`nx_dance_emit.nx` source

↩ module page · 1415 lines · 69317 B
1// nx_dance_emit.nx -- DANCE-MOTION KEYSTONE v2: the being DANCES from REAL third-party mocap (ws=dance-motion 2026-08-10).
2//
3// v2 (operator saw v1 live: "tearing and junky"): the two roots were (1) LOCAL-Euler rotation transfer --
4// with the mocap's collar/spine frames dropped, absolute limb poses were wrong; (2) rigid one-joint
5// binding -- triangles spanning a joint tore into spikes at real dance angles. v2 replaces both:
6//   RETARGET BY POSITION: FK the mocap skeleton per key (world quats+positions from the clip's own
7//   channels), take each segment's WORLD direction (shoulder->elbow, elbow->wrist, hip->knee,
8//   knee->ankle), de-yaw by the dancer's hip axis (torso-relative dance, stable body), mirror X into
9//   our rig's handedness, and drive each bone as the minimal rotation from its rest (-Y) to that
10//   direction. Correct poses BY CONSTRUCTION -- no local-frame luck.
11//   SMOOTH TWO-BONE SKIN: per-vertex second joint + Q14 weight, blending BOTH sides of every joint
12//   pivot over a 150-unit band (child side toward parent, parent side toward child) -- kills the tears.
13// Plus: ONE skin tone (per-part colours read as patches -- the showcase organ measured this first).
14//
15// usage: nx_dance_emit [file.bvh]    default knowledge/fixture_mocapbank.bvh; writes
16//        nx_dance_emit --kat         selftest incl neg-control + exact quat values
17// exit 0 ok | 1 teeth RED | 2 unreadable | 3 usage | 4 REFUSED (parse or joint-map)
18// license_tier: ORIGINAL   No hw writes (Rule 26).   expect_exit: 0
19import "nx_syscalls.nx"
20import "nx_trimesh.nx"
21import "nx_isosurf.nx"
22import "nx_bodyatlas.nx"
23import "nx_gltf_anim.nx"
24import "nx_bvh_lib.nx"
25import "nx_nxa.nx"
26import "nx_clipcap_lib.nx"
27const XD_MAGIC_33333: i64 = 33333
28const XD_MAGIC_1900: i64 = 1900
29const XD_MAGIC_225000000: i64 = 225000000
30const XD_MAGIC_4000: i64 = 4000
31const XD_MAGIC_8000: i64 = 8000
32const XD_MAGIC_3900: i64 = 3900
33const XD_MAGIC_8192: i64 = 8192
34const XD_MAGIC_16384: i64 = 16384
35const XD_MAGIC_116324: i64 = 116324
36const XD_MAGIC_21008: i64 = 21008
37const XD_MAGIC_42008: i64 = 42008
38const XD_MAGIC_16777215: i64 = 16777215
39const XD_MAGIC_4278190080: i64 = 4278190080
40const XD_MAGIC_49008: i64 = 49008
41const XD_MAGIC_56008: i64 = 56008
42const XD_MAGIC_63008: i64 = 63008
43const XD_MAGIC_70008: i64 = 70008
44const XD_MAGIC_112008: i64 = 112008
45const XD_MAGIC_112009: i64 = 112009
46const XD_MAGIC_112010: i64 = 112010
47const XD_MAGIC_112011: i64 = 112011
48const XD_MAGIC_112012: i64 = 112012
49const XD_MAGIC_112013: i64 = 112013
50const XD_MAGIC_112014: i64 = 112014
51const XD_MAGIC_112015: i64 = 112015
52const XD_MAGIC_112016: i64 = 112016
53const XD_MAGIC_112017: i64 = 112017
54const XD_MAGIC_112018: i64 = 112018
55const XD_MAGIC_112019: i64 = 112019
56const XD_MAGIC_112052: i64 = 112052
57const XD_MAGIC_112228: i64 = 112228
58const XD_MAGIC_90000: i64 = 90000
59const XD_MAGIC_2880: i64 = 2880
60const XD_MAGIC_2912: i64 = 2912
61const XD_MAGIC_30000: i64 = 30000
62const XD_MAGIC_40000: i64 = 40000
63const XD_MAGIC_4096: i64 = 4096
64const XD_MAGIC_1231: i64 = 1231
65const XD_MAGIC_1403: i64 = 1403
66const XD_MAGIC_1067: i64 = 1067
67const XD_MAGIC_1179: i64 = 1179
68
69const XD_KEY_US:  i64 = 125000    // 1/8 s -- the writer's exact-f32 time grid
70const XD_MAXK:    i64 = 128       // key cap == the .nxdv wire format's DV_MAXK (16 s at 8 Hz); hitting it is REPORTED, never silent -- 240 here once overran the track region and the viewer refused the blob
71const XD_CIRCLE:  i64 = 25736     // it_* integer-trig full circle (2*PI*4096)
72const XD_MDEG2:   i64 = 720000    // millidegrees in a full circle, x2 (half-angle divisor)
73const XD_FX12:    i64 = 4096
74const XD_NORM_LO: i64 = 3850      // |q|^2/4096 tolerance band
75const XD_NORM_HI: i64 = 4350
76const XD_AXIS_TH: i64 = 50        // 3-axis content threshold (fx12)
77const XD_MOVE_TH: i64 = 100       // motion threshold vs key 0 (fx12)
78const XD_GLBCAP:  i64 = 8388608
79const XD_BAND:    i64 = 180       // smooth-skin blend band around a joint pivot, model units
80const XD_SKIN:    i64 = 11583466  // uniform skin albedo 234 + 192<<8 + 170<<16
81
82// dense being grid -- SAME extents/cell as nx_retarget_emit (the proven export)
83const XD_GX: i64 = 32
84const XD_GY: i64 = 110
85const XD_GZ: i64 = 20
86const XD_GC: i64 = 18
87const XD_OX: i64 = 0-288
88const XD_OY: i64 = 0-990
89const XD_OZ: i64 = 0-180
90const XD_C65536: i64 = 65536
91
92func xd_w(s: *u8) -> i64 { var n: i64=0; while s[n]!=(0 as u8){n=n+1} sys_write(1,s,n); return 0 }
93func xd_num(v: i64) -> i64 {
  let b: *u8 = sys_mmap(32)
  var x: i64 = v; var ng: i64 = 0
  if x < 0 { ng = 1; x = 0-x }
  var i: i64 = 31
  if x == 0 { b[i]=48 as u8; i=i-1 }
  while x > 0 { b[i]=(48+x%10) as u8; x=x/10; i=i-1 }
  if ng == 1 { b[i]=45 as u8; i=i-1 }
  sys_write(1,(b as i64+i+1) as *u8,31-i)
  return 0
103}
104func xd_ru32(buf: *u8, at: i64) -> i64 { return (buf[at] as i64) + ((buf[at+1] as i64)<<8) + ((buf[at+2] as i64)<<16) + ((buf[at+3] as i64)<<24) }
105func xd_hasstr(buf: *u8, n: i64, needle: *u8) -> i64 { var m: i64=0; while needle[m]!=(0 as u8){m=m+1} var i: i64=0; while i+m<=n { var k: i64=0; while k<m { if buf[i+k]!=needle[k] {k=m+9} else {k=k+1} } if k==m {return 1} i=i+1 } return 0 }
106
107// integer floor-sqrt (Newton), for distances and quaternion norms
108func xd_isqrt(n: i64) -> i64 {
  if n <= 0 { return 0 }
  var x: i64 = n
  var y: i64 = (x + 1) / 2
  var it: i64 = 0
  while y < x {
      if it > 64 { y = x }
      else { x = y; y = (x + n/x) / 2; it = it + 1 }
  }
  return x
118}
119
120// joint lookup BY NAME in the parsed skeleton (names = B_NAMEW-strided NUL-terminated rows). -1 = absent.
121func xd_findjoint(names: *u8, nj: i64, want: *u8) -> i64 {
  var j: i64 = 0
  while j < nj {
      let row: *u8 = ((names as i64) + j * B_NAMEW) as *u8
      var i: i64 = 0
      var same: i64 = 1
      var stop: i64 = 0
      while stop == 0 {
          if row[i] != want[i] { same = 0; stop = 1 }
          else { if want[i] == (0 as u8) { stop = 1 } else { i = i + 1 } }
      }
      if same == 1 { return j }
      j = j + 1
  }
  return 0 - 1
136}
137
138// axis quaternion from a millidegree angle, fx12 components into o[0..3] (x,y,z,w)
139func xd_qaxis(chcode: i64, mdeg: i64, o: *i64) -> i64 {
  let half_it: i64 = mdeg * XD_CIRCLE / XD_MDEG2
  let s: i64 = it_sin4096(half_it)
  let c: i64 = it_cos4096(half_it)
  o[0]=0; o[1]=0; o[2]=0; o[3]=c
  if chcode == B_CH_XROT { o[0]=s }
  if chcode == B_CH_YROT { o[1]=s }
  if chcode == B_CH_ZROT { o[2]=s }
  return 0
148}
149
150// Hamilton product o = a * b, all fx12
151func xd_qmul(a: *i64, b: *i64, o: *i64) -> i64 {
  let x: i64 = ( a[3]*b[0] + a[0]*b[3] + a[1]*b[2] - a[2]*b[1] ) / XD_FX12
  let y: i64 = ( a[3]*b[1] - a[0]*b[2] + a[1]*b[3] + a[2]*b[0] ) / XD_FX12
  let z: i64 = ( a[3]*b[2] + a[0]*b[1] - a[1]*b[0] + a[2]*b[3] ) / XD_FX12
  let w: i64 = ( a[3]*b[3] - a[0]*b[0] - a[1]*b[1] - a[2]*b[2] ) / XD_FX12
  o[0]=x; o[1]=y; o[2]=z; o[3]=w
  return 0
158}
159
160// rotate a vector (any integer units) by an fx12 quaternion: r = q (x) (v,0) (x) conj(q). Unit-preserving.
161func xd_qrotv(q: *i64, vx: i64, vy: i64, vz: i64, o: *i64, s1: *i64, s2: *i64, s3: *i64) -> i64 {
  s1[0]=vx; s1[1]=vy; s1[2]=vz; s1[3]=0
  xd_qmul(q, s1, s2)
  s3[0]=0-q[0]; s3[1]=0-q[1]; s3[2]=0-q[2]; s3[3]=q[3]
  xd_qmul(s2, s3, s1)
  o[0]=s1[0]; o[1]=s1[1]; o[2]=s1[2]
  return 0
168}
169
170// minimal rotation taking rest (0,-1,0) to a NORMALIZED fx12 direction. q_raw = (-dz, 0, dx, 4096-dy),
171// renormalized. Degenerate straight-up dir -> 180deg about X.
172func xd_qfromdir(dx: i64, dy: i64, dz: i64, o: *i64) -> i64 {
  o[0] = 0 - dz
  o[1] = 0
  o[2] = dx
  o[3] = XD_FX12 - dy
  let n2: i64 = o[0]*o[0] + o[1]*o[1] + o[2]*o[2] + o[3]*o[3]
  if n2 < 16 { o[0]=XD_FX12; o[1]=0; o[2]=0; o[3]=0; return 0 }
  let nn: i64 = xd_isqrt(n2)
  o[0]=o[0]*XD_FX12/nn; o[1]=o[1]*XD_FX12/nn; o[2]=o[2]*XD_FX12/nn; o[3]=o[3]*XD_FX12/nn
  return 0
182}
183
184// compose one joint's local rotation at one frame from its channels IN FILE ORDER -> fx12 quat in q
185func xd_joint_quat(fv: *i64, chan0j: i64, nchanj: i64, chtype: *i64, q: *i64, qa: *i64, qt: *i64) -> i64 {
  q[0]=0; q[1]=0; q[2]=0; q[3]=XD_FX12
  var c: i64 = 0
  while c < nchanj {
      let ci: i64 = chan0j + c
      let t: i64 = chtype[ci]
      var isrot: i64 = 0
      if t == B_CH_XROT { isrot = 1 }
      if t == B_CH_YROT { isrot = 1 }
      if t == B_CH_ZROT { isrot = 1 }
      if isrot == 1 {
          xd_qaxis(t, fv[ci], qa)
          xd_qmul(q, qa, qt)
          q[0]=qt[0]; q[1]=qt[1]; q[2]=qt[2]; q[3]=qt[3]
      }
      c = c + 1
  }
  return 0
203}
204
205// ===== KAT =====
206func xd_cat(b: *u8, o: i64, s: *u8) -> i64 { let n: i64 = b_slen(s); var i: i64 = 0; while i < n { b[o+i]=s[i]; i=i+1 } return o+n }
207func xd_kat() -> i64 {
  var red: i64 = 0
  // T1: axis-quat exact value -- Zrot 90000 mdeg -> half 45 deg -> sin=cos=2896 fx12
  let qa: *i64 = sys_mmap(32) as *i64
  xd_qaxis(B_CH_ZROT, XD_MAGIC_90000, qa)
  xd_w("T1 qaxis Z90: qz=" as *u8); xd_num(qa[2]); xd_w(" qw=" as *u8); xd_num(qa[3])
  var t1: i64 = 0
  if qa[2] > XD_MAGIC_2880 { if qa[2] < XD_MAGIC_2912 { if qa[3] > XD_MAGIC_2880 { if qa[3] < XD_MAGIC_2912 { if qa[0] == 0 { if qa[1] == 0 { t1 = 1 } } } } } }
  if t1 == 1 { xd_w(" GREEN\n" as *u8) } else { xd_w(" RED\n" as *u8); red = red + 1 }
  // T2: identity * q == q (qmul sanity)
  let qi: *i64 = sys_mmap(32) as *i64
  let qo: *i64 = sys_mmap(32) as *i64
  qi[0]=0; qi[1]=0; qi[2]=0; qi[3]=XD_FX12
  xd_qmul(qi, qa, qo)
  var t2: i64 = 0
  if qo[2] == qa[2] { if qo[3] == qa[3] { t2 = 1 } }
  if t2 == 1 { xd_w("T2 GREEN qmul-identity\n" as *u8) } else { xd_w("T2 RED qmul-identity\n" as *u8); red = red + 1 }
  // T3: norm preserved through a 3-rotation composition
  let qb: *i64 = sys_mmap(32) as *i64
  let qc: *i64 = sys_mmap(32) as *i64
  xd_qaxis(B_CH_ZROT, XD_MAGIC_30000, qb)
  xd_qmul(qa, qb, qc)
  xd_qaxis(B_CH_XROT, XD_MAGIC_40000, qb)
  xd_qmul(qc, qb, qo)
  let n2: i64 = (qo[0]*qo[0] + qo[1]*qo[1] + qo[2]*qo[2] + qo[3]*qo[3]) / XD_FX12
  xd_w("T3 norm2/4096=" as *u8); xd_num(n2)
  var t3: i64 = 0
  if n2 > XD_NORM_LO { if n2 < XD_NORM_HI { t3 = 1 } }
  if t3 == 1 { xd_w(" GREEN\n" as *u8) } else { xd_w(" RED\n" as *u8); red = red + 1 }
  // T4 neg-control-missing-joint: a 2-joint fixture WITHOUT the required names must map to -1
  let fb: *u8 = sys_mmap(XD_MAGIC_4096)
  var o: i64 = 0
  o = xd_cat(fb, o, "HIERARCHY\nROOT Hips\n{\nOFFSET 0.0 0.0 0.0\nCHANNELS 6 Xposition Yposition Zposition Zrotation Xrotation Yrotation\nJOINT Chest\n{\nOFFSET 0.0 5.0 0.0\nCHANNELS 3 Zrotation Xrotation Yrotation\nEnd Site\n{\nOFFSET 0.0 5.0 0.0\n}\n}\n}\nMOTION\nFrames: 1\nFrame Time: 0.033333\n0.0 10.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0\n" as *u8)
  fb[o] = 0 as u8
  let H: *i64 = sys_mmap(B_H_WORDS * 8) as *i64
  let names: *u8 = sys_mmap(B_MAX_JOINTS * B_NAMEW)
  let parent: *i64 = sys_mmap(B_MAX_JOINTS * 8) as *i64
  let nchan: *i64 = sys_mmap(B_MAX_JOINTS * 8) as *i64
  let chan0: *i64 = sys_mmap(B_MAX_JOINTS * 8) as *i64
  let joff: *i64 = sys_mmap(B_MAX_JOINTS * 24) as *i64
  let chtype: *i64 = sys_mmap(B_MAX_CHAN * 8) as *i64
  let pr: i64 = b_parse(fb, o, H, names, parent, nchan, chan0, joff, chtype)
  var t4: i64 = 0
  if pr == 0 {
      let wantL: *u8 = "LeftShoulder" as *u8
      if xd_findjoint(names, H[B_H_NJOINT], wantL) == 0 - 1 { t4 = 1 }
  }
  if t4 == 1 { xd_w("T4 GREEN neg-control-missing-joint maps to -1 (caller REFUSES)\n" as *u8) } else { xd_w("T4 RED neg-control\n" as *u8); red = red + 1 }
  // T5: findjoint positive control on the same fixture
  let wantH: *u8 = "Chest" as *u8
  if xd_findjoint(names, H[B_H_NJOINT], wantH) == 1 { xd_w("T5 GREEN findjoint positive (Chest=1)\n" as *u8) } else { xd_w("T5 RED findjoint\n" as *u8); red = red + 1 }
  // T6: qfromdir on straight-down rest dir -> identity rotation
  xd_qfromdir(0, 0-XD_FX12, 0, qo)
  var t6: i64 = 0
  if qo[0] == 0 { if qo[1] == 0 { if qo[2] == 0 { if qo[3] == XD_FX12 { t6 = 1 } } } }
  if t6 == 1 { xd_w("T6 GREEN qfromdir(down)=identity\n" as *u8) } else { xd_w("T6 RED qfromdir(down): " as *u8); xd_num(qo[0]); xd_w(","as *u8); xd_num(qo[3]); xd_w("\n" as *u8); red = red + 1 }
  // T7: qfromdir(+X) rotates rest(-Y) onto +X (round-trip through xd_qrotv)
  xd_qfromdir(XD_FX12, 0, 0, qo)
  let s1: *i64 = sys_mmap(32) as *i64
  let s2: *i64 = sys_mmap(32) as *i64
  let s3: *i64 = sys_mmap(32) as *i64
  let rv: *i64 = sys_mmap(32) as *i64
  xd_qrotv(qo, 0, 0-XD_FX12, 0, rv, s1, s2, s3)
  xd_w("T7 qrotv(rest by qfromdir(+X)) = " as *u8); xd_num(rv[0]); xd_w(","as *u8); xd_num(rv[1]); xd_w(","as *u8); xd_num(rv[2])
  var t7: i64 = 0
  if rv[0] > XD_MAGIC_3900 { if rv[1] > 0-300 { if rv[1] < 300 { if rv[2] > 0-300 { if rv[2] < 300 { t7 = 1 } } } } }
  if t7 == 1 { xd_w(" GREEN\n" as *u8) } else { xd_w(" RED\n" as *u8); red = red + 1 }
  if red > 0 { xd_w("nx_dance_emit KAT RED teeth_failed=" as *u8); xd_num(red); xd_w("\n" as *u8); return 1 }
  xd_w("nx_dance_emit KAT GREEN 7/7\n" as *u8)
  return 0
277}
278
279// minimal rotation taking unit vector a to unit vector b (both fx12). Output q fx12. Antiparallel
280// falls back to 180deg about a deterministic perpendicular of a (smallest-component axis).
281func xd_qfromto(ax: i64, ay: i64, az: i64, bx: i64, by: i64, bz: i64, qo: *i64) -> i64 {
  let cx: i64 = (ay*bz - az*by)/XD_FX12
  let cy: i64 = (az*bx - ax*bz)/XD_FX12
  let cz: i64 = (ax*by - ay*bx)/XD_FX12
  var w: i64 = XD_FX12 + (ax*bx + ay*by + az*bz)/XD_FX12
  if w < 41 {
      var px: i64 = 0 - az
      var py: i64 = 0
      var pz: i64 = ax
      var aax: i64 = ax
      if aax < 0 { aax = 0 - aax }
      var aay: i64 = ay
      if aay < 0 { aay = 0 - aay }
      var aaz: i64 = az
      if aaz < 0 { aaz = 0 - aaz }
      if aax <= aay { if aax <= aaz { px = 0; py = 0 - az; pz = ay } }
      let pn: i64 = xd_isqrt(px*px + py*py + pz*pz)
      if pn < 1 { qo[0]=0; qo[1]=0; qo[2]=0; qo[3]=XD_FX12; return 0 }
      qo[0]=px*XD_FX12/pn; qo[1]=py*XD_FX12/pn; qo[2]=pz*XD_FX12/pn; qo[3]=0
      return 0
  }
  let n: i64 = xd_isqrt(cx*cx + cy*cy + cz*cz + w*w)
  if n < 1 { qo[0]=0; qo[1]=0; qo[2]=0; qo[3]=XD_FX12; return 0 }
  qo[0]=cx*XD_FX12/n; qo[1]=cy*XD_FX12/n; qo[2]=cz*XD_FX12/n; qo[3]=w*XD_FX12/n
  return 0
306}
307// bind segment dir joint(cj) minus joint(pj), fx12-normalized, NXA frame. SKEL row = 8 words
308// [parent, x, y, z, ...] at word sow+1+j*8 (the ntx_apply-verified layout).
309func xd_nxa_seg(W: *i64, sow: i64, cj: i64, pj: i64, o: *i64) -> i64 {
  let ax: i64 = W[sow+1+cj*8+1] - W[sow+1+pj*8+1]
  let ay: i64 = W[sow+1+cj*8+2] - W[sow+1+pj*8+2]
  let az: i64 = W[sow+1+cj*8+3] - W[sow+1+pj*8+3]
  var n: i64 = xd_isqrt(ax*ax + ay*ay + az*az)
  if n < 1 { n = 1 }
  o[0] = ax*XD_FX12/n
  o[1] = ay*XD_FX12/n
  o[2] = az*XD_FX12/n
  return 0
319}
320// ---- M1 ADOPTION: retargeted mocap -> chn-2 ANIM section spliced into the RIGGED NXA body ----
321// dtrk = 8 limb-segment WORLD dirs per key (fx12, dance frame: X lateral with mocap-left already
322// mirrored to -X, Y up, Z fwd). NXA frame is X lateral / Y BACK (chest DYNA at -y) / Z up, so
323// dance->NXA = (x, -z, y). Wire (decoded from the game player, the working consumer): chn==2,
324// 16B/key LE = u16 t_ms, i16 q[4] (WORLD rotation; scale free -- the player nlerp-normalizes;
325// we pack fx12), i16 d[3] = 0 (in-place BY THE LANE'S DESIGN: the FK zeroes root translation,
326// the organ owns where she is). Wrists carry the forearm D and ankles the shin D (hand/foot
327// continue their parent segment; the player's own hand-collapse + ankle fix ride on top).
328// 12 tracks; every untracked joint holds bind pose, which is correct stillness not a gap.
329// Role resolution is MEASURED-data-driven (probe 2026-08-12): fingertip = argmax side.x; wrist =
330// first ancestor whose parent-segment exceeds 15cm (forearm; finger segments are 2-4cm); elbow/
331// shoulder = its ancestors (this also dodges the twist-helper duplicates, which are SIBLINGS not
332// ancestors); ankle = the unique off-midline joint in the shank band with its parent above the
333// knee line; knee/hip = its ancestors. Every chain is ordering-asserted; ambiguity REFUSES.
334// DECLARED ASSUMPTION (eye-verify on first render): mocap-left maps to the NXA -x side.
335func xd_nxa_apply(inp: *u8, outp: *u8, dtrk: *i64, nk: i64, keyus: i64, ttrk: *i64, atrk: *i64) -> i64 {
  let lp: *i64 = sys_mmap(16) as *i64
  let b: *u8 = sys_read_file(inp, lp)
  if (b as i64) == 0 { xd_w("NXA-ANIM REFUSED: cannot read input NXA\n" as *u8); return 4 }
  let flen: i64 = lp[0]
  let W: *i64 = b as *i64
  let sow: i64 = nxa_find(b, flen, nxa_tag4("SKEL" as *u8))
  if sow < 1 { xd_w("NXA-ANIM REFUSED: SKEL missing or corrupt\n" as *u8); return 4 }
  let ns: i64 = W[2]
  if ns > 62 { xd_w("NXA-ANIM REFUSED: section table full\n" as *u8); return 4 }
  let nj: i64 = W[sow]
  if nj < 12 { xd_w("NXA-ANIM REFUSED: too few joints\n" as *u8); return 4 }
  var zmn: i64 = W[sow+1+3]
  var jz: i64 = 0
  while jz < nj {
      if W[sow+1+jz*8+3] < zmn { zmn = W[sow+1+jz*8+3] }
      jz = jz + 1
  }
  let R: *i64 = sys_mmap(16*8) as *i64
  var sdi: i64 = 0
  while sdi < 2 {
      var sgn: i64 = 1
      if sdi == 1 { sgn = 0 - 1 }
      var ft: i64 = 0 - 1
      var ftx: i64 = 0
      var j2: i64 = 0
      while j2 < nj {
          let xv: i64 = W[sow+1+j2*8+1]*sgn
          if xv > ftx { ftx = xv; ft = j2 }
          j2 = j2 + 1
      }
      if ft < 0 { xd_w("NXA-ANIM REFUSED: no joints on one side\n" as *u8); return 4 }
      var wr: i64 = 0 - 1
      var cu: i64 = ft
      var guard: i64 = 0
      while guard < 64 {
          let pj: i64 = W[sow+1+cu*8]
          if pj < 0 { guard = 64 } else {
              let dx: i64 = W[sow+1+cu*8+1] - W[sow+1+pj*8+1]
              let dy: i64 = W[sow+1+cu*8+2] - W[sow+1+pj*8+2]
              let dz: i64 = W[sow+1+cu*8+3] - W[sow+1+pj*8+3]
              if dx*dx + dy*dy + dz*dz > XD_MAGIC_225000000 { wr = cu; guard = 64 } else { cu = pj; guard = guard + 1 }
          }
      }
      if wr < 1 { xd_w("NXA-ANIM REFUSED: wrist not found (no 15cm segment above the fingertip)\n" as *u8); return 4 }
      let el: i64 = W[sow+1+wr*8]
      if el < 0 { xd_w("NXA-ANIM REFUSED: wrist has no parent\n" as *u8); return 4 }
      let sh: i64 = W[sow+1+el*8]
      if sh < 0 { xd_w("NXA-ANIM REFUSED: elbow has no parent\n" as *u8); return 4 }
      var an: i64 = 0 - 1
      var anc: i64 = 0
      var j3: i64 = 0
      while j3 < nj {
          let xr: i64 = W[sow+1+j3*8+1]*sgn
          let zr: i64 = W[sow+1+j3*8+3] - zmn
          let pj3: i64 = W[sow+1+j3*8]
          if xr > XD_MAGIC_4000 { if zr > XD_MAGIC_8000 { if zr < XD_MAGIC_30000 { if pj3 >= 0 {
              if W[sow+1+pj3*8+3] - zmn > XD_MAGIC_40000 { an = j3; anc = anc + 1 }
          } } } }
          j3 = j3 + 1
      }
      if anc != 1 { xd_w("NXA-ANIM REFUSED: ankle ambiguous count=" as *u8); xd_num(anc); xd_w("\n" as *u8); return 4 }
      let kn: i64 = W[sow+1+an*8]
      let hp: i64 = W[sow+1+kn*8]
      if hp < 0 { xd_w("NXA-ANIM REFUSED: knee has no parent\n" as *u8); return 4 }
      if W[sow+1+sh*8+3] <= W[sow+1+el*8+3] { xd_w("NXA-ANIM REFUSED: arm chain z-order wrong\n" as *u8); return 4 }
      if W[sow+1+el*8+3] <= W[sow+1+wr*8+3] { xd_w("NXA-ANIM REFUSED: forearm z-order wrong\n" as *u8); return 4 }
      if W[sow+1+hp*8+3] <= W[sow+1+kn*8+3] { xd_w("NXA-ANIM REFUSED: leg chain z-order wrong\n" as *u8); return 4 }
      R[sdi*6]=sh; R[sdi*6+1]=el; R[sdi*6+2]=wr; R[sdi*6+3]=hp; R[sdi*6+4]=kn; R[sdi*6+5]=an
      sdi = sdi + 1
  }
  xd_w("NXA-ANIM roles +x sh/el/wr/hp/kn/an=" as *u8)
  xd_num(R[0]); xd_w("/" as *u8); xd_num(R[1]); xd_w("/" as *u8); xd_num(R[2]); xd_w("/" as *u8)
  xd_num(R[3]); xd_w("/" as *u8); xd_num(R[4]); xd_w("/" as *u8); xd_num(R[5])
  xd_w("  -x=" as *u8)
  xd_num(R[6]); xd_w("/" as *u8); xd_num(R[7]); xd_w("/" as *u8); xd_num(R[8]); xd_w("/" as *u8)
  xd_num(R[9]); xd_w("/" as *u8); xd_num(R[10]); xd_w("/" as *u8); xd_num(R[11]); xd_w("\n" as *u8)
  // ---- ZOMBIE-ARMS FIX (operator RED 2026-08-12, "crazy arms"): the player has NO runtime
  // hierarchy, and its OWN load comment documents this exact class -- "forearms pinned at T-pose
  // pivots because their world displacement was dropped at apply time". The first emit set d=0 on
  // every track and reproduced it verbatim. Each chain therefore PROPAGATES its pivots: the mid
  // joint rides the rotated upper segment about the proximal pivot, the distal joint rides the
  // rotated lower segment about the MOVED mid pivot; the dt lanes carry pivot_new - pivot_bind
  // (stored /100: binds are 0.01mm units, the wire is integer mm, the player multiplies x100).
  // Per chain: proximal track = upper D, dt 0 (its pivot rides the untracked torso/pelvis = bind);
  // mid + distal tracks = lower D with propagated dt. dance bones: 1 L-upper 2 L-fore 3 R-upper
  // 4 R-fore 5 L-thigh 6 L-shin 7 R-thigh 8 R-shin; mocap-left rides -x roles, mocap-right +x.
  // ---- SUBTREE-COMPLETE TRACKS (operator RED #2, "still a mess", 2026-08-12): the rig weights
  // flesh to TWIST HELPERS (mid-upper-arm 75, elbow twists 55/57, forearm twist chains, mid-thigh
  // 20, mid-shin 17...) -- the estate's own 07-29 note names the result of leaving them behind:
  // "ribbon forearms". Three role tracks per limb can NEVER drive this rig; EVERY joint in each
  // limb subtree must ride its segment rigidly. Lane by ancestor walk: in subtree(elbow/knee) ->
  // LOWER lane (forearm/shin D about the MOVED mid pivot); else in subtree(shoulder/hip) -> UPPER
  // lane (thigh/upper-arm D about the proximal pivot). One uniform row per joint g:
  // dt_g = pivotNew + rot(qLane, b_g - laneBindBase) - b_g, so fingers, toes and every helper
  // land exactly where their segment carries them (the player's hand-collapse then agrees).
  let CU: *i64 = sys_mmap(4*8) as *i64
  let CL: *i64 = sys_mmap(4*8) as *i64
  let CP: *i64 = sys_mmap(4*8) as *i64
  let CM: *i64 = sys_mmap(4*8) as *i64
  CU[0]=1; CL[0]=2; CP[0]=R[6]; CM[0]=R[7]
  CU[1]=3; CL[1]=4; CP[1]=R[0]; CM[1]=R[1]
  CU[2]=5; CL[2]=6; CP[2]=R[9]; CM[2]=R[10]
  CU[3]=7; CL[3]=8; CP[3]=R[3]; CM[3]=R[4]
  let LN: *i64 = sys_mmap(nj*8 + 64) as *i64
  var lg: i64 = 0
  while lg < nj {
      LN[lg] = 0 - 1
      var c2: i64 = 0
      while c2 < 4 {
          var cu2: i64 = lg
          var gd: i64 = 0
          var lane: i64 = 0 - 1
          while gd < 64 {
              if cu2 == CM[c2] { lane = c2*2 + 1; gd = 64 }
              else { if cu2 == CP[c2] { lane = c2*2; gd = 64 }
              else { cu2 = W[sow+1+cu2*8]
                     if cu2 < 0 { gd = 64 } else { gd = gd + 1 } } }
          }
          if lane >= 0 { LN[lg] = lane; c2 = 4 } else { c2 = c2 + 1 }
      }
      lg = lg + 1
  }
  // ---- M1-TORSO (debt 1786598036): the torso is TRACKED, not bind-held. qT per key = minimal
  // rotation from the NXA's OWN bind spine (hip-centre -> shoulder-centre) to the captured,
  // de-yawed mocap spine. LEAN-ONLY v1: shoulder-axis twist deliberately deferred (declared).
  let hcx: i64 = (W[sow+1+R[3]*8+1] + W[sow+1+R[9]*8+1])/2
  let hcy: i64 = (W[sow+1+R[3]*8+2] + W[sow+1+R[9]*8+2])/2
  let hcz: i64 = (W[sow+1+R[3]*8+3] + W[sow+1+R[9]*8+3])/2
  var tdx: i64 = (W[sow+1+R[0]*8+1] + W[sow+1+R[6]*8+1])/2 - hcx
  var tdy: i64 = (W[sow+1+R[0]*8+2] + W[sow+1+R[6]*8+2])/2 - hcy
  var tdz: i64 = (W[sow+1+R[0]*8+3] + W[sow+1+R[6]*8+3])/2 - hcz
  var tdn: i64 = xd_isqrt(tdx*tdx + tdy*tdy + tdz*tdz)
  if tdn < 1 { tdn = 1 }
  tdx = tdx*XD_FX12/tdn
  tdy = tdy*XD_FX12/tdn
  tdz = tdz*XD_FX12/tdn
  // NXA bind shoulder axis (-x-side shoulder minus +x-side: mocap-left rides -x roles)
  var bax: i64 = W[sow+1+R[6]*8+1] - W[sow+1+R[0]*8+1]
  var bay: i64 = W[sow+1+R[6]*8+2] - W[sow+1+R[0]*8+2]
  var baz: i64 = W[sow+1+R[6]*8+3] - W[sow+1+R[0]*8+3]
  var ban: i64 = xd_isqrt(bax*bax + bay*bay + baz*baz)
  if ban < 1 { ban = 1 }
  bax = bax*XD_FX12/ban
  bay = bay*XD_FX12/ban
  baz = baz*XD_FX12/ban
  // TWO-VECTOR chest frame per key: q1 aligns the spine (LEAN), q2 then aligns the shoulder
  // axis (TWIST -- its residual axis ~ the leaned spine, second-order error only); qT = q2*q1.
  // The twist is what gives a crossing arm its forward clearance (probe-proven at key 78).
  let qTc: *i64 = sys_mmap(nk*4*8 + 64) as *i64
  let q1T: *i64 = sys_mmap(32) as *i64
  let q2T: *i64 = sys_mmap(32) as *i64
  let rvT: *i64 = sys_mmap(32) as *i64
  let s1T: *i64 = sys_mmap(32) as *i64
  let s2T: *i64 = sys_mmap(32) as *i64
  let s3T: *i64 = sys_mmap(32) as *i64
  var kT: i64 = 0
  while kT < nk {
      xd_qfromto(tdx, tdy, tdz, ttrk[kT*6], 0 - ttrk[kT*6+2], ttrk[kT*6+1], q1T)
      xd_qrotv(q1T, bax, bay, baz, rvT, s1T, s2T, s3T)
      xd_qfromto(rvT[0], rvT[1], rvT[2], ttrk[kT*6+3], 0 - ttrk[kT*6+5], ttrk[kT*6+4], q2T)
      xd_qmul(q2T, q1T, ((qTc as i64) + kT*32) as *i64)
      kT = kT + 1
  }
  let TF: *i64 = sys_mmap(nj*8 + 64) as *i64
  var tf2: i64 = 0
  while tf2 < nj {
      TF[tf2] = 0
      if LN[tf2] < 0 { if W[sow+1+tf2*8+3] >= hcz { TF[tf2] = 1 } }
      tf2 = tf2 + 1
  }
  var ntr: i64 = 0
  var ntor: i64 = 0
  var g2: i64 = 0
  while g2 < nj {
      if LN[g2] >= 0 { ntr = ntr + 1 } else { if TF[g2] == 1 { ntr = ntr + 1; ntor = ntor + 1 } }
      g2 = g2 + 1
  }
  xd_w("NXA-ANIM subtree tracks=" as *u8); xd_num(ntr); xd_w(" of " as *u8); xd_num(nj)
  xd_w(" joints (torso tracked=" as *u8); xd_num(ntor); xd_w(")\n" as *u8)
  // per-chain per-key quats + moved mid pivots, precomputed once
  let sdU: *i64 = sys_mmap(32) as *i64
  let sdL: *i64 = sys_mmap(32) as *i64
  let rv2: *i64 = sys_mmap(32) as *i64
  let t1: *i64 = sys_mmap(32) as *i64
  let t2: *i64 = sys_mmap(32) as *i64
  let t3: *i64 = sys_mmap(32) as *i64
  let qUc: *i64 = sys_mmap(4*nk*4*8) as *i64
  let qLc: *i64 = sys_mmap(4*nk*4*8) as *i64
  let mNc: *i64 = sys_mmap(4*nk*3*8) as *i64
  let pPc: *i64 = sys_mmap(4*nk*3*8 + 64) as *i64   // per-chain per-key PROXIMAL pivot (torso-rebased for arms)
  var ikfb9: i64 = 0                                 // M1-ARM-IK: keys that fell back to the direction lane
  var ch: i64 = 0
  while ch < 4 {
      let jP: i64 = CP[ch]
      let jM: i64 = CM[ch]
      // lower-lane bind dir needs the distal role: reuse the resolver's R rows (wr/an sit at +2/+5)
      var jD: i64 = 0
      if ch == 0 { jD = R[8] }
      if ch == 1 { jD = R[2] }
      if ch == 2 { jD = R[11] }
      if ch == 3 { jD = R[5] }
      xd_nxa_seg(W, sow, jM, jP, sdU)
      xd_nxa_seg(W, sow, jD, jM, sdL)
      // M1-ARM-IK: OUR bind segment lengths (W units) for the two-bone solve
      let uax9: i64 = W[sow+1+jM*8+1] - W[sow+1+jP*8+1]
      let uay9: i64 = W[sow+1+jM*8+2] - W[sow+1+jP*8+2]
      let uaz9: i64 = W[sow+1+jM*8+3] - W[sow+1+jP*8+3]
      var aU9: i64 = xd_isqrt(uax9*uax9 + uay9*uay9 + uaz9*uaz9)
      if aU9 < 1 { aU9 = 1 }
      let lbx9: i64 = W[sow+1+jD*8+1] - W[sow+1+jM*8+1]
      let lby9: i64 = W[sow+1+jD*8+2] - W[sow+1+jM*8+2]
      let lbz9: i64 = W[sow+1+jD*8+3] - W[sow+1+jM*8+3]
      var bL9: i64 = xd_isqrt(lbx9*lbx9 + lby9*lby9 + lbz9*lbz9)
      if bL9 < 1 { bL9 = 1 }
      var k4: i64 = 0
      while k4 < nk {
          let dbU: i64 = ((CU[ch]-1)*nk + k4)*3
          let dbL: i64 = ((CL[ch]-1)*nk + k4)*3
          let qb: i64 = (ch*nk + k4)*4
          // pivot FIRST (moved above the IK, which needs it): ARM chains (0,1) ride the TRACKED
          // torso -- the clearance mechanism; LEG chains keep the bind pivot (pelvis residual
          // ~ identity post-de-yaw)
          var bpx9: i64 = W[sow+1+jP*8+1]
          var bpy9: i64 = W[sow+1+jP*8+2]
          var bpz9: i64 = W[sow+1+jP*8+3]
          if ch < 2 {
              xd_qrotv(((qTc as i64) + k4*32) as *i64, bpx9 - hcx, bpy9 - hcy, bpz9 - hcz, rv2, t1, t2, t3)
              bpx9 = hcx + rv2[0]
              bpy9 = hcy + rv2[1]
              bpz9 = hcz + rv2[2]
          }
          var ikok: i64 = 0
          if ch < 2 {
              // M1-ARM-IK v2 (debt 1786598036): shoulder-relative retarget CANNOT preserve torso
              // clearance when the shoulder-to-axis distance differs between bodies (measured at
              // the worst key: source wrist 201mm from its axis; the shoulder-relative solve put
              // ours at 40mm, no better than direction-copy). So the wrist is retargeted in the
              // TORSO frame: offset from the HIP CENTRE, scaled by the spine-length ratio
              // (tdn/sn9 -- the same stature-class bridge the clipcheck ruler uses), then a
              // two-bone solve from OUR tracked shoulder pivot with the mocap bend-plane hint.
              // Axis clearance is inherited from the data BY CONSTRUCTION; arm shape adapts.
              // dance->NXA map (x,-z,y) on the RAW atrk offsets, matching the dtrk convention.
              let ab8: i64 = k4*20 + 1 + ch*9
              let sn8: i64 = atrk[k4*20]
              // slots ab8+0..2 = the mocap SHOULDER hip-offset (banked for the future twist lane)
              let emx: i64 = atrk[ab8+3]
              let emy: i64 = 0 - atrk[ab8+5]
              let emz: i64 = atrk[ab8+4]
              let wmx: i64 = atrk[ab8+6]
              let wmy: i64 = 0 - atrk[ab8+8]
              let wmz: i64 = atrk[ab8+7]
              if sn8 > 0 {
                  let sc9: i64 = tdn*XD_FX12/sn8
                  let twx: i64 = hcx + wmx*sc9/XD_FX12
                  let twy: i64 = hcy + wmy*sc9/XD_FX12
                  let twz: i64 = hcz + wmz*sc9/XD_FX12
                  let cx9: i64 = twx - bpx9
                  let cy9: i64 = twy - bpy9
                  let cz9: i64 = twz - bpz9
                  var cn9: i64 = xd_isqrt(cx9*cx9 + cy9*cy9 + cz9*cz9)
                  if cn9 < 1 { cn9 = 1 }
                  let lr9: i64 = aU9 + bL9
                  var dmin9: i64 = aU9 - bL9
                  if dmin9 < 0 { dmin9 = 0 - dmin9 }
                  dmin9 = dmin9 + 1
                  var d9: i64 = cn9
                  if d9 < dmin9 { d9 = dmin9 }
                  if d9 > lr9 - 1 { d9 = lr9 - 1 }
                  let ux9: i64 = cx9*XD_FX12/cn9
                  let uy9: i64 = cy9*XD_FX12/cn9
                  let uz9: i64 = cz9*XD_FX12/cn9
                  // bend hint v2b: OUR pivot -> the SCALED mocap elbow position (hip frame). Its
                  // perp about OUR chord steers the elbow toward the mocap elbow's ABSOLUTE
                  // torso-frame position (clean in the source), not merely its bend plane --
                  // measured: plane-only left the elbow at 68mm from the axis (worst 71mm).
                  // (x64 scale keeps angular resolution in integers)
                  let hbx: i64 = hcx + emx*sc9/XD_FX12 - bpx9
                  let hby: i64 = hcy + emy*sc9/XD_FX12 - bpy9
                  let hbz: i64 = hcz + emz*sc9/XD_FX12 - bpz9
                  let hdu: i64 = (hbx*ux9 + hby*uy9 + hbz*uz9)/XD_FX12
                  let px9: i64 = hbx*64 - hdu*ux9/64
                  let py9: i64 = hby*64 - hdu*uy9/64
                  let pz9: i64 = hbz*64 - hdu*uz9/64
                  let pn9: i64 = xd_isqrt(px9*px9 + py9*py9 + pz9*pz9)
                  var x9: i64 = (aU9*aU9 - bL9*bL9 + d9*d9)/(2*d9)
                  if x9 > aU9 { x9 = aU9 }
                  if x9 < 0 - bL9 { x9 = 0 - bL9 }
                  var y29: i64 = aU9*aU9 - x9*x9
                  if y29 < 0 { y29 = 0 }
                  var y9: i64 = xd_isqrt(y29)
                  if pn9 < 1 { y9 = 0 }
                  var ex9: i64 = ux9*x9/XD_FX12
                  var ey9: i64 = uy9*x9/XD_FX12
                  var ez9: i64 = uz9*x9/XD_FX12
                  if y9 > 0 {
                      ex9 = ex9 + px9*y9/pn9
                      ey9 = ey9 + py9*y9/pn9
                      ez9 = ez9 + pz9*y9/pn9
                  }
                  let tx9: i64 = ux9*d9/XD_FX12
                  let ty9: i64 = uy9*d9/XD_FX12
                  let tz9: i64 = uz9*d9/XD_FX12
                  var en9: i64 = xd_isqrt(ex9*ex9 + ey9*ey9 + ez9*ez9)
                  if en9 < 1 { en9 = 1 }
                  var fx9: i64 = tx9 - ex9
                  var fy9: i64 = ty9 - ey9
                  var fz9: i64 = tz9 - ez9
                  var fn9: i64 = xd_isqrt(fx9*fx9 + fy9*fy9 + fz9*fz9)
                  if fn9 < 1 { fn9 = 1 }
                  xd_qfromto(sdU[0], sdU[1], sdU[2], ex9*XD_FX12/en9, ey9*XD_FX12/en9, ez9*XD_FX12/en9, ((qUc as i64) + qb*8) as *i64)
                  xd_qfromto(sdL[0], sdL[1], sdL[2], fx9*XD_FX12/fn9, fy9*XD_FX12/fn9, fz9*XD_FX12/fn9, ((qLc as i64) + qb*8) as *i64)
                  ikok = 1
              }
              if ikok == 0 { ikfb9 = ikfb9 + 1 }
          }
          if ikok == 0 {
              xd_qfromto(sdU[0], sdU[1], sdU[2], dtrk[dbU], 0 - dtrk[dbU+2], dtrk[dbU+1], ((qUc as i64) + qb*8) as *i64)
              xd_qfromto(sdL[0], sdL[1], sdL[2], dtrk[dbL], 0 - dtrk[dbL+2], dtrk[dbL+1], ((qLc as i64) + qb*8) as *i64)
          }
          let pb8: i64 = (ch*nk + k4)*3
          pPc[pb8]   = bpx9
          pPc[pb8+1] = bpy9
          pPc[pb8+2] = bpz9
          xd_qrotv(((qUc as i64) + qb*8) as *i64, W[sow+1+jM*8+1] - W[sow+1+jP*8+1], W[sow+1+jM*8+2] - W[sow+1+jP*8+2], W[sow+1+jM*8+3] - W[sow+1+jP*8+3], rv2, t1, t2, t3)
          let mb: i64 = (ch*nk + k4)*3
          mNc[mb]   = bpx9 + rv2[0]
          mNc[mb+1] = bpy9 + rv2[1]
          mNc[mb+2] = bpz9 + rv2[2]
          k4 = k4 + 1
      }
      ch = ch + 1
  }
  xd_w("NXA-ANIM arm-ik keys=" as *u8); xd_num(nk*2 - ikfb9)
  xd_w(" fallback=" as *u8); xd_num(ikfb9); xd_w("\n" as *u8)
  let kw: i64 = nk*2
  let aw: i64 = 1 + ntr*(3 + kw)
  let AP: *i64 = sys_mmap(aw*8 + 64) as *i64
  AP[0] = ntr
  var ap: i64 = 1
  var tg: i64 = 0
  while tg < nj {
      if LN[tg] >= 0 {
          let c3: i64 = LN[tg]/2
          let low: i64 = LN[tg] - (LN[tg]/2)*2
          AP[ap] = tg
          AP[ap+1] = 2
          AP[ap+2] = nk
          ap = ap + 3
          let bgx: i64 = W[sow+1+tg*8+1]
          let bgy: i64 = W[sow+1+tg*8+2]
          let bgz: i64 = W[sow+1+tg*8+3]
          var basej: i64 = CP[c3]
          if low == 1 { basej = CM[c3] }
          let bbx: i64 = W[sow+1+basej*8+1]
          let bby: i64 = W[sow+1+basej*8+2]
          let bbz: i64 = W[sow+1+basej*8+3]
          var k5: i64 = 0
          while k5 < nk {
              let qb2: i64 = (c3*nk + k5)*4
              var qq: *i64 = ((qUc as i64) + qb2*8) as *i64
              if low == 1 { qq = ((qLc as i64) + qb2*8) as *i64 }
              let pb9: i64 = (c3*nk + k5)*3
              var pvx: i64 = pPc[pb9]
              var pvy: i64 = pPc[pb9+1]
              var pvz: i64 = pPc[pb9+2]
              if low == 1 {
                  let mb2: i64 = (c3*nk + k5)*3
                  pvx = mNc[mb2]
                  pvy = mNc[mb2+1]
                  pvz = mNc[mb2+2]
              }
              xd_qrotv(qq, bgx - bbx, bgy - bby, bgz - bbz, rv2, t1, t2, t3)
              let dgx: i64 = (pvx + rv2[0] - bgx)/100
              let dgy: i64 = (pvy + rv2[1] - bgy)/100
              let dgz: i64 = (pvz + rv2[2] - bgz)/100
              let tms: i64 = k5*keyus/1000
              AP[ap + k5*2] = (tms & 0xffff) | ((qq[0] & 0xffff) << 16) | ((qq[1] & 0xffff) << 32) | ((qq[2] & 0xffff) << 48)
              AP[ap + k5*2 + 1] = (qq[3] & 0xffff) | ((dgx & 0xffff) << 16) | ((dgy & 0xffff) << 32) | ((dgz & 0xffff) << 48)
              k5 = k5 + 1
          }
          ap = ap + kw
      } else { if TF[tg] == 1 {
          // TORSO track: the joint rides the tracked chest rigidly about the hip centre
          AP[ap] = tg
          AP[ap+1] = 2
          AP[ap+2] = nk
          ap = ap + 3
          let bgx2: i64 = W[sow+1+tg*8+1]
          let bgy2: i64 = W[sow+1+tg*8+2]
          let bgz2: i64 = W[sow+1+tg*8+3]
          var k6: i64 = 0
          while k6 < nk {
              let qq2: *i64 = ((qTc as i64) + k6*32) as *i64
              xd_qrotv(qq2, bgx2 - hcx, bgy2 - hcy, bgz2 - hcz, rv2, t1, t2, t3)
              let dgx2: i64 = (hcx + rv2[0] - bgx2)/100
              let dgy2: i64 = (hcy + rv2[1] - bgy2)/100
              let dgz2: i64 = (hcz + rv2[2] - bgz2)/100
              let tms2: i64 = k6*keyus/1000
              AP[ap + k6*2] = (tms2 & 0xffff) | ((qq2[0] & 0xffff) << 16) | ((qq2[1] & 0xffff) << 32) | ((qq2[2] & 0xffff) << 48)
              AP[ap + k6*2 + 1] = (qq2[3] & 0xffff) | ((dgx2 & 0xffff) << 16) | ((dgy2 & 0xffff) << 32) | ((dgz2 & 0xffff) << 48)
              k6 = k6 + 1
          }
          ap = ap + kw
      } }
      tg = tg + 1
  }
  // splice: keep every section except an old ANIM, append ours, RECOMPUTE every checksum
  // (a copied checksum validates its own bug -- the ntx_apply law)
  var ani: i64 = 0 - 1
  var s4: i64 = 0
  while s4 < ns {
      if W[4+s4*4] == nxa_tag4("ANIM" as *u8) { ani = s4 }
      s4 = s4 + 1
  }
  var nsec: i64 = ns
  if ani < 0 { nsec = ns + 1 }
  var total: i64 = (4 + nsec*4)*8
  var s5: i64 = 0
  while s5 < ns {
      if s5 != ani { total = total + W[4+s5*4+2]*8 }
      s5 = s5 + 1
  }
  total = total + aw*8
  let nb: *u8 = sys_mmap(total + XD_MAGIC_4096)
  if (nb as i64) == 0 { xd_w("NXA-ANIM REFUSED: cannot allocate output\n" as *u8); return 4 }
  let NW: *i64 = nb as *i64
  NW[0] = nxa_magic()
  NW[1] = 1
  NW[2] = nsec
  var wo: i64 = (4 + nsec*4)*8
  var ti3: i64 = 0
  var s6: i64 = 0
  while s6 < ns {
      if s6 != ani {
          let oldoff: i64 = W[4+s6*4+1]
          let wl: i64 = W[4+s6*4+2]
          NW[4+ti3*4] = W[4+s6*4]
          NW[4+ti3*4+1] = wo
          NW[4+ti3*4+2] = wl
          var cb: i64 = 0
          while cb < wl*8 { nb[wo+cb] = b[oldoff+cb]; cb = cb + 1 }
          let pw: *i64 = ((nb as i64) + wo) as *i64
          NW[4+ti3*4+3] = nxa_check2(1, pw, wl)
          wo = wo + wl*8
          ti3 = ti3 + 1
      }
      s6 = s6 + 1
  }
  NW[4+ti3*4] = nxa_tag4("ANIM" as *u8)
  NW[4+ti3*4+1] = wo
  NW[4+ti3*4+2] = aw
  let dstw: *i64 = ((nb as i64) + wo) as *i64
  var cw: i64 = 0
  while cw < aw { dstw[cw] = AP[cw]; cw = cw + 1 }
  NW[4+ti3*4+3] = nxa_check2(1, dstw, aw)
  wo = wo + aw*8
  let tb2: *i64 = ((nb as i64) + 32) as *i64
  NW[3] = nxa_check2(1, tb2, nsec*4)
  let fd: i64 = sys_openat_wr(outp, 0x1a4)
  if fd < 0 { xd_w("NXA-ANIM REFUSED: cannot open output\n" as *u8); return 4 }
  sys_write(fd, nb, wo)
  sys_close(fd)
  xd_w("NXA-ANIM-OK ntr=" as *u8); xd_num(ntr); xd_w(" nk=" as *u8); xd_num(nk)
  xd_w(" sections=" as *u8); xd_num(nsec)
  xd_w(" out_bytes=" as *u8); xd_num(wo); xd_w("\n" as *u8)
  return 0
802}
803func xd_streq(a: *u8, b: *u8) -> i64 {
  var i: i64=0; var go: i64=1; var eq: i64=1
  while go==1 { if a[i]!=b[i] { eq=0; go=0 } else { if a[i]==(0 as u8) { go=0 } else { i=i+1 } } }
  return eq
807}
808// M1 ADOPTION (2026-08-12): dump the NXA SKEL so the 12-role resolver is designed against
809// MEASURED binds, never armchair anatomy. Output: nj, then per joint: idx parent x y z.
810func xd_nxa_probe(inp: *u8) -> i64 {
  let lp: *i64 = sys_mmap(16) as *i64
  let b: *u8 = sys_read_file(inp, lp)
  if (b as i64) == 0 { xd_w("NXA-PROBE REFUSED: cannot read input\n" as *u8); return 2 }
  let flen: i64 = lp[0]
  let sow: i64 = nxa_find(b, flen, nxa_tag4("SKEL" as *u8))
  if sow < 0 { xd_w("NXA-PROBE REFUSED: SKEL missing/corrupt code=" as *u8); xd_num(sow); xd_w("\n" as *u8); return 2 }
  let W: *i64 = b as *i64
  let nj: i64 = W[sow]
  xd_w("NXA-PROBE nj=" as *u8); xd_num(nj); xd_w(" rows: idx parent x y z\n" as *u8)
  var j: i64 = 0
  while j < nj {
      let base: i64 = sow + 1 + j*8
      xd_num(j); xd_w(" " as *u8); xd_num(W[base]); xd_w(" " as *u8)
      xd_num(W[base+1]); xd_w(" " as *u8); xd_num(W[base+2]); xd_w(" " as *u8); xd_num(W[base+3]); xd_w("\n" as *u8)
      j = j + 1
  }
  return 0
828}
829// M1-ARM-IK: de-yawed + mirrored offset of joint j from the mocap hip centre, RAW units -> o[ob..ob+2]
830// (the same de-yaw+mirror pipeline as dtrk/ttrk; un-normalized because POSITION is the payload)
831func xd_hipoff(wp: *i64, j: i64, hx: i64, hy: i64, hz: i64, cr: i64, sr: i64, o: *i64, ob: i64) -> i64 {
  let dx0: i64 = wp[j*3]   - hx
  let dy0: i64 = wp[j*3+1] - hy
  let dz0: i64 = wp[j*3+2] - hz
  o[ob]   = 0 - ((dx0*cr + dz0*sr) / XD_FX12)
  o[ob+1] = dy0
  o[ob+2] = ((0-dx0)*sr + dz0*cr) / XD_FX12
  return 0
839}
840func main(argc: i64, argv: *i64) -> i64 {
  var donxa: i64 = 0
  if argc > 1 {
      let a1: *u8 = argv[1] as *u8
      if a1[0] == (45 as u8) { return xd_kat() }
      if xd_streq(a1, "nxa" as *u8) == 1 {
          if argc >= 3 { if xd_streq(argv[2] as *u8, "probe" as *u8) == 1 {
              if argc < 4 { xd_w("usage: nx_dance_emit nxa probe <in.nxa>\n" as *u8); return 3 }
              return xd_nxa_probe(argv[3] as *u8)
          } }
          if argc < 5 { xd_w("usage: nx_dance_emit nxa <in.nxa> <clip.bvh> <out.nxa>\n" as *u8); return 3 }
          donxa = 1
      }
  }
  xd_w("=== nx_dance_emit v2 -- REAL mocap -> position-retargeted, smooth-skinned being ===\n" as *u8)
  var path: *u8 = "knowledge/fixture_mocapbank.bvh" as *u8
  if argc > 1 { path = argv[1] as *u8 }
  if donxa == 1 { path = argv[3] as *u8 }
858
  let lenp: *i64 = sys_mmap(16) as *i64
  let buf: *u8 = sys_read_file(path, lenp)
  if (buf as i64) == 0 { xd_w("nx_dance_emit unreadable\n" as *u8); return 2 }
  let len: i64 = lenp[0]
863
  let H: *i64 = sys_mmap(B_H_WORDS * 8) as *i64
  let names: *u8 = sys_mmap(B_MAX_JOINTS * B_NAMEW)
  let parent: *i64 = sys_mmap(B_MAX_JOINTS * 8) as *i64
  let nchan: *i64 = sys_mmap(B_MAX_JOINTS * 8) as *i64
  let chan0: *i64 = sys_mmap(B_MAX_JOINTS * 8) as *i64
  let joff: *i64 = sys_mmap(B_MAX_JOINTS * 24) as *i64
  let chtype: *i64 = sys_mmap(B_MAX_CHAN * 8) as *i64
  let r: i64 = b_parse(buf, len, H, names, parent, nchan, chan0, joff, chtype)
  if r < 0 { return b_refuse(r) }
  xd_w("clip joints=" as *u8); xd_num(H[B_H_NJOINT])
  xd_w(" frames=" as *u8); xd_num(H[B_H_NFRAME])
  xd_w(" ftime_us=" as *u8); xd_num(H[B_H_FTIME])
  xd_w("\n" as *u8)
877
  // ---- resolve 12 skeleton joints BY NAME, CMU/cgspeed aliases FIRST (that skeleton also carries a
  // "LeftShoulder" CLAVICLE, so the mocapbank name must be the FALLBACK, never the first try);
  // a missing role REFUSES (proven by KAT T4) ----
  let map: *i64 = sys_mmap(13*8) as *i64
  let aLsh: *u8 = "LeftArm" as *u8
  let nLsh: *u8 = "LeftShoulder" as *u8
  let aLel: *u8 = "LeftForeArm" as *u8
  let nLel: *u8 = "LeftElbow" as *u8
  let aRsh: *u8 = "RightArm" as *u8
  let nRsh: *u8 = "RightShoulder" as *u8
  let aRel: *u8 = "RightForeArm" as *u8
  let nRel: *u8 = "RightElbow" as *u8
  let aLhp: *u8 = "LeftUpLeg" as *u8
  let nLhp: *u8 = "LeftHip" as *u8
  let aLkn: *u8 = "LeftLeg" as *u8
  let nLkn: *u8 = "LeftKnee" as *u8
  let aRhp: *u8 = "RightUpLeg" as *u8
  let nRhp: *u8 = "RightHip" as *u8
  let aRkn: *u8 = "RightLeg" as *u8
  let nRkn: *u8 = "RightKnee" as *u8
  let aLwr: *u8 = "LeftHand" as *u8
  let nLwr: *u8 = "LeftWrist" as *u8
  let aRwr: *u8 = "RightHand" as *u8
  let nRwr: *u8 = "RightWrist" as *u8
  let aLan: *u8 = "LeftFoot" as *u8
  let nLan: *u8 = "LeftAnkle" as *u8
  let aRan: *u8 = "RightFoot" as *u8
  let nRan: *u8 = "RightAnkle" as *u8
  let nj: i64 = H[B_H_NJOINT]
  map[1] = xd_findjoint(names, nj, aLsh)
  if map[1] < 0 { map[1] = xd_findjoint(names, nj, nLsh) }
  map[2] = xd_findjoint(names, nj, aLel)
  if map[2] < 0 { map[2] = xd_findjoint(names, nj, nLel) }
  map[3] = xd_findjoint(names, nj, aRsh)
  if map[3] < 0 { map[3] = xd_findjoint(names, nj, nRsh) }
  map[4] = xd_findjoint(names, nj, aRel)
  if map[4] < 0 { map[4] = xd_findjoint(names, nj, nRel) }
  map[5] = xd_findjoint(names, nj, aLhp)
  if map[5] < 0 { map[5] = xd_findjoint(names, nj, nLhp) }
  map[6] = xd_findjoint(names, nj, aLkn)
  if map[6] < 0 { map[6] = xd_findjoint(names, nj, nLkn) }
  map[7] = xd_findjoint(names, nj, aRhp)
  if map[7] < 0 { map[7] = xd_findjoint(names, nj, nRhp) }
  map[8] = xd_findjoint(names, nj, aRkn)
  if map[8] < 0 { map[8] = xd_findjoint(names, nj, nRkn) }
  map[9] = xd_findjoint(names, nj, aLwr)
  if map[9] < 0 { map[9] = xd_findjoint(names, nj, nLwr) }
  map[10] = xd_findjoint(names, nj, aRwr)
  if map[10] < 0 { map[10] = xd_findjoint(names, nj, nRwr) }
  map[11] = xd_findjoint(names, nj, aLan)
  if map[11] < 0 { map[11] = xd_findjoint(names, nj, nLan) }
  map[12] = xd_findjoint(names, nj, aRan)
  if map[12] < 0 { map[12] = xd_findjoint(names, nj, nRan) }
  var bi: i64 = 1
  var missing: i64 = 0
  while bi <= 12 { if map[bi] < 0 { missing = missing + 1 } bi = bi + 1 }
  if missing > 0 {
      xd_w("DANCE-EMIT REFUSED: required joints missing from clip=" as *u8); xd_num(missing); xd_w(" of 12\n" as *u8)
      return 4
  }
  xd_w("joint map 12/12 by name\n" as *u8)
939
  // ---- keys: nearest frame on the 8 Hz exact-f32 grid ----
  let dur_us: i64 = H[B_H_NFRAME] * H[B_H_FTIME]
  // M1 FLUIDITY (operator: "movements aren't fluid"): the 8 Hz grid was the BLOB wire's DV_MAXK
  // constraint, not a choice -- 125ms nlerp gaps read as non-fluid on fast choreography. The NXA
  // lane samples at the clip's NATIVE rate (floored at 30 Hz); its wire has no 128-key cap
  // (u16 ms ceils at 65s, guarded at 1900 keys).
  var keyus: i64 = XD_KEY_US
  if donxa == 1 {
      keyus = H[B_H_FTIME]
      if keyus < XD_MAGIC_33333 { keyus = XD_MAGIC_33333 }
  }
  var nk: i64 = dur_us / keyus
  var capped: i64 = 0
  if donxa == 0 { if nk > XD_MAXK { nk = XD_MAXK; capped = 1 } }
  if donxa == 1 { if nk > XD_MAGIC_1900 { nk = XD_MAGIC_1900; capped = 1 } }
  if nk < 2 { xd_w("DANCE-EMIT REFUSED: clip shorter than 2 keys\n" as *u8); return 4 }
  xd_w("keys=" as *u8); xd_num(nk)
  xd_w(" key_us=" as *u8); xd_num(keyus)
  xd_w(" over " as *u8); xd_num(dur_us/1000); xd_w(" ms" as *u8)
  if capped == 1 { xd_w(" (CAPPED at XD_MAXK)" as *u8) }
  xd_w("\n" as *u8)
961
  // ---- POSITION-BASED RETARGET: FK the whole mocap skeleton per key, drive bones by world dirs ----
  let qtrk: *i64 = sys_mmap(8*nk*4*8) as *i64
  let fv: *i64 = sys_mmap(B_MAX_CHAN*8) as *i64
  let q: *i64 = sys_mmap(32) as *i64
  let qa: *i64 = sys_mmap(32) as *i64
  let qt: *i64 = sys_mmap(32) as *i64
  let s1: *i64 = sys_mmap(32) as *i64
  let s2: *i64 = sys_mmap(32) as *i64
  let s3: *i64 = sys_mmap(32) as *i64
  let rv: *i64 = sys_mmap(32) as *i64
  let wq: *i64 = sys_mmap(B_MAX_JOINTS*4*8) as *i64   // mocap world quats, fx12
  let wp: *i64 = sys_mmap(B_MAX_JOINTS*3*8) as *i64   // mocap world positions, file units
  let qwb: *i64 = sys_mmap(9*4*8) as *i64             // OUR bones' world quats this key
  let dtrk: *i64 = sys_mmap(8*nk*3*8 + 64) as *i64    // M1: per-key WORLD segment dirs (fx12, dance frame) for the NXA lane
  let ttrk: *i64 = sys_mmap(nk*6*8 + 64) as *i64      // M1-TORSO: per-key de-yawed mocap SPINE dir + SHOULDER-AXIS dir (fx12, 6/key)
  let atrk: *i64 = sys_mmap(nk*20*8 + 64) as *i64     // M1-ARM-IK (debt 1786598036): per key = [mocap spine len, then per arm RAW de-yawed+mirrored sh/el/wr offsets from the HIP CENTRE (9)] = 20/key, mocap units
  let pa: *i64 = sys_mmap(9*8) as *i64                // per-bone segment: parent joint (map index)
  let pc: *i64 = sys_mmap(9*8) as *i64                //                    child joint (map index)
  pa[1]=1; pc[1]=2
  pa[2]=2; pc[2]=9
  pa[3]=3; pc[3]=4
  pa[4]=4; pc[4]=10
  pa[5]=5; pc[5]=6
  pa[6]=6; pc[6]=11
  pa[7]=7; pc[7]=8
  pa[8]=8; pc[8]=12
  var k: i64 = 0
  while k < nk {
      var f: i64 = k * keyus / H[B_H_FTIME]
      if f >= H[B_H_NFRAME] { f = H[B_H_NFRAME] - 1 }
      if b_frame_values(buf, len, H, f, fv) != 0 { xd_w("DANCE-EMIT REFUSED: frame read failed\n" as *u8); return 4 }
      // FK: BVH file order is parent-before-child
      var mj: i64 = 0
      while mj < nj {
          xd_joint_quat(fv, chan0[mj], nchan[mj], chtype, q, qa, qt)
          let pj: i64 = parent[mj]
          if pj < 0 {
              wq[mj*4]=q[0]; wq[mj*4+1]=q[1]; wq[mj*4+2]=q[2]; wq[mj*4+3]=q[3]
              wp[mj*3]=0; wp[mj*3+1]=0; wp[mj*3+2]=0
          } else {
              xd_qmul(((wq as i64) + pj*32) as *i64, q, ((wq as i64) + mj*32) as *i64)
              xd_qrotv(((wq as i64) + pj*32) as *i64, joff[mj*3], joff[mj*3+1], joff[mj*3+2], rv, s1, s2, s3)
              wp[mj*3]   = wp[pj*3]   + rv[0]
              wp[mj*3+1] = wp[pj*3+1] + rv[1]
              wp[mj*3+2] = wp[pj*3+2] + rv[2]
          }
          mj = mj + 1
      }
      // hip-axis yaw frame (torso-relative dance; stable body facing)
      let hl: i64 = map[5]
      let hr: i64 = map[7]
      let hx: i64 = wp[hl*3] - wp[hr*3]
      let hz: i64 = wp[hl*3+2] - wp[hr*3+2]
      var hn: i64 = xd_isqrt(hx*hx + hz*hz)
      if hn < 1 { hn = 1 }
      let cr: i64 = hx*XD_FX12/hn
      let sr: i64 = hz*XD_FX12/hn
      // M1-TORSO (debt 1786598036): capture the de-yawed, mirrored SPINE direction per key --
      // real choreography clears the chest by torso lean; bind-holding it was the proven root
      // cause of the 138mm arm-through-chest clip (clipcheck probe key78 joint86)
      let ls9: i64 = map[1]
      let rs9: i64 = map[3]
      let sx0: i64 = (wp[ls9*3] + wp[rs9*3])/2 - (wp[hl*3] + wp[hr*3])/2
      let sy0: i64 = (wp[ls9*3+1] + wp[rs9*3+1])/2 - (wp[hl*3+1] + wp[hr*3+1])/2
      let sz0: i64 = (wp[ls9*3+2] + wp[rs9*3+2])/2 - (wp[hl*3+2] + wp[hr*3+2])/2
      let sx1: i64 = (sx0*cr + sz0*sr) / XD_FX12
      let sz1: i64 = ((0-sx0)*sr + sz0*cr) / XD_FX12
      let sx2: i64 = 0 - sx1
      var sn9: i64 = xd_isqrt(sx2*sx2 + sy0*sy0 + sz1*sz1)
      if sn9 < 1 { sn9 = 1 }
      ttrk[k*6]   = sx2*XD_FX12/sn9
      ttrk[k*6+1] = sy0*XD_FX12/sn9
      ttrk[k*6+2] = sz1*XD_FX12/sn9
      // shoulder-axis dir (Lsh - Rsh), same de-yaw + mirror pipeline: carries the chest TWIST
      let ax0: i64 = wp[ls9*3]   - wp[rs9*3]
      let ay0: i64 = wp[ls9*3+1] - wp[rs9*3+1]
      let az0: i64 = wp[ls9*3+2] - wp[rs9*3+2]
      let ax1: i64 = (ax0*cr + az0*sr) / XD_FX12
      let az1: i64 = ((0-ax0)*sr + az0*cr) / XD_FX12
      let ax2: i64 = 0 - ax1
      var an9: i64 = xd_isqrt(ax2*ax2 + ay0*ay0 + az1*az1)
      if an9 < 1 { an9 = 1 }
      ttrk[k*6+3] = ax2*XD_FX12/an9
      ttrk[k*6+4] = ay0*XD_FX12/an9
      ttrk[k*6+5] = az1*XD_FX12/an9
      // M1-ARM-IK v2: RAW sh/el/wr offsets from the MOCAP HIP CENTRE, de-yawed + mirrored like
      // dtrk. HIP-relative, not shoulder-relative: shoulder-relative fidelity cannot preserve
      // torso clearance when the shoulder-to-axis distance differs between bodies (measured:
      // source wrist 201mm from its axis; shoulder-relative retarget placed ours at 40mm).
      // atrk[k*20] additionally banks the mocap spine length sn9 = the scale bridge.
      let hcmx9: i64 = (wp[hl*3] + wp[hr*3])/2
      let hcmy9: i64 = (wp[hl*3+1] + wp[hr*3+1])/2
      let hcmz9: i64 = (wp[hl*3+2] + wp[hr*3+2])/2
      atrk[k*20] = sn9
      var ar9: i64 = 0
      while ar9 < 2 {
          let ab9: i64 = k*20 + 1 + ar9*9
          xd_hipoff(wp, map[1 + ar9*2], hcmx9, hcmy9, hcmz9, cr, sr, atrk, ab9)
          xd_hipoff(wp, map[2 + ar9*2], hcmx9, hcmy9, hcmz9, cr, sr, atrk, ab9+3)
          xd_hipoff(wp, map[9 + ar9],  hcmx9, hcmy9, hcmz9, cr, sr, atrk, ab9+6)
          ar9 = ar9 + 1
      }
      // per bone: world dir -> de-yaw -> mirror X -> normalize -> quat; local = conj(parentBone) x world
      var bn: i64 = 1
      while bn <= 8 {
          let ja: i64 = map[pa[bn]]
          let jc: i64 = map[pc[bn]]
          let dx0: i64 = wp[jc*3]   - wp[ja*3]
          let dy0: i64 = wp[jc*3+1] - wp[ja*3+1]
          let dz0: i64 = wp[jc*3+2] - wp[ja*3+2]
          let dx1: i64 = (dx0*cr + dz0*sr) / XD_FX12
          let dz1: i64 = ((0-dx0)*sr + dz0*cr) / XD_FX12
          let dx2: i64 = 0 - dx1
          var dn: i64 = xd_isqrt(dx2*dx2 + dy0*dy0 + dz1*dz1)
          if dn < 1 { dn = 1 }
          let dbi: i64 = ((bn-1)*nk + k)*3
          dtrk[dbi]   = dx2*XD_FX12/dn
          dtrk[dbi+1] = dy0*XD_FX12/dn
          dtrk[dbi+2] = dz1*XD_FX12/dn
          xd_qfromdir(dtrk[dbi], dtrk[dbi+1], dtrk[dbi+2], q)
          qwb[bn*4]=q[0]; qwb[bn*4+1]=q[1]; qwb[bn*4+2]=q[2]; qwb[bn*4+3]=q[3]
          let qb: i64 = ((bn-1)*nk + k)*4
          if bn == 2 { s3[0]=0-qwb[4]; s3[1]=0-qwb[5]; s3[2]=0-qwb[6]; s3[3]=qwb[7]; xd_qmul(s3, q, qt); qtrk[qb]=qt[0]; qtrk[qb+1]=qt[1]; qtrk[qb+2]=qt[2]; qtrk[qb+3]=qt[3] }
          else { if bn == 4 { s3[0]=0-qwb[12]; s3[1]=0-qwb[13]; s3[2]=0-qwb[14]; s3[3]=qwb[15]; xd_qmul(s3, q, qt); qtrk[qb]=qt[0]; qtrk[qb+1]=qt[1]; qtrk[qb+2]=qt[2]; qtrk[qb+3]=qt[3] }
          else { if bn == 6 { s3[0]=0-qwb[20]; s3[1]=0-qwb[21]; s3[2]=0-qwb[22]; s3[3]=qwb[23]; xd_qmul(s3, q, qt); qtrk[qb]=qt[0]; qtrk[qb+1]=qt[1]; qtrk[qb+2]=qt[2]; qtrk[qb+3]=qt[3] }
          else { if bn == 8 { s3[0]=0-qwb[28]; s3[1]=0-qwb[29]; s3[2]=0-qwb[30]; s3[3]=qwb[31]; xd_qmul(s3, q, qt); qtrk[qb]=qt[0]; qtrk[qb+1]=qt[1]; qtrk[qb+2]=qt[2]; qtrk[qb+3]=qt[3] }
          else { qtrk[qb]=q[0]; qtrk[qb+1]=q[1]; qtrk[qb+2]=q[2]; qtrk[qb+3]=q[3] } } } }
          bn = bn + 1
      }
      k = k + 1
  }
1093
  if donxa == 1 { return xd_nxa_apply(argv[2] as *u8, argv[4] as *u8, dtrk, nk, keyus, ttrk, atrk) }
  // ---- track teeth (values, not booleans) ----
  var fails: i64 = 0
  var normbad: i64 = 0
  var worstn2: i64 = XD_FX12
  var axis3: i64 = 0
  var moved: i64 = 0
  var bn2: i64 = 1
  while bn2 <= 8 {
      var k2: i64 = 0
      while k2 < nk {
          let qb2: i64 = ((bn2-1)*nk + k2)*4
          let n2: i64 = (qtrk[qb2]*qtrk[qb2] + qtrk[qb2+1]*qtrk[qb2+1] + qtrk[qb2+2]*qtrk[qb2+2] + qtrk[qb2+3]*qtrk[qb2+3]) / XD_FX12
          if n2 < XD_NORM_LO { normbad = normbad + 1 }
          if n2 > XD_NORM_HI { normbad = normbad + 1 }
          var dv: i64 = n2 - XD_FX12
          if dv < 0 { dv = 0 - dv }
          var dw: i64 = worstn2 - XD_FX12
          if dw < 0 { dw = 0 - dw }
          if dv > dw { worstn2 = n2 }
          var ay: i64 = qtrk[qb2+1]
          if ay < 0 { ay = 0 - ay }
          var az: i64 = qtrk[qb2+2]
          if az < 0 { az = 0 - az }
          if ay > XD_AXIS_TH { axis3 = axis3 + 1 }
          if az > XD_AXIS_TH { axis3 = axis3 + 1 }
          let q0: i64 = ((bn2-1)*nk)*4
          var c3: i64 = 0
          while c3 < 4 {
              var d3: i64 = qtrk[qb2+c3] - qtrk[q0+c3]
              if d3 < 0 { d3 = 0 - d3 }
              if d3 > XD_MOVE_TH { moved = moved + 1 }
              c3 = c3 + 1
          }
          k2 = k2 + 1
      }
      bn2 = bn2 + 1
  }
  xd_w("T-norm worst |q|^2/4096=" as *u8); xd_num(worstn2); xd_w(" band=[" as *u8); xd_num(XD_NORM_LO); xd_w(","as *u8); xd_num(XD_NORM_HI); xd_w("] violations=" as *u8); xd_num(normbad)
  if normbad == 0 { xd_w(" PASS\n" as *u8) } else { xd_w(" FAIL\n" as *u8); fails = fails + 1 }
  xd_w("T-3axis |qy|/|qz|>50 count=" as *u8); xd_num(axis3)
  if axis3 > 0 { xd_w(" PASS\n" as *u8) } else { xd_w(" FAIL flat\n" as *u8); fails = fails + 1 }
  xd_w("T-moves keys-departing-key0 count=" as *u8); xd_num(moved)
  if moved > 0 { xd_w(" PASS\n" as *u8) } else { xd_w(" FAIL constant-pose\n" as *u8); fails = fails + 1 }
1138
  // ---- build the being (SEED-SAN proportions) + bind, ONE skin tone ----
  ba_set_axes(363, XD_MAGIC_1231, XD_MAGIC_1403, XD_MAGIC_1067, XD_MAGIC_1179)
  atlas_build(0)
  let grid: *i64 = sys_mmap((XD_GX+1)*(XD_GY+1)*(XD_GZ+1)*8) as *i64
  var gi: i64 = 0
  while gi <= XD_GX { var gj: i64=0; while gj <= XD_GY { var gk: i64=0; while gk <= XD_GZ { grid[(gi*(XD_GY+1)+gj)*(XD_GZ+1)+gk] = ba_sdf(XD_OX+gi*XD_GC, XD_OY+gj*XD_GC, XD_OZ+gk*XD_GC, 1); gk=gk+1 } gj=gj+1 } gi=gi+1 }
  tm_reset()
  surface_nets(grid, XD_GX, XD_GY, XD_GZ, XD_OX, XD_OY, XD_OZ, XD_GC, 0, XD_SKIN)
  let NV: i64 = tm_nv()
  let jarr: *i64 = sys_mmap(NV*8) as *i64
  let vp: *i64 = sys_mmap(24) as *i64
  let jc9: *i64 = sys_mmap(9*8) as *i64
  var b9: i64 = 0
  while b9 < 9 { jc9[b9]=0; b9=b9+1 }
  var vi: i64 = 0
  while vi < NV {
      tm_vpos(vi, vp)
      let kk: i64 = ba_nearest(vp[0], vp[1], vp[2], 1)
      var jt: i64 = 0
      if kk >= 0 { jt = ba_part_bone(kk) }
      tm_vcol(vi, XD_SKIN)
      jarr[vi] = jt
      jc9[jt] = jc9[jt] + 1
      vi = vi + 1
  }
  xd_w("verts=" as *u8); xd_num(NV)
  xd_w(" bound: Lsh=" as *u8); xd_num(jc9[1]); xd_w(" Lel=" as *u8); xd_num(jc9[2]); xd_w(" Lhip=" as *u8); xd_num(jc9[5]); xd_w(" Lkn=" as *u8); xd_num(jc9[6]); xd_w("\n" as *u8)
  var t0: i64 = 0
  if jc9[1] > 20 { if jc9[5] > 20 { if jc9[6] > 20 { t0 = 1 } } }
  if t0 == 1 { xd_w("T-bind PASS limbs rigged\n" as *u8) } else { fails=fails+1; xd_w("T-bind FAIL\n" as *u8) }
1169
  // ---- smooth two-bone weights, CONTINUOUS across every seam (v2.2) ----
  // The v2.1 ownership-anchored scheme was discontinuous: adjacent verts across a seam flipped
  // PRIMARY bone while each kept majority weight -- the seam still tore 8-10x (measured). Correct
  // scheme: near any joint pivot the blend is a pure function of GEOMETRY -- signed height relative
  // to the pivot (all rest bones hang -Y): w_child = 1/2 + (pivY - vy)/(2*BAND), clamped. Adjacent
  // verts get near-identical mixes whichever side owns them, so the seam deforms instead of tearing.
  let j1arr: *i64 = sys_mmap(NV*8) as *i64
  let j2arr: *i64 = sys_mmap(NV*8) as *i64
  let wtarr: *i64 = sys_mmap(NV*8) as *i64
  let pb: *i64 = sys_mmap(9*8) as *i64
  pb[0]=0; pb[1]=0; pb[2]=1; pb[3]=0; pb[4]=3; pb[5]=0; pb[6]=5; pb[7]=0; pb[8]=7
  // OWNERSHIP-GATED seams (v2.3): a vert participates only in seams its own chain forms -- own
  // pivot (seam with parent) and child pivots (seam with that child). An ungated nearest-pivot
  // capture let the ELBOW pivot grab belly/chest verts (seedsan arms hang against the torso;
  // measured 25x tears). Weight stays PURELY GEOMETRIC (signed height vs the seam pivot, all rest
  // bones hang -Y), so the two sides of a seam get continuous, matching blends.
  let cA: *i64 = sys_mmap(9*8) as *i64
  let cB: *i64 = sys_mmap(9*8) as *i64
  let cC: *i64 = sys_mmap(9*8) as *i64
  let cD: *i64 = sys_mmap(9*8) as *i64
  var ci9: i64 = 0
  while ci9 < 9 { cA[ci9]=0-1; cB[ci9]=0-1; cC[ci9]=0-1; cD[ci9]=0-1; ci9=ci9+1 }
  cA[0]=1; cB[0]=3; cC[0]=5; cD[0]=7
  cA[1]=2; cA[3]=4; cA[5]=6; cA[7]=8
  vi = 0
  while vi < NV {
      tm_vpos(vi, vp)
      let own: i64 = jarr[vi]
      var sc: i64 = 0 - 1
      var nd: i64 = XD_BAND + 1
      // own pivot = seam (own <-> parent)
      if own > 0 {
          let ox2: i64 = vp[0] - ga_piv(own,0)
          let oy2: i64 = vp[1] - ga_piv(own,1)
          let oz2: i64 = vp[2] - ga_piv(own,2)
          let od: i64 = xd_isqrt(ox2*ox2 + oy2*oy2 + oz2*oz2)
          if od < nd { nd = od; sc = own }
      }
      // child pivots = seams (child <-> own)
      var cslot: i64 = 0
      while cslot < 4 {
          var cb2: i64 = 0 - 1
          if cslot == 0 { cb2 = cA[own] }
          if cslot == 1 { cb2 = cB[own] }
          if cslot == 2 { cb2 = cC[own] }
          if cslot == 3 { cb2 = cD[own] }
          if cb2 > 0 {
              let cx: i64 = vp[0] - ga_piv(cb2,0)
              let cy2: i64 = vp[1] - ga_piv(cb2,1)
              let cz: i64 = vp[2] - ga_piv(cb2,2)
              let dd: i64 = xd_isqrt(cx*cx + cy2*cy2 + cz*cz)
              if dd < nd { nd = dd; sc = cb2 }
          }
          cslot = cslot + 1
      }
      if sc > 0 {
          let sup: i64 = ga_piv(sc,1) - vp[1]
          var w: i64 = XD_MAGIC_8192 + XD_MAGIC_8192*sup/XD_BAND
          if w < 0 { w = 0 }
          if w > XD_MAGIC_16384 { w = XD_MAGIC_16384 }
          j1arr[vi] = sc
          j2arr[vi] = pb[sc]
          wtarr[vi] = w
      } else {
          j1arr[vi] = own
          j2arr[vi] = own
          wtarr[vi] = XD_MAGIC_16384
      }
      vi = vi + 1
  }
1240
  // ---- export the glb through the shared writer (gets the v2 retargeted track too) ----
  let out: *u8 = sys_mmap(XD_GLBCAP)
  let aname: *u8 = "dance" as *u8
  let total: i64 = gltf_anim_export_qtrack(out, jarr, qtrk, nk, aname)
  xd_w("glb bytes=" as *u8); xd_num(total); xd_w("\n" as *u8)
  var t1: i64 = 0
  if (out[0] as i64)==103 { if xd_ru32(out,8)==total { t1=1 } }
  if t1 == 1 { xd_w("T-glb PASS header + length\n" as *u8) } else { fails=fails+1; xd_w("T-glb FAIL\n" as *u8) }
  let jsonLen: i64 = xd_ru32(out,12)
  var t2: i64 = 0
  let ndance: *u8 = "\"dance\"" as *u8
  let nwalk: *u8 = "\"walk\"" as *u8
  if xd_hasstr(out,20+jsonLen,ndance)==1 { if xd_hasstr(out,20+jsonLen,nwalk)==0 { t2=1 } }
  if t2 == 1 { xd_w("T-name PASS animation is 'dance', not 'walk'\n" as *u8) } else { fails=fails+1; xd_w("T-name FAIL\n" as *u8) }
1255
  let p1: *u8 = "knowledge/nishi_being_dance.glb\x00" as *u8
  let fd: i64 = sys_openat_wr(p1, 0x1a4)
  sys_write(fd, out, total)
  sys_close(fd)
  xd_w("artifact:ADDED knowledge/nishi_being_dance.glb bytes=" as *u8); xd_num(total); xd_w("\n" as *u8)
  let p2: *u8 = "sites/nishifamily/exceed/vrm/nishi-being-dance.glb\x00" as *u8
  let fd2: i64 = sys_openat_wr(p2, 0x1a4)
  sys_write(fd2, out, total)
  sys_close(fd2)
  xd_w("artifact:ADDED sites/nishifamily/exceed/vrm/nishi-being-dance.glb bytes=" as *u8); xd_num(total); xd_w("\n" as *u8)
1266
  // ---- .nxdv v2 blob: the sovereign viewer's wasm-memory IMAGE (wire format = O_D* in
  // nx_meshview_wasm.nx v2). Units: verts/translations Q14 = units*16384/600 (trunc); normals fx12*4;
  // quats fx12*4; weights Q14. Cross-checked byte-identical vs the Node oracle (build_blob.js).
  let XB_TOT: i64 = XD_MAGIC_116324
  let bb: *i64 = sys_mmap(XB_TOT*8) as *i64
  bb[0] = 0x3256584E
  bb[1] = NV
  bb[2] = tm_nt()
  bb[3] = nk
  bb[4] = 125
  bb[5] = 11
  bb[6] = 0
  bb[7] = 0
  var xk: i64 = 0
  while xk < NV {
      tm_vpos(xk, vp)
      bb[8 + xk*3]     = vp[0]*XD_MAGIC_16384/600
      bb[8 + xk*3 + 1] = vp[1]*XD_MAGIC_16384/600
      bb[8 + xk*3 + 2] = vp[2]*XD_MAGIC_16384/600
      tm_vnorm(xk, vp)
      bb[XD_MAGIC_21008 + xk*3]     = vp[0]*4
      bb[XD_MAGIC_21008 + xk*3 + 1] = vp[1]*4
      bb[XD_MAGIC_21008 + xk*3 + 2] = vp[2]*4
      bb[XD_MAGIC_42008 + xk] = (tm_getvcol(xk) & XD_MAGIC_16777215) + XD_MAGIC_4278190080
      bb[XD_MAGIC_49008 + xk] = j1arr[xk]
      bb[XD_MAGIC_56008 + xk] = j2arr[xk]
      bb[XD_MAGIC_63008 + xk] = wtarr[xk]
      xk = xk + 1
  }
  // BRIDGE FILTER (v2.1): the rest-pose SDF fuses surfaces that merely TOUCH (hanging forearms
  // against thighs, inner thighs against each other) -- surface_nets bridges them into one skin, and
  // any correct dance tears those triangles 50x (measured: worst edge stretch 58x, all offenders
  // arm-bone<->leg-bone pairs). A triangle spanning two different LIMBS, or torso<->forearm, has no
  // anatomical joint -- DROP it from the viewer blob. Legit seams stay: torso<->shoulder, torso<->hip,
  // chain links. Dropped count is PRINTED, never silent.
  let lg: *i64 = sys_mmap(9*8) as *i64
  lg[0]=0; lg[1]=1; lg[2]=1; lg[3]=2; lg[4]=2; lg[5]=3; lg[6]=3; lg[7]=4; lg[8]=4
  let NT2: i64 = tm_nt()
  var xt: i64 = 0
  var kept: i64 = 0
  var dropped: i64 = 0
  let tv: *i64 = sys_mmap(24) as *i64
  while xt < NT2 {
      tm_tget(xt, tv)
      let ga: i64 = lg[jarr[tv[0]]]
      let gb: i64 = lg[jarr[tv[1]]]
      let gc: i64 = lg[jarr[tv[2]]]
      var lo: i64 = 9
      var hi: i64 = 0
      if ga > 0 { if ga < lo { lo = ga } if ga > hi { hi = ga } }
      if gb > 0 { if gb < lo { lo = gb } if gb > hi { hi = gb } }
      if gc > 0 { if gc < lo { lo = gc } if gc > hi { hi = gc } }
      var drop: i64 = 0
      if hi > 0 { if lo < hi { drop = 1 } }
      var hastorso: i64 = 0
      if ga == 0 { hastorso = 1 }
      if gb == 0 { hastorso = 1 }
      if gc == 0 { hastorso = 1 }
      // mixed torso+limb is legit ONLY at the limb's ROOT joint: every vert of the triangle must sit
      // within 170 units of that pivot (shoulder/hip). The SDF fuses the whole inner arm to the chest
      // (and inner thighs to the crotch) -- those strips are contact, not anatomy, and they tear.
      if drop == 0 { if hastorso == 1 { if hi > 0 {
          var rootb: i64 = 1
          if hi == 2 { rootb = 3 }
          if hi == 3 { rootb = 5 }
          if hi == 4 { rootb = 7 }
          let rpx: i64 = ga_piv(rootb, 0)
          let rpy: i64 = ga_piv(rootb, 1)
          let rpz: i64 = ga_piv(rootb, 2)
          var vv: i64 = 0
          while vv < 3 {
              tm_vpos(tv[vv], vp)
              let ddx: i64 = vp[0] - rpx
              let ddy: i64 = vp[1] - rpy
              let ddz: i64 = vp[2] - rpz
              if xd_isqrt(ddx*ddx + ddy*ddy + ddz*ddz) > 170 { drop = 1 }
              vv = vv + 1
          }
      } } }
      if drop == 0 {
          bb[XD_MAGIC_70008 + kept*3]     = tv[0]
          bb[XD_MAGIC_70008 + kept*3 + 1] = tv[1]
          bb[XD_MAGIC_70008 + kept*3 + 2] = tv[2]
          kept = kept + 1
      } else { dropped = dropped + 1 }
      xt = xt + 1
  }
  bb[2] = kept
  xd_w("bridge filter: kept=" as *u8); xd_num(kept); xd_w(" dropped=" as *u8); xd_num(dropped); xd_w(" (fused rest-pose contact patches)\n" as *u8)
  // joint slots 0..10 = the glb skin order = ga_piv indices; parents fixed by the rig
  bb[XD_MAGIC_112008] = 0-1
  bb[XD_MAGIC_112009] = 0
  bb[XD_MAGIC_112010] = 1
  bb[XD_MAGIC_112011] = 0
  bb[XD_MAGIC_112012] = 3
  bb[XD_MAGIC_112013] = 0
  bb[XD_MAGIC_112014] = 5
  bb[XD_MAGIC_112015] = 0
  bb[XD_MAGIC_112016] = 7
  bb[XD_MAGIC_112017] = 6
  bb[XD_MAGIC_112018] = 8
  var xs: i64 = 0
  while xs < 11 {
      var xpar: i64 = bb[XD_MAGIC_112008 + xs]
      var xax: i64 = 0
      while xax < 3 {
          var tloc: i64 = ga_piv(xs, xax)
          if xpar >= 0 { tloc = tloc - ga_piv(xpar, xax) }
          bb[XD_MAGIC_112019 + xs*3 + xax] = tloc*XD_MAGIC_16384/600
          xax = xax + 1
      }
      var xc: i64 = 0
      while xc < 16 { bb[XD_MAGIC_112052 + xs*16 + xc] = 0; xc = xc + 1 }
      bb[XD_MAGIC_112052 + xs*16]      = XD_MAGIC_16384
      bb[XD_MAGIC_112052 + xs*16 + 5]  = XD_MAGIC_16384
      bb[XD_MAGIC_112052 + xs*16 + 10] = XD_MAGIC_16384
      bb[XD_MAGIC_112052 + xs*16 + 15] = XD_MAGIC_16384
      bb[XD_MAGIC_112052 + xs*16 + 3]  = (0 - ga_piv(xs, 0))*XD_MAGIC_16384/600
      bb[XD_MAGIC_112052 + xs*16 + 7]  = (0 - ga_piv(xs, 1))*XD_MAGIC_16384/600
      bb[XD_MAGIC_112052 + xs*16 + 11] = (0 - ga_piv(xs, 2))*XD_MAGIC_16384/600
      xs = xs + 1
  }
  var xbn: i64 = 0
  while xbn < 8 {
      var xkk: i64 = 0
      while xkk < nk {
          let src: i64 = (xbn*nk + xkk)*4
          let dst: i64 = XD_MAGIC_112228 + (xkk*8 + xbn)*4
          bb[dst]     = qtrk[src]*4
          bb[dst + 1] = qtrk[src + 1]*4
          bb[dst + 2] = qtrk[src + 2]*4
          bb[dst + 3] = qtrk[src + 3]*4
          xkk = xkk + 1
      }
      xbn = xbn + 1
  }
  let p3: *u8 = "sites/nishifamily/exceed/vrm/being-dance.nxdv\x00" as *u8
  let fd3: i64 = sys_openat_wr(p3, 0x1a4)
  sys_write(fd3, bb as *u8, XB_TOT*8)
  sys_close(fd3)
  xd_w("artifact:ADDED sites/nishifamily/exceed/vrm/being-dance.nxdv bytes=" as *u8); xd_num(XB_TOT*8); xd_w(" (v2: position-retargeted + smooth 2-bone skin)\n" as *u8)
1408
  if fails == 0 {
      xd_w("DANCE-EMIT v2 GREEN -- position-retargeted mocap + smooth skin. Residual: bone twist, root motion, spine/head bones, VMD-corpus clip.\n" as *u8)
      return 0
  }
  xd_w("DANCE-EMIT RED fails=" as *u8); xd_num(fails); xd_w("\n" as *u8)
  return 1
1415}
nx_dance_emit.nx source

`nx_dance_emit.nx` source
