`nx_actbench.nx` source

↩ module page · 1222 lines · 57971 B
1// nx_actbench.nx -- I3: THE PHYSICAL-PLAUSIBILITY RULER. (beyond-metahuman plan, Phase 0 instruments.)
2//
3// ★★★WHY THIS EXISTS, AND IT IS A MEASURED REASON RATHER THAN A PREFERENCE. The field published the
4// number that convicts our whole instrument set: "Beyond MPJPE: A Physics-Based Audit of Monocular 3D
5// Human Pose Estimation" (PhysHuman @ CVPR 2026) reports that the geometric standard MPJPE and the
6// physical composite PHYSSCORE are correlated at only SPEARMAN rho = 0.37, WITH RANK REVERSALS -- the
7// temporal method WHAM ranks 3rd on MPJPE and 1st on physical plausibility. Every ruler this program
8// owns -- nx_twinbench (mm), nx_bodybench (geometry MIN), nx_facemark (placement), nx_curvebench --
9// is GEOMETRIC. So a body of ours can score well on all of them and still be physically impossible,
10// and nothing we own could see it. This organ is the missing axis.
11//
12// ★WHAT IT IS NOT: invented teeth. The first draft of this rung was going to assert energy decay and
13// replay determinism -- both fine properties, both MINE. runtime/nx_pose_benchmark_audit.nx exists
14// precisely to convict that move, grading every claim MECHANICAL vs SELF-VALIDATED vs
15// INDUSTRY-MEASURED, and its standing verdict is "ZERO industry benchmarks is the honest truth". So
16// the channels below are the PUBLISHED ones (PHYSSCORE's six; definitions from the PhysDiff/EDGE
17// lineage and PhyMotion arXiv:2605.14269), not the ones that were convenient to write.
18//
19// ★A RULER IS A FUNCTION OF A TRACE. PHYSSCORE operates on joint positions and needs NO GROUND TRUTH,
20// which is the property that matters here: it can score a GENERATED being. That is what makes it
21// usable on the creature/fantasy half, where there is no cadaver dragon to compare against.
22// So this organ takes a trace + a skeleton and scores it. It is coupled to no generator.
23//
24// ★★CHANNEL 4 READS THE SKELETON'S OWN EMITTED TABLE. nx_skelgen writes "B <bone> <len> <lo> <hi>";
25// this reads those rows. There is therefore NO SECOND CONSTRAINT TABLE to drift from -- the exact
26// failure nx_skelgen itself documents (a fix applied to one of two tables is a bug with a good alibi).
27//
28// ⚠★DECLARED SUBSTITUTION, because an undeclared one is a lie: PHYSSCORE measures penetration and
29// float against the lowest MESH VERTEX. We measure against the lowest JOINT. A joint is inboard of the
30// surface, so our penetration UNDER-reports and our float OVER-reports by roughly a limb radius. The
31// number travels with that caveat in-band, every call.
32//
33// ⚠★AND THE FIELD ITSELF SAYS THERE IS NO STANDARD PARAMETER SET ("various methods may employ
34// disparate parameter choices and even design distinct evaluation approaches"). So every threshold
35// this organ uses is EMITTED IN THE OUTPUT. A plausibility number quoted without its thresholds is
36// not comparable to anyone else's, including our own last run.
37//
38//   nx_actbench score <trace> <skel.dat>
39//   nx_actbench selftest
40// license_tier: ORIGINAL  expect_exit: 0  No hw writes (Rule 26).
41import "nx_gate_verdict.nx"
42const AB_MAGIC_65536: i64 = 65536
43const AB_MAGIC_4096: i64 = 4096
44const AB_MAGIC_1523: i64 = 1523
45
46// ---- capacity. ★DECLARED AND FAIL-LOUD, not preallocated-and-truncating. This program has now been
47// bitten three times by an emitter that silently stopped at a cap (the red-face bug, the part array,
48// the ring pool), so a trace beyond these bounds is REFUSED with its own exit code.
49const AB_MAXF: i64 = 512
50const AB_MAXJ: i64 = 64
51const AB_MAXC: i64 = 32
52// C-row stride: joint, parent, child, bone, flexion-axis, sign-of-positive-flexion
53const AB_CST: i64 = 6
54// capsule limb proxies for channel 6: <j0> <j1> <radius_mm>
55const AB_MAXS: i64 = 32
56const AB_SST: i64 = 3
57// samples along a capsule axis when probing closest approach; declared in the output because it
58// bounds the resolution of the penetration depth
59const AB_CAPSAMP: i64 = 16
60const AB_MAXB: i64 = 24
61const AB_MODE: i64 = 420
62// ---- the declared thresholds. Every one of these is printed in the output.
63// 5mm is the tolerance the literature uses for both penetration and float, to absorb geometry
64// approximation. It is theirs, not tuned by us.
65const AB_GTOL: i64 = 5
66// a foot counts as in contact below this height. Ours, declared: a joint sits inboard of the sole,
67// so the contact band must be at least an ankle radius.
68const AB_CONTACT: i64 = 40
69// half-width of the support a single contacting foot provides, in mm. Ours, declared.
70const AB_FOOTHALF: i64 = 60
71const AB_SCALE: i64 = 1024
72const AB_PERMIL: i64 = 1000
73const AB_DEG: i64 = 180
74// cosine table build precision: 2^20 internally, stored at 2^10 (AB_SCALE)
75const AB_FXB: i64 = 20
76const AB_COS1: i64 = 1048416
77const AB_SIN1: i64 = 18300
78const AB_ONE20: i64 = 1048576
79// exit codes -- distinct, so a caller can tell WHICH refusal happened
80const AB_E_OPEN: i64 = 3
81const AB_E_CAP: i64 = 4
82const AB_E_EMPTY: i64 = 5
83
84func ab_puts(s: *u8) -> i64 { var n: i64=0; while s[n]!=(0 as u8){n=n+1} sys_write(1,s,n); return 0 }
85func ab_pn(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
93}
94func ab_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
98}
99func ab_iabs(v: i64) -> i64 { if v<0 { return 0-v } return v }
100// integer sqrt, Newton. ★Bounded inputs only: callers pass squared millimetre distances, so the
101// argument stays far below the i64 ceiling -- the nx_twinbench overflow (a determinant over squared
102// edge lengths reached 1e25 and wrapped SILENTLY to a plausible number) is the reason that sentence
103// is written down rather than assumed.
104func ab_isqrt(v: i64) -> i64 {
  if v <= 0 { return 0 }
  var x: i64 = v
  var y: i64 = (x+1)/2
  while y < x { x = y; y = (x + v/x)/2 }
  return x
110}
111
112// ---- COSINE TABLE, 0..180 degrees at AB_SCALE. Built by angle-addition recurrence from cos(1deg) and
113// sin(1deg) rather than typed as 181 literals: a hand-typed trig table is ~181 chances to fat-finger a
114// digit and a wrong cosine looks exactly like a right one. The KAT tooth checks the known values.
115func ab_costab() -> *i64 {
  let t: *i64 = sys_mmap((AB_DEG+1)*8) as *i64
  var c: i64 = AB_ONE20
  var s: i64 = 0
  var d: i64 = 0
  while d <= AB_DEG {
      t[d] = c >> (AB_FXB - 10)
      let nc: i64 = (c*AB_COS1 - s*AB_SIN1) >> AB_FXB
      let ns: i64 = (s*AB_COS1 + c*AB_SIN1) >> AB_FXB
      c = nc
      s = ns
      d = d + 1
  }
  return t
129}
130// acos by monotone search: cos is strictly decreasing on 0..180, so the first index whose cosine is
131// at or below the target IS the angle. Same table, read backwards -- no second approximation.
132func ab_acos(cv: i64, t: *i64) -> i64 {
  var d: i64 = 0
  var got: i64 = AB_DEG
  var go: i64 = 1
  while go == 1 {
      if d > AB_DEG { go = 0 } else {
          if t[d] <= cv { got = d; go = 0 } else { d = d + 1 }
      }
  }
  return got
142}
143
144// ---- tiny text parsing over a whole-file buffer
145func ab_isdig(c: i64) -> i64 { if c>=48 { if c<=57 { return 1 } } return 0 }
146// read one signed integer starting at or after p[0]; advances p[0] past it. rc 1 = got one, 0 = none.
147func ab_tok(b: *u8, n: i64, p: *i64, out: *i64) -> i64 {
  var i: i64 = p[0]
  var go: i64 = 1
  while go == 1 {
      if i >= n { go = 0 } else {
          let c: i64 = b[i] as i64
          var st: i64 = 0
          if ab_isdig(c) == 1 { st = 1 }
          if c == 45 { st = 1 }
          if st == 1 { go = 0 } else { i = i + 1 }
      }
  }
  if i >= n { p[0] = i; return 0 }
  var sg: i64 = 1
  if b[i] as i64 == 45 { sg = 0-1; i = i + 1 }
  var v: i64 = 0
  var g2: i64 = 1
  while g2 == 1 {
      if i >= n { g2 = 0 } else {
          let c2: i64 = b[i] as i64
          if ab_isdig(c2) == 1 { v = v*10 + (c2-48); i = i + 1 } else { g2 = 0 }
      }
  }
  p[0] = i
  out[0] = v*sg
  return 1
173}
174// advance p[0] to the first byte of the next line
175func ab_nextline(b: *u8, n: i64, p: *i64) -> i64 {
  var i: i64 = p[0]
  var go: i64 = 1
  while go == 1 {
      if i >= n { go = 0 } else {
          if b[i] as i64 == 10 { i = i + 1; go = 0 } else { i = i + 1 }
      }
  }
  p[0] = i
  return 0
185}
186
187// ---- trace store. V[(f*AB_MAXJ + j)*3 + axis] in millimetres. present[] marks filled slots.
188func ab_vidx(f: i64, j: i64, ax: i64) -> i64 { return (f*AB_MAXJ + j)*3 + ax }
189
190// ---- support geometry ------------------------------------------------------------------------
191// ★★★A SUPPORT POLYGON OF TWO POINTS CANNOT REPRESENT A TWO-FOOTED STANCE. The first version of the
192// CoM channel took the first two contacts and treated the segment between them as the support. With a
193// heel and a toe per foot that is FOUR contacts, and it silently used the right foot only -- so a
194// correctly standing body measured as falling sideways by exactly its half-stance width. The declared
195// approximation covered "one or two contacts"; using two OUT OF four was an UNDECLARED truncation,
196// which is the failure class this program keeps re-finding. Fixed properly: the real convex hull.
197func ab_seg_dist(ax: i64, az: i64, bx: i64, bz: i64, px: i64, pz: i64) -> i64 {
  let ex: i64 = bx-ax
  let ez: i64 = bz-az
  let den: i64 = ex*ex + ez*ez
  var t256: i64 = 0
  if den > 0 {
      let num: i64 = (px-ax)*ex + (pz-az)*ez
      t256 = num*256/den
      if t256 < 0 { t256 = 0 }
      if t256 > 256 { t256 = 256 }
  }
  let qx: i64 = ax + ex*t256/256
  let qz: i64 = az + ez*t256/256
  let dx: i64 = px-qx
  let dz: i64 = pz-qz
  return ab_isqrt(dx*dx + dz*dz)
213}
214// Andrew monotone chain over the contact points, integer throughout. n is small (a few contacts), so
215// the insertion sort is the right tool and its cost is invisible.
216func ab_hull(cx: *i64, cz: *i64, n: i64, hx: *i64, hz: *i64) -> i64 {
  var i: i64 = 1
  while i < n {
      let kx: i64 = cx[i]
      let kz: i64 = cz[i]
      var j: i64 = i-1
      var go: i64 = 1
      while go == 1 {
          if j < 0 { go = 0 } else {
              var gt: i64 = 0
              if cx[j] > kx { gt = 1 }
              if cx[j] == kx { if cz[j] > kz { gt = 1 } }
              if gt == 1 { cx[j+1]=cx[j]; cz[j+1]=cz[j]; j=j-1 } else { go = 0 }
          }
      }
      cx[j+1]=kx; cz[j+1]=kz
      i = i + 1
  }
  var k: i64 = 0
  var a: i64 = 0
  while a < n {
      var g2: i64 = 1
      while g2 == 1 {
          if k < 2 { g2 = 0 } else {
              let cr: i64 = (hx[k-1]-hx[k-2])*(cz[a]-hz[k-2]) - (hz[k-1]-hz[k-2])*(cx[a]-hx[k-2])
              if cr <= 0 { k = k-1 } else { g2 = 0 }
          }
      }
      hx[k]=cx[a]; hz[k]=cz[a]; k=k+1
      a = a + 1
  }
  let lower: i64 = k+1
  var b: i64 = n-2
  while b >= 0 {
      var g3: i64 = 1
      while g3 == 1 {
          if k < lower { g3 = 0 } else {
              let cr: i64 = (hx[k-1]-hx[k-2])*(cz[b]-hz[k-2]) - (hz[k-1]-hz[k-2])*(cx[b]-hx[k-2])
              if cr <= 0 { k = k-1 } else { g3 = 0 }
          }
      }
      hx[k]=cx[b]; hz[k]=cz[b]; k=k+1
      b = b - 1
  }
  if n == 1 { return 1 }
  return k-1
262}
263// distance from a point to the hull: 0 if inside. The inside test accepts EITHER winding, so it does
264// not silently depend on the hull builder's orientation.
265func ab_hull_dist(hx: *i64, hz: *i64, h: i64, px: i64, pz: i64) -> i64 {
  if h <= 1 {
      let dx: i64 = px-hx[0]
      let dz: i64 = pz-hz[0]
      return ab_isqrt(dx*dx + dz*dz)
  }
  if h == 2 { return ab_seg_dist(hx[0],hz[0],hx[1],hz[1],px,pz) }
  var pos: i64 = 0
  var neg: i64 = 0
  var i: i64 = 0
  while i < h {
      let j: i64 = (i+1)%h
      let cr: i64 = (hx[j]-hx[i])*(pz-hz[i]) - (hz[j]-hz[i])*(px-hx[i])
      if cr > 0 { pos = 1 }
      if cr < 0 { neg = 1 }
      i = i + 1
  }
  if pos == 0 { return 0 }
  if neg == 0 { return 0 }
  var best: i64 = 0-1
  var m: i64 = 0
  while m < h {
      let j2: i64 = (m+1)%h
      let d: i64 = ab_seg_dist(hx[m],hz[m],hx[j2],hz[j2],px,pz)
      if best < 0 { best = d } else { if d < best { best = d } }
      m = m + 1
  }
  return best
293}
294
295// ---- 3D point-to-segment, the primitive channel 6 is built from.
296// ⚠BOUNDS, stated because nx_twinbench died of exactly this: coordinates are millimetres (~2e3), so
297// differences are ~4e3, squared sums ~5e7, and the largest intermediate (num*256) is ~1.3e10 --
298// six orders of magnitude clear of the i64 ceiling. No magnitude reduction needed here.
299func ab_pt_seg3(ax: i64, ay: i64, az: i64, bx: i64, by: i64, bz: i64,
              px: i64, py: i64, pz: i64) -> i64 {
  let ex: i64 = bx-ax
  let ey: i64 = by-ay
  let ez: i64 = bz-az
  let den: i64 = ex*ex + ey*ey + ez*ez
  var t256: i64 = 0
  if den > 0 {
      let num: i64 = (px-ax)*ex + (py-ay)*ey + (pz-az)*ez
      t256 = num*256/den
      if t256 < 0 { t256 = 0 }
      if t256 > 256 { t256 = 256 }
  }
  let qx: i64 = ax + ex*t256/256
  let qy: i64 = ay + ey*t256/256
  let qz: i64 = az + ez*t256/256
  let dx: i64 = px-qx
  let dy: i64 = py-qy
  let dz: i64 = pz-qz
  return ab_isqrt(dx*dx + dy*dy + dz*dz)
319}
320// Closest approach between two capsule AXES, by DECLARED SAMPLING along the first one -- the same
321// honesty nx_twinbench applies to its surface query. Sampling can only ever OVERSTATE the distance
322// (i.e. UNDER-report penetration), never invent one, so the error has a known sign and the sample
323// count travels in the output.
324func ab_seg_seg3(ax: i64, ay: i64, az: i64, bx: i64, by: i64, bz: i64,
               cx: i64, cy: i64, cz: i64, dx: i64, dy: i64, dz: i64) -> i64 {
  var best: i64 = 0-1
  var s: i64 = 0
  while s <= AB_CAPSAMP {
      let px: i64 = ax + (bx-ax)*s/AB_CAPSAMP
      let py: i64 = ay + (by-ay)*s/AB_CAPSAMP
      let pz: i64 = az + (bz-az)*s/AB_CAPSAMP
      let d: i64 = ab_pt_seg3(cx,cy,cz,dx,dy,dz,px,py,pz)
      if best < 0 { best = d } else { if d < best { best = d } }
      s = s + 1
  }
  return best
337}
338
339// ---- the six channels ------------------------------------------------------------------------
340// Each returns its raw measurement; the caller prints them with the thresholds that produced them.
341
342// CHANNEL 1 -- GROUND PENETRATION. Literature: distance between the ground and the lowest body vertex
343// BELOW the ground, 5mm tolerance. Ours is over joints (declared substitution above).
344// out[0] = mean depth over violating frames (mm), out[1] = worst depth, out[2] = violating frames
345func ab_gpen(V: *i64, nf: i64, nj: i64, out: *i64) -> i64 {
  var sum: i64 = 0
  var worst: i64 = 0
  var cnt: i64 = 0
  var f: i64 = 0
  while f < nf {
      var lo: i64 = 0
      var have: i64 = 0
      var j: i64 = 0
      while j < nj {
          let y: i64 = V[ab_vidx(f,j,1)]
          if have == 0 { lo = y; have = 1 } else { if y < lo { lo = y } }
          j = j + 1
      }
      if have == 1 {
          let depth: i64 = 0 - lo - AB_GTOL
          if depth > 0 { sum = sum + depth; cnt = cnt + 1; if depth > worst { worst = depth } }
      }
      f = f + 1
  }
  out[0] = 0
  if cnt > 0 { out[0] = sum/cnt }
  out[1] = worst
  out[2] = cnt
  return 0
370}
371
372// CHANNEL 2 -- FLOAT. Frames where nothing is within tolerance of the ground; the reported value is
373// the lowest joint's height above it.
374// ⚠HONEST LIMIT, DECLARED: a genuine airborne phase (a jump) IS floating and this channel cannot tell
375// it from a body hovering. PhyMotion's version additionally requires the body to fail a plausible
376// BALLISTIC trajectory before flagging. We do not model ballistics, so this channel OVER-REPORTS on
377// any motion with real flight. It is evidence, not a verdict, until a ballistic test exists.
378func ab_float(V: *i64, nf: i64, nj: i64, out: *i64) -> i64 {
  var sum: i64 = 0
  var worst: i64 = 0
  var cnt: i64 = 0
  var f: i64 = 0
  while f < nf {
      var lo: i64 = 0
      var have: i64 = 0
      var j: i64 = 0
      while j < nj {
          let y: i64 = V[ab_vidx(f,j,1)]
          if have == 0 { lo = y; have = 1 } else { if y < lo { lo = y } }
          j = j + 1
      }
      if have == 1 {
          let h: i64 = lo - AB_GTOL
          if h > 0 { sum = sum + h; cnt = cnt + 1; if h > worst { worst = h } }
      }
      f = f + 1
  }
  out[0] = 0
  if cnt > 0 { out[0] = sum/cnt }
  out[1] = worst
  out[2] = cnt
  return 0
403}
404
405// CHANNEL 3 -- FOOT SKATE. Literature: for foot joints in contact across two ADJACENT frames, the
406// average HORIZONTAL displacement within those frames. A planted foot must read ~0; a sliding one
407// must read its slide.
408// out[0] = mean mm per contact pair, out[1] = worst, out[2] = number of contact pairs
409func ab_skate(V: *i64, nf: i64, E: *i64, ne: i64, out: *i64) -> i64 {
  var sum: i64 = 0
  var worst: i64 = 0
  var pairs: i64 = 0
  var f: i64 = 1
  while f < nf {
      var e: i64 = 0
      while e < ne {
          let j: i64 = E[e]
          let y0: i64 = V[ab_vidx(f-1,j,1)]
          let y1: i64 = V[ab_vidx(f,j,1)]
          if y0 <= AB_CONTACT { if y1 <= AB_CONTACT {
              let dx: i64 = V[ab_vidx(f,j,0)] - V[ab_vidx(f-1,j,0)]
              let dz: i64 = V[ab_vidx(f,j,2)] - V[ab_vidx(f-1,j,2)]
              let d: i64 = ab_isqrt(dx*dx + dz*dz)
              sum = sum + d
              pairs = pairs + 1
              if d > worst { worst = d }
          } }
          e = e + 1
      }
      f = f + 1
  }
  out[0] = 0
  if pairs > 0 { out[0] = sum/pairs }
  out[1] = worst
  out[2] = pairs
  return 0
437}
438
439// CHANNEL 4 -- JOINT-ANGLE LIMIT VIOLATIONS. The one channel we already owned: nx_skelgen's sg_legal
440// is fail-closed and gate-proven. Here the limits are READ FROM ITS EMITTED FILE, so this can never
441// disagree with the generator.
442//
443// ★★★THE FLEXION ANGLE MUST BE SIGNED, AND THE FIRST VERSION OF THIS FUNCTION WAS NOT. It computed the
444// INTERIOR angle at the joint and called 180-interior the flexion. That is unsigned, and a knee bent
445// sixty degrees forward has EXACTLY the same interior angle as one bent sixty degrees backward -- so
446// the channel was structurally incapable of detecting hyperextension, which is the single violation it
447// exists to catch. The gate's T9 caught it on the first run.
448// ★SAME CLASS AS TWO EARLIER FINDINGS IN THIS LANE -- "a protruding structure cannot be a radius
449// modulation" and "relief modulates a radius and cannot cut a hole": a representation that cannot
450// EXPRESS the thing, not a number that needed tuning. The fix is a representation change, not a
451// threshold change.
452// ★THE SIGN COMES FROM ANATOMY: flexion is rotation about the joint's mediolateral axis, so the sign
453// is the sign of (BA x BC) along that axis. A C row therefore names its flexion axis and which sign of
454// that component counts as positive flexion. For a knee that is the x axis, and the knee sitting
455// POSTERIOR to the hip-ankle line is genu recurvatum -- negative flexion, refused by lo=0.
456// Legal iff lo <= signed_flex <= hi.
457// out[0] = violations per mille of samples, out[1] = worst overshoot in degrees, out[2] = samples
458func ab_jlimit(V: *i64, nf: i64, C: *i64, nc: i64, BLO: *i64, BHI: *i64, t: *i64, out: *i64) -> i64 {
  var viol: i64 = 0
  var worst: i64 = 0
  var n: i64 = 0
  var f: i64 = 0
  while f < nf {
      var c: i64 = 0
      while c < nc {
          let jj: i64 = C[c*AB_CST]
          let pa: i64 = C[c*AB_CST+1]
          let ch: i64 = C[c*AB_CST+2]
          let bo: i64 = C[c*AB_CST+3]
          let axis: i64 = C[c*AB_CST+4]
          let posw: i64 = C[c*AB_CST+5]
          let ax: i64 = V[ab_vidx(f,pa,0)] - V[ab_vidx(f,jj,0)]
          let ay: i64 = V[ab_vidx(f,pa,1)] - V[ab_vidx(f,jj,1)]
          let az: i64 = V[ab_vidx(f,pa,2)] - V[ab_vidx(f,jj,2)]
          let bx: i64 = V[ab_vidx(f,ch,0)] - V[ab_vidx(f,jj,0)]
          let by: i64 = V[ab_vidx(f,ch,1)] - V[ab_vidx(f,jj,1)]
          let bz: i64 = V[ab_vidx(f,ch,2)] - V[ab_vidx(f,jj,2)]
          let la: i64 = ab_isqrt(ax*ax+ay*ay+az*az)
          let lb: i64 = ab_isqrt(bx*bx+by*by+bz*bz)
          if la > 0 { if lb > 0 {
              let dot: i64 = ax*bx + ay*by + az*bz
              var cv: i64 = dot*AB_SCALE/(la*lb)
              if cv > AB_SCALE { cv = AB_SCALE }
              if cv < 0-AB_SCALE { cv = 0-AB_SCALE }
              let interior: i64 = ab_acos(cv, t)
              // ★the signed part: which way did it bend? Cross product about the flexion axis.
              var comp: i64 = 0
              if axis == 0 { comp = ay*bz - az*by }
              if axis == 1 { comp = az*bx - ax*bz }
              if axis == 2 { comp = ax*by - ay*bx }
              var sgn: i64 = 1
              if comp*posw < 0 { sgn = 0-1 }
              let flex: i64 = sgn * (AB_DEG - interior)
              n = n + 1
              var over: i64 = 0
              if flex < BLO[bo] { over = BLO[bo] - flex }
              if flex > BHI[bo] { over = flex - BHI[bo] }
              if over > 0 { viol = viol + 1; if over > worst { worst = over } }
          } }
          c = c + 1
      }
      f = f + 1
  }
  out[0] = 0
  if n > 0 { out[0] = viol*AB_PERMIL/n }
  out[1] = worst
  out[2] = n
  return 0
509}
510
511// CHANNEL 5 -- TEMPORAL SMOOTHNESS (jitter). Mean magnitude of the discrete THIRD difference (jerk)
512// over every joint and frame, in mm per frame cubed. Needs four consecutive frames.
513// out[0] = mean jerk, out[1] = worst, out[2] = samples
514func ab_smooth(V: *i64, nf: i64, nj: i64, out: *i64) -> i64 {
  var sum: i64 = 0
  var worst: i64 = 0
  var n: i64 = 0
  var f: i64 = 3
  while f < nf {
      var j: i64 = 0
      while j < nj {
          var a: i64 = 0
          var acc: i64 = 0
          while a < 3 {
              // third difference: p[f] - 3p[f-1] + 3p[f-2] - p[f-3]
              let d: i64 = V[ab_vidx(f,j,a)] - 3*V[ab_vidx(f-1,j,a)] + 3*V[ab_vidx(f-2,j,a)] - V[ab_vidx(f-3,j,a)]
              acc = acc + d*d
              a = a + 1
          }
          let m: i64 = ab_isqrt(acc)
          sum = sum + m
          n = n + 1
          if m > worst { worst = m }
          j = j + 1
      }
      f = f + 1
  }
  out[0] = 0
  if n > 0 { out[0] = sum/n }
  out[1] = worst
  out[2] = n
  return 0
543}
544
545// CHANNEL 6 -- CENTRE-OF-MASS STABILITY. PhyMotion: the fraction of frames where the projected centre
546// of mass falls outside the SUPPORT POLYGON of the contacting feet.
547// ⚠TWO DECLARED APPROXIMATIONS: (a) our CoM is the arithmetic mean of joint positions, NOT a
548// mass-weighted sum of segment centroids -- we have no segment masses, and inventing them would be a
549// magic number; (b) with one or two contacts the "polygon" is a point or a segment, so support is
550// taken as that primitive dilated by AB_FOOTHALF. Both travel in the output.
551// out[0] = unstable frames per mille of SUPPORTED frames, out[1] = worst excess mm, out[2] = supported frames
552func ab_com(V: *i64, nf: i64, nj: i64, E: *i64, ne: i64, out: *i64) -> i64 {
  var bad: i64 = 0
  var worst: i64 = 0
  var sup: i64 = 0
  let px: *i64 = sys_mmap(AB_MAXJ*8) as *i64
  let pz: *i64 = sys_mmap(AB_MAXJ*8) as *i64
  let hx: *i64 = sys_mmap(AB_MAXJ*4*8) as *i64
  let hz: *i64 = sys_mmap(AB_MAXJ*4*8) as *i64
  var f: i64 = 0
  while f < nf {
      var sx: i64 = 0
      var sz: i64 = 0
      var j: i64 = 0
      while j < nj { sx = sx + V[ab_vidx(f,j,0)]; sz = sz + V[ab_vidx(f,j,2)]; j = j + 1 }
      if nj > 0 {
          let cx: i64 = sx/nj
          let cz: i64 = sz/nj
          // gather EVERY contacting foot point -- all of them, not the first two
          var nct: i64 = 0
          var e: i64 = 0
          while e < ne {
              let jf: i64 = E[e]
              if V[ab_vidx(f,jf,1)] <= AB_CONTACT {
                  px[nct] = V[ab_vidx(f,jf,0)]
                  pz[nct] = V[ab_vidx(f,jf,2)]
                  nct = nct + 1
              }
              e = e + 1
          }
          if nct > 0 {
              sup = sup + 1
              let h: i64 = ab_hull(px, pz, nct, hx, hz)
              let dist: i64 = ab_hull_dist(hx, hz, h, cx, cz)
              let ex2: i64 = dist - AB_FOOTHALF
              if ex2 > 0 { bad = bad + 1; if ex2 > worst { worst = ex2 } }
          }
      }
      f = f + 1
  }
  out[0] = 0
  if sup > 0 { out[0] = bad*AB_PERMIL/sup }
  out[1] = worst
  out[2] = sup
  return 0
596}
597
598// CHANNEL 6 -- SELF-PENETRATION. An arm through the torso. PHYSSCORE measures this on the MESH; we are
599// fed a joint trace, so limbs are represented by CAPSULE PROXIES supplied as data (`S <j0> <j1> <r>`).
600// ★★RADII ARE NOT A CONSTANT IN THIS FILE. There is no defensible universal limb radius, so rather
601// than bury one (rule 11) the caller supplies it and the organ reports that it did. With NO S rows the
602// channel REFUSES rather than returning a clean 0 -- coverage then honestly reads 5 of 6, not 6.
603// ★★★ADJACENCY IS DERIVED, NOT DECLARED. Two capsules sharing a joint MEET there by construction, so
604// every adjacent pair would read as penetrating and every body would score as broken. The shared-joint
605// test is read off the S rows themselves -- there is no second adjacency table to drift from, the same
606// discipline channel 4 uses for its limits. T18 is the tooth that holds this.
607// two joints are LINKED if they are the same joint or one is the other's parent -- the articulated
608// equivalent of "these two limbs meet here, and meeting is not penetrating"
609func ab_linked(a: i64, b: i64, JP: *i64) -> i64 {
  if a == b { return 1 }
  if a >= 0 { if a < AB_MAXJ { if JP[a] == b { return 1 } } }
  if b >= 0 { if b < AB_MAXJ { if JP[b] == a { return 1 } } }
  return 0
614}
615// out[0]=mean depth over violations, out[1]=worst depth, out[2]=violations, out[3]=pairs tested
616func ab_selfpen(V: *i64, nf: i64, S: *i64, ns: i64, JP: *i64, out: *i64) -> i64 {
  var sum: i64 = 0
  var worst: i64 = 0
  var viol: i64 = 0
  var pairs: i64 = 0
  var f: i64 = 0
  while f < nf {
      var i: i64 = 0
      while i < ns {
          var j: i64 = i+1
          while j < ns {
              let a0: i64 = S[i*AB_SST]
              let a1: i64 = S[i*AB_SST+1]
              let b0: i64 = S[j*AB_SST]
              let b1: i64 = S[j*AB_SST+1]
              // ★★DERIVED ADJACENCY, AND THE FIRST VERSION WAS TOO WEAK. Sharing an ENDPOINT is not
              // the only way two limbs legitimately meet: a thigh's proximal joint is a CHILD of the
              // torso's, so a femoral head sits inside the pelvic volume with no shared index at
              // all. Measured on the real skeleton, that false-positived the torso against both
              // thighs (111mm) and both arms. So adjacency reads the PARENT CHAIN out of the J rows
              // nx_skelgen already emits -- still derived, still no second table.
              var adj: i64 = 0
              if ab_linked(a0,b0,JP) == 1 { adj = 1 }
              if ab_linked(a0,b1,JP) == 1 { adj = 1 }
              if ab_linked(a1,b0,JP) == 1 { adj = 1 }
              if ab_linked(a1,b1,JP) == 1 { adj = 1 }
              if adj == 0 {
                  pairs = pairs + 1
                  let d: i64 = ab_seg_seg3(
                      V[ab_vidx(f,a0,0)], V[ab_vidx(f,a0,1)], V[ab_vidx(f,a0,2)],
                      V[ab_vidx(f,a1,0)], V[ab_vidx(f,a1,1)], V[ab_vidx(f,a1,2)],
                      V[ab_vidx(f,b0,0)], V[ab_vidx(f,b0,1)], V[ab_vidx(f,b0,2)],
                      V[ab_vidx(f,b1,0)], V[ab_vidx(f,b1,1)], V[ab_vidx(f,b1,2)])
                  let depth: i64 = S[i*AB_SST+2] + S[j*AB_SST+2] - d
                  if depth > 0 {
                      sum = sum + depth
                      viol = viol + 1
                      if depth > worst { worst = depth }
                  }
              }
              j = j + 1
          }
          i = i + 1
      }
      f = f + 1
  }
  out[0] = 0
  if viol > 0 { out[0] = sum/viol }
  out[1] = worst
  out[2] = viol
  out[3] = pairs
  return 0
668}
669
670// ---- loaders ---------------------------------------------------------------------------------
671// skeleton: consume nx_skelgen's own "B <bone> <len> <lo> <hi>" rows. rc = bones read, <0 = refused.
672func ab_load_skel(path: *u8, BLO: *i64, BHI: *i64, JP: *i64) -> i64 {
  let ln: *i64 = sys_mmap(16) as *i64
  let buf: *u8 = sys_read_file(path, ln)
  if buf as i64 == 0 { return 0-1 }
  let n: i64 = ln[0]
  let p: *i64 = sys_mmap(16) as *i64
  let v: *i64 = sys_mmap(16) as *i64
  p[0] = 0
  var z: i64 = 0
  while z < AB_MAXJ { JP[z] = 0-1; z = z + 1 }
  var cnt: i64 = 0
  var go: i64 = 1
  while go == 1 {
      if p[0] >= n { go = 0 } else {
          let c: i64 = buf[p[0]] as i64
          if c == 66 {
              p[0] = p[0] + 1
              if ab_tok(buf,n,p,v) == 1 {
                  let b: i64 = v[0]
                  if ab_tok(buf,n,p,v) == 1 {
                      if ab_tok(buf,n,p,v) == 1 {
                          let lo: i64 = v[0]
                          if ab_tok(buf,n,p,v) == 1 {
                              if b >= 0 { if b < AB_MAXB { BLO[b]=lo; BHI[b]=v[0]; cnt=cnt+1 } }
                          }
                      }
                  }
              }
          }
          // J <idx> <parent> <side> <x> <y> <z> -- only the parent column is needed here
          if c == 74 {
              p[0] = p[0] + 1
              if ab_tok(buf,n,p,v) == 1 {
                  let jid: i64 = v[0]
                  if ab_tok(buf,n,p,v) == 1 {
                      if jid >= 0 { if jid < AB_MAXJ { JP[jid] = v[0] } }
                  }
              }
          }
          ab_nextline(buf,n,p)
      }
  }
  return cnt
715}
716// trace. cfg[0]=nframes cfg[1]=njoints cfg[2]=nfeet cfg[3]=nangles. rc 0 ok, else refusal code.
717func ab_load_trace(path: *u8, V: *i64, E: *i64, C: *i64, S: *i64, cfg: *i64) -> i64 {
  let ln: *i64 = sys_mmap(16) as *i64
  let buf: *u8 = sys_read_file(path, ln)
  if buf as i64 == 0 { return AB_E_OPEN }
  let n: i64 = ln[0]
  let p: *i64 = sys_mmap(16) as *i64
  let v: *i64 = sys_mmap(16) as *i64
  p[0] = 0
  cfg[0]=0; cfg[1]=0; cfg[2]=0; cfg[3]=0; cfg[4]=0
  var rc: i64 = 0
  var go: i64 = 1
  while go == 1 {
      if p[0] >= n { go = 0 } else {
          let c: i64 = buf[p[0]] as i64
          if c == 65 {
              p[0] = p[0] + 1
              if ab_tok(buf,n,p,v) == 1 {
                  let nf: i64 = v[0]
                  if ab_tok(buf,n,p,v) == 1 {
                      let nj: i64 = v[0]
                      // ★REFUSE LOUD rather than truncate -- the whole point of the capacity law
                      if nf > AB_MAXF { rc = AB_E_CAP; go = 0 }
                      if nj > AB_MAXJ { rc = AB_E_CAP; go = 0 }
                      if rc == 0 { cfg[0]=nf; cfg[1]=nj }
                  }
              }
          }
          if c == 69 {
              p[0] = p[0] + 1
              if ab_tok(buf,n,p,v) == 1 {
                  if cfg[2] < AB_MAXJ { E[cfg[2]] = v[0]; cfg[2] = cfg[2]+1 }
              }
          }
          if c == 67 {
              p[0] = p[0] + 1
              if cfg[3] < AB_MAXC {
                  let k: i64 = cfg[3]*AB_CST
                  var okc: i64 = 1
                  if ab_tok(buf,n,p,v) == 1 { C[k]=v[0] } else { okc = 0 }
                  if ab_tok(buf,n,p,v) == 1 { C[k+1]=v[0] } else { okc = 0 }
                  if ab_tok(buf,n,p,v) == 1 { C[k+2]=v[0] } else { okc = 0 }
                  if ab_tok(buf,n,p,v) == 1 { C[k+3]=v[0] } else { okc = 0 }
                  if ab_tok(buf,n,p,v) == 1 { C[k+4]=v[0] } else { okc = 0 }
                  if ab_tok(buf,n,p,v) == 1 { C[k+5]=v[0] } else { okc = 0 }
                  if okc == 1 { cfg[3] = cfg[3]+1 }
              }
          }
          if c == 83 {
              p[0] = p[0] + 1
              if cfg[4] < AB_MAXS {
                  let k: i64 = cfg[4]*AB_SST
                  var oks: i64 = 1
                  if ab_tok(buf,n,p,v) == 1 { S[k]=v[0] } else { oks = 0 }
                  if ab_tok(buf,n,p,v) == 1 { S[k+1]=v[0] } else { oks = 0 }
                  if ab_tok(buf,n,p,v) == 1 { S[k+2]=v[0] } else { oks = 0 }
                  if oks == 1 { cfg[4] = cfg[4]+1 }
              }
          }
          if c == 86 {
              p[0] = p[0] + 1
              var f: i64 = 0
              var j: i64 = 0
              var okv: i64 = 1
              if ab_tok(buf,n,p,v) == 1 { f=v[0] } else { okv = 0 }
              if ab_tok(buf,n,p,v) == 1 { j=v[0] } else { okv = 0 }
              if okv == 1 {
                  if f >= 0 { if f < AB_MAXF { if j >= 0 { if j < AB_MAXJ {
                      if ab_tok(buf,n,p,v) == 1 { V[ab_vidx(f,j,0)] = v[0] }
                      if ab_tok(buf,n,p,v) == 1 { V[ab_vidx(f,j,1)] = v[0] }
                      if ab_tok(buf,n,p,v) == 1 { V[ab_vidx(f,j,2)] = v[0] }
                  } } } }
              }
          }
          if go == 1 { ab_nextline(buf,n,p) }
      }
  }
  if rc == 0 { if cfg[0] <= 0 { rc = AB_E_EMPTY } }
  return rc
795}
796
797func ab_vbytes() -> i64 { return AB_MAXF*AB_MAXJ*3*8 }
798
799// ---- the report ------------------------------------------------------------------------------
800func ab_score(tpath: *u8, spath: *u8) -> i64 {
  let V: *i64 = sys_mmap(ab_vbytes()) as *i64
  let E: *i64 = sys_mmap(AB_MAXJ*8) as *i64
  let C: *i64 = sys_mmap(AB_MAXC*AB_CST*8) as *i64
  let S: *i64 = sys_mmap(AB_MAXS*AB_SST*8) as *i64
  let cfg: *i64 = sys_mmap(64) as *i64
  let BLO: *i64 = sys_mmap(AB_MAXB*8) as *i64
  let BHI: *i64 = sys_mmap(AB_MAXB*8) as *i64
  let JP: *i64 = sys_mmap(AB_MAXJ*8) as *i64
  let rc: i64 = ab_load_trace(tpath, V, E, C, S, cfg)
  if rc != 0 {
      ab_puts("{\x22organ\x22:\x22nx_actbench\x22,\x22action\x22:\x22REFUSED\x22,\x22rc\x22:" as *u8); ab_pn(rc)
      ab_puts(",\x22why\x22:\x22trace unreadable, empty, or beyond declared capacity -- refused loudly rather than truncated\x22}\n" as *u8)
      return rc
  }
  let nb: i64 = ab_load_skel(spath, BLO, BHI, JP)
  let t: *i64 = ab_costab()
  let o1: *i64 = sys_mmap(64) as *i64
  let o2: *i64 = sys_mmap(64) as *i64
  let o3: *i64 = sys_mmap(64) as *i64
  let o4: *i64 = sys_mmap(64) as *i64
  let o5: *i64 = sys_mmap(64) as *i64
  let o6: *i64 = sys_mmap(64) as *i64
  ab_gpen(V, cfg[0], cfg[1], o1)
  ab_float(V, cfg[0], cfg[1], o2)
  ab_skate(V, cfg[0], E, cfg[2], o3)
  ab_jlimit(V, cfg[0], C, cfg[3], BLO, BHI, t, o4)
  ab_smooth(V, cfg[0], cfg[1], o5)
  ab_com(V, cfg[0], cfg[1], E, cfg[2], o6)
  ab_puts("{\x22organ\x22:\x22nx_actbench\x22,\x22v\x22:1,\x22standard\x22:\x22PHYSSCORE 6-channel composite (PhysHuman @ CVPR 2026); definitions from the PhysDiff/EDGE lineage + PhyMotion arXiv:2605.14269\x22" as *u8)
  ab_puts(",\x22frames\x22:" as *u8); ab_pn(cfg[0])
  ab_puts(",\x22joints\x22:" as *u8); ab_pn(cfg[1])
  ab_puts(",\x22feet\x22:" as *u8); ab_pn(cfg[2])
  ab_puts(",\x22angle_sites\x22:" as *u8); ab_pn(cfg[3])
  ab_puts(",\x22skel_bones\x22:" as *u8); ab_pn(nb)
  ab_puts(",\x22ground_penetration\x22:{\x22mean_mm\x22:" as *u8); ab_pn(o1[0])
  ab_puts(",\x22worst_mm\x22:" as *u8); ab_pn(o1[1])
  ab_puts(",\x22frames\x22:" as *u8); ab_pn(o1[2]); ab_puts("}" as *u8)
  ab_puts(",\x22float\x22:{\x22mean_mm\x22:" as *u8); ab_pn(o2[0])
  ab_puts(",\x22worst_mm\x22:" as *u8); ab_pn(o2[1])
  ab_puts(",\x22frames\x22:" as *u8); ab_pn(o2[2])
  ab_puts(",\x22caveat\x22:\x22no ballistic test -- a genuine airborne phase is indistinguishable from hovering, so this OVER-REPORTS on motion with real flight\x22}" as *u8)
  ab_puts(",\x22foot_skate\x22:{\x22mean_mm_per_contact_pair\x22:" as *u8); ab_pn(o3[0])
  ab_puts(",\x22worst_mm\x22:" as *u8); ab_pn(o3[1])
  ab_puts(",\x22contact_pairs\x22:" as *u8); ab_pn(o3[2]); ab_puts("}" as *u8)
  ab_puts(",\x22joint_limit\x22:{\x22violations_permil\x22:" as *u8); ab_pn(o4[0])
  ab_puts(",\x22worst_overshoot_deg\x22:" as *u8); ab_pn(o4[1])
  ab_puts(",\x22samples\x22:" as *u8); ab_pn(o4[2])
  ab_puts(",\x22limits_from\x22:\x22the B rows nx_skelgen emitted -- there is no second constraint table to drift from\x22}" as *u8)
  ab_puts(",\x22temporal_smoothness\x22:{\x22mean_jerk_mm\x22:" as *u8); ab_pn(o5[0])
  ab_puts(",\x22worst_jerk_mm\x22:" as *u8); ab_pn(o5[1])
  ab_puts(",\x22samples\x22:" as *u8); ab_pn(o5[2]); ab_puts("}" as *u8)
  ab_puts(",\x22com_stability\x22:{\x22unstable_permil\x22:" as *u8); ab_pn(o6[0])
  ab_puts(",\x22worst_excess_mm\x22:" as *u8); ab_pn(o6[1])
  ab_puts(",\x22supported_frames\x22:" as *u8); ab_pn(o6[2]); ab_puts("}" as *u8)
  // ★CHANNEL 6 MEASURES ONLY IF THE CALLER SUPPLIED CAPSULE PROXIES. With none, it REFUSES rather
  // than returning a clean 0 -- "no self-penetration found" for a test that never ran is the exact
  // failure mode this program keeps hitting -- and the coverage line then says 5 of 6 out loud.
  var nchan: i64 = 5
  if cfg[4] > 0 {
      nchan = 6
      let o7: *i64 = sys_mmap(64) as *i64
      ab_selfpen(V, cfg[0], S, cfg[4], JP, o7)
      ab_puts(",\x22self_penetration\x22:{\x22mean_depth_mm\x22:" as *u8); ab_pn(o7[0])
      ab_puts(",\x22worst_depth_mm\x22:" as *u8); ab_pn(o7[1])
      ab_puts(",\x22violations\x22:" as *u8); ab_pn(o7[2])
      ab_puts(",\x22pairs_tested\x22:" as *u8); ab_pn(o7[3])
      ab_puts(",\x22capsules\x22:" as *u8); ab_pn(cfg[4])
      ab_puts(",\x22axis_samples\x22:" as *u8); ab_pn(AB_CAPSAMP)
      ab_puts(",\x22method\x22:\x22capsule limb proxies supplied as data, NOT a radius baked into this organ; adjacency DERIVED from shared joints so limbs that legitimately meet are never counted; sampled closest approach can only UNDER-report depth, never invent it\x22}" as *u8)
  } else {
      ab_puts(",\x22self_penetration\x22:{\x22status\x22:\x22ABSENT-REFUSED\x22,\x22why\x22:\x22no capsule proxies (S rows) supplied -- returning 0 would be a clean number for a test that never ran\x22}" as *u8)
  }
  ab_puts(",\x22channels_measured\x22:" as *u8); ab_pn(nchan)
  ab_puts(",\x22channels_total\x22:6" as *u8)
  ab_puts(",\x22thresholds\x22:{\x22ground_tol_mm\x22:" as *u8); ab_pn(AB_GTOL)
  ab_puts(",\x22contact_height_mm\x22:" as *u8); ab_pn(AB_CONTACT)
  ab_puts(",\x22foot_half_mm\x22:" as *u8); ab_pn(AB_FOOTHALF); ab_puts("}" as *u8)
  ab_puts(",\x22declared_substitutions\x22:\x22penetration and float are measured to the lowest JOINT, not the lowest mesh vertex as the literature specifies, so penetration under-reports and float over-reports by roughly a limb radius; the centre of mass is an unweighted mean of joints, not a mass-weighted sum of segment centroids\x22" as *u8)
  ab_puts(",\x22comparability\x22:\x22the field states plainly that there is NO standardised parameter set for these metrics, so these numbers are comparable only against runs quoting the same thresholds above\x22}\n" as *u8)
  return 0
881}
882
883// ---- fixtures + gate -------------------------------------------------------------------------
884// Fixtures are WRITTEN, not asserted about: a tooth that reads a file the gate authored is a fixture
885// test, and the lane's law is that the decoy must be the thing that actually fools it.
886func ab_wr(path: *u8, b: *u8, n: i64) -> i64 {
  let fd: i64 = sys_openat_wr(path, AB_MODE)
  if fd < 0 { return 0-1 }
  sys_write(fd, b, n)
  sys_close(fd)
  return n
892}
893func ab_app(b: *u8, p: *i64, s: *u8) -> i64 {
  var i: i64 = 0
  while s[i] != (0 as u8) { b[p[0]] = s[i]; p[0] = p[0]+1; i = i+1 }
  return 0
897}
898func ab_appn(b: *u8, p: *i64, v: i64) -> i64 {
  var x: i64 = v
  if x < 0 { b[p[0]]=45 as u8; p[0]=p[0]+1; x=0-x }
  let t: *u8 = sys_mmap(32)
  var k: i64 = 0
  if x == 0 { t[0]=48 as u8; k=1 }
  while x > 0 { t[k]=(48+x%10) as u8; x=x/10; k=k+1 }
  var q: i64 = k-1
  while q >= 0 { b[p[0]]=t[q]; p[0]=p[0]+1; q=q-1 }
  b[p[0]]=32 as u8; p[0]=p[0]+1
  return 0
909}
910func ab_v(b: *u8, p: *i64, f: i64, j: i64, x: i64, y: i64, z: i64) -> i64 {
  ab_app(b,p,"V " as *u8); ab_appn(b,p,f); ab_appn(b,p,j); ab_appn(b,p,x); ab_appn(b,p,y); ab_appn(b,p,z)
  ab_app(b,p,"\n" as *u8)
  return 0
914}
915// A 3-joint leg: joint0 hip, joint1 knee, joint2 foot, built in the SAGITTAL plane (+y up, +z
916// forward) because that is the plane a knee actually flexes in -- the first fixture displaced the
917// knee LATERALLY, which is not a knee motion at all and is half of why T9 was meaningless.
918// `slide` moves the foot horizontally per frame; `sink` drops it below ground; `jitter` alternates
919// the knee height; `kneez` displaces the knee along the sagittal axis:
920//   kneez > 0  knee ANTERIOR to the hip-ankle line = normal flexion (a squat)      -> LEGAL
921//   kneez < 0  knee POSTERIOR to that line = genu recurvatum = HYPEREXTENSION      -> REFUSED by lo=0
922func ab_fixture(path: *u8, nf: i64, slide: i64, sink: i64, kneez: i64, jitter: i64) -> i64 {
  let b: *u8 = sys_mmap(AB_MAGIC_65536)
  let p: *i64 = sys_mmap(16) as *i64
  p[0] = 0
  ab_app(b,p,"A " as *u8); ab_appn(b,p,nf); ab_appn(b,p,3); ab_app(b,p,"\n" as *u8)
  ab_app(b,p,"E 2\n" as *u8)
  // angle site: at the knee (1) between hip (0) and foot (2); limits from bone 9 (the knee's range);
  // flexion axis 0 = x (mediolateral); positive flexion is the NEGATIVE x cross-component, which is
  // what a knee-forward bend produces in this frame.
  ab_app(b,p,"C " as *u8); ab_appn(b,p,1); ab_appn(b,p,0); ab_appn(b,p,2); ab_appn(b,p,9)
  ab_appn(b,p,0); ab_appn(b,p,0-1); ab_app(b,p,"\n" as *u8)
  var f: i64 = 0
  while f < nf {
      var jy: i64 = 0
      if jitter > 0 { if f%2 == 1 { jy = jitter } }
      ab_v(b,p,f,0, 0, 900, 0)
      ab_v(b,p,f,1, 0, 450 + jy, kneez)
      ab_v(b,p,f,2, slide*f, 0 - sink, 0)
      f = f + 1
  }
  return ab_wr(path, b, p[0])
943}
944func ab_gate() -> i64 {
  let ctr: *i64 = gv_ctr()
  gv_head("nx_actbench selftest -- the PHYSSCORE channels, measured not invented" as *u8)
  let t: *i64 = ab_costab()
  // ★T1 THE COSINE TABLE IS A KAT. It is built by recurrence rather than typed, so it must be
  // checked against values that are known exactly, or 180 steps of drift go unnoticed.
  var t1: i64 = 0
  let c0: i64 = t[0]
  let c60: i64 = t[60]
  let c90: i64 = t[90]
  let c180: i64 = t[180]
  if c0 == AB_SCALE { if ab_iabs(c60-512) <= 2 { if ab_iabs(c90) <= 2 { if ab_iabs(c180+AB_SCALE) <= 2 { t1 = 1 } } } }
  gv_check("T1 cosine table KAT: cos0=1024, cos60=512, cos90=0, cos180=-1024" as *u8, t1, ctr)
  // ★T2 acos round-trips through the same table it was built from
  var t2: i64 = 0
  if ab_acos(AB_SCALE, t) == 0 { if ab_iabs(ab_acos(512,t)-60) <= 1 { if ab_iabs(ab_acos(0,t)-90) <= 1 { t2 = 1 } } }
  gv_check("T2 acos recovers the angle it was given" as *u8, t2, ctr)
  // build a skeleton with the REAL generator's row format so the limit channel is exercised as shipped
  let sb: *u8 = sys_mmap(AB_MAGIC_4096)
  let sp: *i64 = sys_mmap(16) as *i64
  sp[0] = 0
  // B <bone> <len> <lo> <hi> -- bone 9 is the knee: 0..140, CANNOT hyperextend (nx_skelgen's table)
  ab_app(sb,sp,"B " as *u8); ab_appn(sb,sp,9); ab_appn(sb,sp,430); ab_appn(sb,sp,0); ab_appn(sb,sp,140)
  ab_app(sb,sp,"\n" as *u8)
  ab_wr("/tmp/nx_ab_skel.dat" as *u8, sb, sp[0])
  let BLO: *i64 = sys_mmap(AB_MAXB*8) as *i64
  let BHI: *i64 = sys_mmap(AB_MAXB*8) as *i64
  let JP: *i64 = sys_mmap(AB_MAXJ*8) as *i64
  var t3: i64 = 0
  if ab_load_skel("/tmp/nx_ab_skel.dat" as *u8, BLO, BHI, JP) == 1 { if BLO[9]==0 { if BHI[9]==140 { t3 = 1 } } }
  gv_check("T3 limits are READ from nx_skelgen's own B rows, not restated here" as *u8, t3, ctr)
  let V: *i64 = sys_mmap(ab_vbytes()) as *i64
  let E: *i64 = sys_mmap(AB_MAXJ*8) as *i64
  let C: *i64 = sys_mmap(AB_MAXC*AB_CST*8) as *i64
  let S: *i64 = sys_mmap(AB_MAXS*AB_SST*8) as *i64
  let cfg: *i64 = sys_mmap(64) as *i64
  let o: *i64 = sys_mmap(64) as *i64
  // ---- PLANTED foot, straight leg, on the ground, no jitter
  ab_fixture("/tmp/nx_ab_plant.tr" as *u8, 8, 0, 0, 0, 0)
  ab_load_trace("/tmp/nx_ab_plant.tr" as *u8, V, E, C, S, cfg)
  ab_skate(V, cfg[0], E, cfg[2], o)
  var t4: i64 = 0
  if o[0] == 0 { t4 = 1 }
  gv_check("T4 a PLANTED foot reads skate 0" as *u8, t4, ctr)
  let plant_skate: i64 = o[0]
  // ---- SLIDING foot: the decoy. This is the one that has to separate.
  ab_fixture("/tmp/nx_ab_slide.tr" as *u8, 8, 12, 0, 0, 0)
  ab_load_trace("/tmp/nx_ab_slide.tr" as *u8, V, E, C, S, cfg)
  ab_skate(V, cfg[0], E, cfg[2], o)
  var t5: i64 = 0
  if o[0] > plant_skate { if o[0] >= 12 { t5 = 1 } }
  gv_check("T5 ANTI-VACUITY: a SLIDING foot reads its slide, strictly above the planted one" as *u8, t5, ctr)
  // ---- penetration pair
  ab_load_trace("/tmp/nx_ab_plant.tr" as *u8, V, E, C, S, cfg)
  ab_gpen(V, cfg[0], cfg[1], o)
  var t6: i64 = 0
  if o[0] == 0 { if o[2] == 0 { t6 = 1 } }
  gv_check("T6 a foot ON the ground reports NO penetration" as *u8, t6, ctr)
  ab_fixture("/tmp/nx_ab_sink.tr" as *u8, 8, 0, 50, 0, 0)
  ab_load_trace("/tmp/nx_ab_sink.tr" as *u8, V, E, C, S, cfg)
  ab_gpen(V, cfg[0], cfg[1], o)
  var t7: i64 = 0
  if o[1] >= 40 { if o[2] == 8 { t7 = 1 } }
  gv_check("T7 a foot 50mm BELOW the ground reports it, on every frame" as *u8, t7, ctr)
  // ---- ★★THE JOINT-LIMIT PAIR. nx_skelgen's own law: a tooth that only proves refusal is worthless,
  // because "refuse everything" passes it. Both directions or neither.
  // knee x-offset 0 => hip, knee and foot colinear => interior 180 => flexion 0 => LEGAL (lo=0).
  ab_load_trace("/tmp/nx_ab_plant.tr" as *u8, V, E, C, S, cfg)
  ab_jlimit(V, cfg[0], C, cfg[3], BLO, BHI, t, o)
  var t8: i64 = 0
  if o[0] == 0 { if o[2] > 0 { t8 = 1 } }
  gv_check("T8 a STRAIGHT leg is legal, and the channel actually sampled it" as *u8, t8, ctr)
  // ★T9a a NORMAL bend (knee anterior = a squat) must stay LEGAL. Without this tooth an
  // implementation that flags every bent knee passes T9b, which is the "refuse everything" hole
  // nx_skelgen's own gate documents.
  ab_fixture("/tmp/nx_ab_flex.tr" as *u8, 8, 0, 0, 260, 0)
  ab_load_trace("/tmp/nx_ab_flex.tr" as *u8, V, E, C, S, cfg)
  ab_jlimit(V, cfg[0], C, cfg[3], BLO, BHI, t, o)
  var t9a: i64 = 0
  if o[0] == 0 { if o[2] > 0 { t9a = 1 } }
  gv_check("T9a a NORMAL knee bend (anterior, a squat) stays legal" as *u8, t9a, ctr)
  // ★★T9b THE REFUTATION, and the tooth that convicted the unsigned first implementation: the knee
  // POSTERIOR to the hip-ankle line is genu recurvatum. Its INTERIOR angle is identical to T9a's, so
  // only a SIGNED flexion can tell them apart -- if this passes while T9a also passes, the sign works.
  ab_fixture("/tmp/nx_ab_hyper.tr" as *u8, 8, 0, 0, 0-260, 0)
  ab_load_trace("/tmp/nx_ab_hyper.tr" as *u8, V, E, C, S, cfg)
  ab_jlimit(V, cfg[0], C, cfg[3], BLO, BHI, t, o)
  var t9: i64 = 0
  if o[0] > 0 { if o[1] > 0 { t9 = 1 } }
  gv_check("T9b REFUTATION: a HYPEREXTENDED knee is caught -- same interior angle as T9a, opposite sign" as *u8, t9, ctr)
  // ---- smoothness pair
  ab_load_trace("/tmp/nx_ab_plant.tr" as *u8, V, E, C, S, cfg)
  ab_smooth(V, cfg[0], cfg[1], o)
  let smooth_still: i64 = o[0]
  ab_fixture("/tmp/nx_ab_jit.tr" as *u8, 8, 0, 0, 0, 30)
  ab_load_trace("/tmp/nx_ab_jit.tr" as *u8, V, E, C, S, cfg)
  ab_smooth(V, cfg[0], cfg[1], o)
  var t10: i64 = 0
  if smooth_still == 0 { if o[0] > 0 { t10 = 1 } }
  gv_check("T10 jitter SEPARATES: a still trace reads 0 jerk, an alternating one reads more" as *u8, t10, ctr)
  // ---- CoM pair. Standing over the foot is supported; the same body with the foot far to the side
  // puts the centre of mass outside the support and must be flagged.
  ab_load_trace("/tmp/nx_ab_plant.tr" as *u8, V, E, C, S, cfg)
  ab_com(V, cfg[0], cfg[1], E, cfg[2], o)
  var t11: i64 = 0
  if o[0] == 0 { if o[2] == 8 { t11 = 1 } }
  gv_check("T11 a body standing OVER its foot is stable, on supported frames it counted" as *u8, t11, ctr)
  // ★★★T11b THE TOOTH THE HULL BUG WALKED THROUGH. Four contacts -- two feet, each with heel and toe
  // -- and a centre of mass in the middle of them. The old code took the first TWO contacts, so the
  // support was one foot and a correctly standing body measured as falling sideways. A hull of all
  // four contains the CoM, so the honest answer is stable. Built as a FIXTURE, not an assertion.
  let qb: *u8 = sys_mmap(AB_MAGIC_4096)
  let qp: *i64 = sys_mmap(16) as *i64
  qp[0] = 0
  ab_app(qb,qp,"A 4 5\n" as *u8)
  ab_app(qb,qp,"E 1\nE 2\nE 3\nE 4\n" as *u8)
  var qf: i64 = 0
  while qf < 4 {
      ab_v(qb,qp,qf,0, 0, 900, 0)        // body mass, centred between the feet
      ab_v(qb,qp,qf,1, 84, 0, 200)       // right toe
      ab_v(qb,qp,qf,2, 84, 0, 0-67)      // right heel
      ab_v(qb,qp,qf,3, 0-84, 0, 200)     // left toe
      ab_v(qb,qp,qf,4, 0-84, 0, 0-67)    // left heel
      qf = qf + 1
  }
  ab_wr("/tmp/nx_ab_stance.tr" as *u8, qb, qp[0])
  ab_load_trace("/tmp/nx_ab_stance.tr" as *u8, V, E, C, S, cfg)
  ab_com(V, cfg[0], cfg[1], E, cfg[2], o)
  var t11b: i64 = 0
  if o[0] == 0 { if o[2] == 4 { t11b = 1 } }
  gv_check("T11b a TWO-FOOTED stance with four contacts is stable -- the hull, not the first two" as *u8, t11b, ctr)
  ab_fixture("/tmp/nx_ab_tip.tr" as *u8, 8, 0, 0, 900, 0)
  ab_load_trace("/tmp/nx_ab_tip.tr" as *u8, V, E, C, S, cfg)
  ab_com(V, cfg[0], cfg[1], E, cfg[2], o)
  var t12: i64 = 0
  if o[0] > 0 { if o[1] > 0 { t12 = 1 } }
  gv_check("T12 REFUTATION: a centre of mass outside the support polygon is flagged" as *u8, t12, ctr)
  // ---- ★T13 the capacity refusal. The plan's S0 rung exists because this program has shipped three
  // emitters that silently stopped at a cap. A trace claiming more frames than we can hold must be
  // REFUSED with its own code, never quietly clipped to something that still scores.
  let ob: *u8 = sys_mmap(256)
  let op: *i64 = sys_mmap(16) as *i64
  op[0] = 0
  ab_app(ob,op,"A " as *u8); ab_appn(ob,op,AB_MAXF+1); ab_appn(ob,op,3); ab_app(ob,op,"\n" as *u8)
  ab_wr("/tmp/nx_ab_over.tr" as *u8, ob, op[0])
  var t13: i64 = 0
  if ab_load_trace("/tmp/nx_ab_over.tr" as *u8, V, E, C, S, cfg) == AB_E_CAP { t13 = 1 }
  gv_check("T13 a trace beyond declared capacity is REFUSED, not truncated" as *u8, t13, ctr)
  var t14: i64 = 0
  if ab_load_trace("/tmp/nx_ab_missing.tr" as *u8, V, E, C, S, cfg) == AB_E_OPEN { t14 = 1 }
  gv_check("T14 a missing trace fails loud with its own exit code" as *u8, t14, ctr)
  // ---- ★T15 DETERMINISM: the same trace scored twice gives the same numbers, and the check is not
  // vacuous because T5/T7/T9/T12 already proved the numbers move when the input does.
  ab_load_trace("/tmp/nx_ab_slide.tr" as *u8, V, E, C, S, cfg)
  let d1: *i64 = sys_mmap(64) as *i64
  let d2: *i64 = sys_mmap(64) as *i64
  ab_skate(V, cfg[0], E, cfg[2], d1)
  ab_skate(V, cfg[0], E, cfg[2], d2)
  var t15: i64 = 0
  if d1[0]==d2[0] { if d1[1]==d2[1] { if d1[2]==d2[2] { t15 = 1 } } }
  gv_check("T15 deterministic: the same trace scores identically twice" as *u8, t15, ctr)
  // ---- ★CHANNEL 6. Four joints forming two parallel bars a declared distance apart, with capsule
  // radii chosen so the pair is clear in one fixture and overlapping in the other. `gap` is the
  // separation; radii sum to 100, so gap 300 is clear and gap 40 is 60mm of interpenetration.
  let pb: *u8 = sys_mmap(AB_MAGIC_4096)
  let pp: *i64 = sys_mmap(16) as *i64
  var gapv: i64 = 300
  var round: i64 = 0
  var clear_v: i64 = 0-1
  var over_v: i64 = 0-1
  var over_worst: i64 = 0
  var adjacent_flagged: i64 = 1
  while round < 2 {
      if round == 1 { gapv = 40 }
      pp[0] = 0
      ab_app(pb,pp,"A 2 4\n" as *u8)
      // bar A: joints 0-1. bar B: joints 2-3, offset sideways by gapv.
      ab_app(pb,pp,"S 0 1 50\n" as *u8)
      ab_app(pb,pp,"S 2 3 50\n" as *u8)
      var ff: i64 = 0
      while ff < 2 {
          ab_v(pb,pp,ff,0, 0, 500, 0-200)
          ab_v(pb,pp,ff,1, 0, 500, 200)
          ab_v(pb,pp,ff,2, gapv, 500, 0-200)
          ab_v(pb,pp,ff,3, gapv, 500, 200)
          ff = ff + 1
      }
      ab_wr("/tmp/nx_ab_sp.tr" as *u8, pb, pp[0])
      ab_load_trace("/tmp/nx_ab_sp.tr" as *u8, V, E, C, S, cfg)
      let o8: *i64 = sys_mmap(64) as *i64
      ab_selfpen(V, cfg[0], S, cfg[4], JP, o8)
      if round == 0 { clear_v = o8[2] }
      if round == 1 { over_v = o8[2]; over_worst = o8[1] }
      round = round + 1
  }
  var t16: i64 = 0
  if clear_v == 0 { t16 = 1 }
  gv_check("T16 two limbs 300mm apart do NOT self-penetrate" as *u8, t16, ctr)
  var t17: i64 = 0
  if over_v > 0 { if over_worst >= 55 { t17 = 1 } }
  gv_check("T17 REFUTATION: overlapping limbs are caught, with the depth they overlap by" as *u8, t17, ctr)
  // ★★T18 THE TOOTH THAT STOPS EVERY BODY SCORING AS BROKEN. Two capsules SHARING a joint meet there
  // by construction -- a forearm touches an upper arm at the elbow. If adjacency were not derived,
  // this fixture (two bars hinged at a shared joint, radii overlapping at the hinge) would be
  // flagged and every articulated body would read as self-penetrating.
  pp[0] = 0
  ab_app(pb,pp,"A 2 3\n" as *u8)
  ab_app(pb,pp,"S 0 1 50\n" as *u8)
  ab_app(pb,pp,"S 1 2 50\n" as *u8)
  var gf: i64 = 0
  while gf < 2 {
      ab_v(pb,pp,gf,0, 0, 900, 0)
      ab_v(pb,pp,gf,1, 0, 500, 0)
      ab_v(pb,pp,gf,2, 0, 100, 0)
      gf = gf + 1
  }
  ab_wr("/tmp/nx_ab_adj.tr" as *u8, pb, pp[0])
  ab_load_trace("/tmp/nx_ab_adj.tr" as *u8, V, E, C, S, cfg)
  let o9: *i64 = sys_mmap(64) as *i64
  ab_selfpen(V, cfg[0], S, cfg[4], JP, o9)
  if o9[3] == 0 { adjacent_flagged = 0 }
  var t18: i64 = 0
  if o9[2] == 0 { if adjacent_flagged == 0 { t18 = 1 } }
  gv_check("T18 limbs SHARING a joint are excluded by DERIVED adjacency, not counted as penetrating" as *u8, t18, ctr)
  // ★★★T18b THE TOOTH FOR THE ADJACENCY FIX. A thigh and a torso share NO joint index, but the
  // thigh's proximal joint is the torso's CHILD -- a femoral head inside a pelvis. On the real
  // skeleton the endpoint-only test false-positived this at 111mm. Adjacency must read the parent
  // chain, and the fixture supplies J rows saying joint 9's parent is joint 0.
  sp[0] = 0
  ab_app(sb,sp,"B " as *u8); ab_appn(sb,sp,9); ab_appn(sb,sp,430); ab_appn(sb,sp,0); ab_appn(sb,sp,140)
  ab_app(sb,sp,"\n" as *u8)
  ab_app(sb,sp,"J 0 -1 0 0 0 0\n" as *u8)
  ab_app(sb,sp,"J 2 1 0 0 0 0\n" as *u8)
  ab_app(sb,sp,"J 9 0 1 0 0 0\n" as *u8)
  ab_app(sb,sp,"J 10 9 1 0 0 0\n" as *u8)
  ab_wr("/tmp/nx_ab_skel2.dat" as *u8, sb, sp[0])
  ab_load_skel("/tmp/nx_ab_skel2.dat" as *u8, BLO, BHI, JP)
  pp[0] = 0
  ab_app(pb,pp,"A 2 11\n" as *u8)
  ab_app(pb,pp,"S 0 2 140\n" as *u8)
  ab_app(pb,pp,"S 9 10 55\n" as *u8)
  var hf: i64 = 0
  while hf < 2 {
      ab_v(pb,pp,hf,0,  0, 928, 0)      // pelvis
      ab_v(pb,pp,hf,2,  0, AB_MAGIC_1523, 0)     // cervicale
      ab_v(pb,pp,hf,9,  84, 928, 0)     // hip -- 84mm out, well inside 140+55
      ab_v(pb,pp,hf,10, 84, 499, 0)     // knee
      hf = hf + 1
  }
  ab_wr("/tmp/nx_ab_par.tr" as *u8, pb, pp[0])
  ab_load_trace("/tmp/nx_ab_par.tr" as *u8, V, E, C, S, cfg)
  let o10: *i64 = sys_mmap(64) as *i64
  ab_selfpen(V, cfg[0], S, cfg[4], JP, o10)
  var t18b: i64 = 0
  if o10[2] == 0 { if o10[3] == 0 { t18b = 1 } }
  gv_check("T18b a thigh inside a pelvis is adjacency via the PARENT CHAIN, not self-penetration" as *u8, t18b, ctr)
  // ★T18c and the fix must not have blunted the instrument: with the SAME geometry but no parent
  // link declared, the overlap is still reported. Without this, "adjacency" could swallow everything.
  var zz: i64 = 0
  while zz < AB_MAXJ { JP[zz] = 0-1; zz = zz + 1 }
  ab_selfpen(V, cfg[0], S, cfg[4], JP, o10)
  var t18c: i64 = 0
  if o10[2] > 0 { if o10[3] > 0 { t18c = 1 } }
  gv_check("T18c REFUTATION: strip the parent link and the SAME overlap is reported again" as *u8, t18c, ctr)
  return gv_verdict("ACTBENCH-GATE" as *u8, ctr,
      "all 6 published PHYSSCORE channels, each with a separating pair; radii and adjacency are data and derivation, never constants in this file" as *u8)
1210}
1211
1212func main(argc: i64, argv: *i64) -> i64 {
  if argc >= 2 {
      if ab_streq(argv[1] as *u8, "selftest" as *u8) == 1 { return ab_gate() }
      if ab_streq(argv[1] as *u8, "score" as *u8) == 1 {
          if argc < 4 { ab_puts("usage: nx_actbench score <trace> <skel.dat>\n" as *u8); return 2 }
          return ab_score(argv[2] as *u8, argv[3] as *u8)
      }
  }
  ab_puts("usage: nx_actbench score <trace> <skel.dat> | selftest\n" as *u8)
  return 2
1222}
nx_actbench.nx source

`nx_actbench.nx` source
