code wiki / _hdl_build / nx_profile_fit_output_t320.nx
`nx_profile_fit_output_t320.nx` source

↩ module page · 847 lines · 44504 B
1// nx_profile_fit.nx -- ★MEASURED CROSS-SECTION PROFILES FROM A REAL ANATOMICAL REFERENCE.
2// This is the Infinigen method, done sovereignly: their creature lofting threads NURBS surfaces through
3// profile sections taken from REAL references (nurbs_data). Ours threaded ELLIPSES -- and a human cross
4// section is not an ellipse (flat back, spinal furrow, sternal hollow, deltoid shelf, iliac flare). This
5// organ SLICES an oracle mesh at every station height, clusters each slice into torso / arm / leg / head,
6// fits the section's bounding ellipse, and emits the DIMENSIONLESS deviation of the real outline from that
7// ellipse as a per-angle ratio.
8//
9// ★WHAT IS AND IS NOT TAKEN FROM THE ORACLE: only the SHAPE PRIOR (a per-mille ratio per angle, 1000 = on
10// the ellipse). Every SIZE stays procedural -- the generator still decides stature, breadth, build and
11// dimorphism. So this cannot become "ship the scanned body": it is a measured shape rule the emitter applies
12// to whatever body the rule engine asks for, exactly as Infinigen applies profiles from refs to a genome.
13// Oracle provenance/licence is written into the emitted file header by the caller's manifest.
14//
15//   nx_profile_fit <oracle.nxmesh> <out.dat> [step_permil] [canon_out.dat] [part_id]
16// ORGAN MODE: supply part_id and the oracle is declared to BE that single part -- no band gate, no limb
17// clustering. Absent it, the body path is unchanged.
18// license_tier: ORIGINAL  expect_exit: 0
19import "nx_syscalls.nx"
20import "nx_buf_dyn.nx"
21import "nx_itoa_lib.nx"
22import "nx_atomic_rewrite.nx"
23
24const PF_Q14: i64 = 16384
25const PF_BIG: i64 = 2000000000
26const PF_M8388607: i64 = 8388607
27const PF_M8388608: i64 = 8388608
28const PF_POSQ0: i64 = 4096
29const PF_TARGET: i64 = 200000
30const PF_MAGIC_40500: i64 = 40500
31// ★ANGULAR RESOLUTION OF THE PRIOR. 24 bins (15 deg) proved too coarse to be worth anything: it smoothed
32// the back instead of carrying the scapular ridges, and measured WORSE than no prior. The prior can only
33// carry structure the emitter's ring can represent, so keep bins <= the emitter's radial segment count.
34const PF_NB: i64 = 48
35const PF_MAXST: i64 = 256          // station slices
36const PF_MAXPT: i64 = 4096         // section points held per station
37const PF_XBINS: i64 = 128          // x-histogram bins used to separate torso from limbs
38const PF_GAP: i64 = 2              // empty x-bins that separate two clusters
39const PF_MAXRUN: i64 = 8
40const PF_MAXPARTS: i64 = 8
41const PF_MAXK: i64 = 12            // control rings kept per part after factorisation
42// Output storage is owned and grows through nx_bo_append; allocation failure is reported.
43// part indices must match the canon: 0 torso, 1 arm, 2 leg, 4 head
44const PF_PTORSO: i64 = 0
45const PF_PARM: i64 = 1
46const PF_PLEG: i64 = 2
47const PF_PHEAD: i64 = 4
48// anatomical band limits, per-mille of stature (canon ring extents, not tuned constants)
49const PF_TORSO_LO: i64 = 430
50const PF_TORSO_HI: i64 = 908
51// ★BAND FLOORS ARE ANATOMY, NOT TUNING: below the wrist the outer cluster is the HAND and below the ankle
52// it is the FOOT (a forward-running part in the canon, so its section is not the leg tube's section).
53// Profiling those heights would feed hand/foot outlines into the arm/leg tubes.
54const PF_ARM_LO: i64 = 470
55const PF_ARM_HI: i64 = 838
56const PF_LEG_LO: i64 = 60
57const PF_LEG_HI: i64 = 452
58const PF_HEAD_LO: i64 = 852
59
60func pf_hw(s: *u8) -> i64 { var n: i64 = 0; while s[n] != (0 as u8) { n = n+1 } sys_write(1, s, n); return 0 }
61func pf_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
69}
70func pf_satoi(s: *u8) -> i64 {
  var i: i64 = 0; var n: i64 = 0
  while s[i] != (0 as u8) { let c: i64 = s[i] as i64; if c >= 48 { if c <= 57 { n = n*10 + (c-48) } } i = i+1 }
  return n
74}
75func pf_rdbits(b: *u8, o: i64) -> i64 {
  return (b[o] as i64) | ((b[o+1] as i64)<<8) | ((b[o+2] as i64)<<16) | ((b[o+3] as i64)<<24)
77}
78func pf_f32mul(b: *u8, o: i64, mul: i64) -> i64 {
  let bits: i64 = pf_rdbits(b, o)
  let sign: i64 = (bits>>31) & 1
  let exp: i64 = (bits>>23) & 255
  let mant: i64 = bits & PF_M8388607
  if exp == 0 { return 0 }
  let m: i64 = (mant | PF_M8388608) * mul
  var e: i64 = exp - 127 - 23
  var v: i64 = 0
  if e >= 0 { v = m << e } else { let sh: i64 = 0-e; v = (m + (1 << (sh-1))) >> sh }
  if sign == 1 { v = 0-v }
  return v
90}
91func pf_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 }
92func pf_wrap(d: i64) -> i64 { var x: i64 = d % 360; if x < 0 { x = x + 360 } return x }
93// Bhaskara-I degree sine in Q14 -- our own integer trig, exact at 0/30/90/150/180
94func pf_sin_fill(t: *i64) -> i64 {
  var d: i64 = 0
  while d < 180 { let P: i64 = d*(180-d); t[d] = PF_Q14*4*P/(PF_MAGIC_40500-P); t[d+180] = 0-t[d]; d = d+1 }
  return 0
98}
99// Output adapters retain the fitter record grammar while the shared owner grows storage.
100// pos = [published-length, sticky append error, reusable integer scratch pointer].
101func pf_output_new(pos: *i64) -> *NxBufOwned {
  let out: *NxBufOwned = sys_mmap(NX_BO_BYTES) as *NxBufOwned
  out.buf = 0 as *u8; out.len = 0; out.cap = 0
  pos[0] = 0; pos[1] = 0; pos[2] = sys_mmap(NXI_BUF) as i64
  return out
106}
107func pf_putint(buf: *NxBufOwned, pos: *i64, v: i64, sep: i64) -> i64 {
  if pos[1] < 0 { return pos[1] }
  let tmp: *u8 = pos[2] as *u8
  let n: i64 = nxi_buf(tmp, 0, v)
  tmp[n] = sep as u8
  let rc: i64 = nx_bo_append(buf, tmp, n+1, 0)
  if rc < 0 { pos[1] = rc; return rc }
  pos[0] = buf.len
  return 0
116}
117func pf_puts(buf: *NxBufOwned, pos: *i64, s: *u8) -> i64 {
  if pos[1] < 0 { return pos[1] }
  var n: i64 = 0
  while s[n] != (0 as u8) { n = n+1 }
  let rc: i64 = nx_bo_append(buf, s, n, 0)
  if rc < 0 { pos[1] = rc; return rc }
  pos[0] = buf.len
  return 0
125}
126// The checked shared writer acknowledges the complete file or returns a named failure.
127// Caller serializes writers for each destination; two output files are separate commits.
128func pf_output_commit(buf: *NxBufOwned, pos: *i64, path: *u8) -> i64 {
  var rc: i64 = pos[1]
  if rc == 0 { rc = atomic_rewrite_checked(path, buf.buf, buf.len) }
  let released: i64 = nx_bo_release(buf)
  sys_munmap(pos[2] as *u8, NXI_BUF)
  if rc == 0 { if released < 0 { rc = released } }
  return rc
135}
136
137// ============================ SECTION FIT ============================
138// Fit one clustered slice: bounding ellipse (centre + semi-axes from the section's own extent), then the
139// per-angle support radius measured along the ELLIPSE PARAMETER directions the emitter actually uses --
140// the emitter places a vertex at (ra*cos t, rb*sin t), so the ratio must be measured along that same ray or
141// it would not compose with the emitter's parameterisation.
142// Writes ra,rb into fit[0..1] and PF_NB ratios into rat[]; returns 1 on success, 0 if the section is degenerate.
143// ★NB IS A RUNTIME PARAMETER, NOT A COMPILE-TIME CEILING (2026-08-23). PF_NB=48 was a PICKED constant
144// and it was THE high-frequency detail ceiling of the entire human generator: the oracle holds up to
145// PF_MAXPT=4096 points per section, the consumer (nx_body_gen BG_NBMAX) can hold 96 bins, and we were
146// binning to 48 and discarding the rest of the measured resolution. Measured consequence: with HF on,
147// mesh radial 24 UNDER-samples the 48-bin prior, radial 48 matches it (best head detail 208), and
148// radial 96 OVERSAMPLES a band-limited signal -- shape DEGRADES 923->900 because Catmull-Rom through
149// the same 48 bins invents form between them. So detail was never bounded by triangles; it was bounded
150// by how finely we measured. Threading nb makes that bound DATA-DERIVED and liftable.
151// ⚠Default stays PF_NB so every existing caller is BYTE-IDENTICAL by construction -- the neutrality
152// proof is `same args -> same output`, not an assertion.
153func pf_fit_section(px: *i64, pz: *i64, idx: *i64, cnt: i64, sinT: *i64, fit: *i64, rat: *i64, nb: i64) -> i64 {
  if cnt < nb { return 0 }
  var xmn: i64 = PF_BIG; var xmx: i64 = 0-PF_BIG; var zmn: i64 = PF_BIG; var zmx: i64 = 0-PF_BIG
  var k: i64 = 0
  while k < cnt {
      let j: i64 = idx[k]
      let x: i64 = px[j]; let z: i64 = pz[j]
      if x < xmn { xmn = x }
      if x > xmx { xmx = x }
      if z < zmn { zmn = z }
      if z > zmx { zmx = z }
      k = k+1
  }
  let xc: i64 = (xmn+xmx)/2; let zc: i64 = (zmn+zmx)/2
  var ra: i64 = (xmx-xmn)/2; var rb: i64 = (zmx-zmn)/2
  if ra < 1 { return 0 }
  if rb < 1 { return 0 }
  fit[0] = ra; fit[1] = rb; fit[2] = xc; fit[3] = zc
  // ellipse-parameter directions, unit (Q14) plus their true length
  let ux: *i64 = sys_mmap(nb*8) as *i64
  let uz: *i64 = sys_mmap(nb*8) as *i64
  let ul: *i64 = sys_mmap(nb*8) as *i64
  let best: *i64 = sys_mmap(nb*8) as *i64
  var i: i64 = 0
  while i < nb {
      let dg: i64 = pf_wrap(i*360/nb)
      let dx: i64 = ra*sinT[pf_wrap(dg+90)]/PF_Q14
      let dz: i64 = rb*sinT[dg]/PF_Q14
      var l: i64 = pf_isqrt(dx*dx + dz*dz)
      if l < 1 { l = 1 }
      ux[i] = dx*PF_Q14/l; uz[i] = dz*PF_Q14/l; ul[i] = l
      best[i] = 0-PF_BIG
      i = i+1
  }
  // ★MEAN RADIUS PER BIN, NOT THE MAXIMUM. Taking the max projection in each direction is the section's
  // SUPPORT FUNCTION, and a support function describes the CONVEX HULL -- every concavity (the spinal
  // furrow, the groove between the erector columns, the armpit, the popliteal hollow) is erased by
  // construction. Measured consequence: the convexified prior transferred fine on the mostly-convex FRONT
  // (detail 348->372) and wrecked the BACK (374->281), because it flattened our back without carrying the
  // structure that makes a real back busy. Averaging the points that fall in a bin keeps concavities.
  let bsum: *i64 = sys_mmap(nb*8) as *i64
  let bcnt: *i64 = sys_mmap(nb*8) as *i64
  i = 0
  while i < nb { bsum[i] = 0; bcnt[i] = 0; i = i+1 }
  k = 0
  while k < cnt {
      let j: i64 = idx[k]
      let vx: i64 = px[j]-xc; let vz: i64 = pz[j]-zc
      var bi: i64 = 0; var bd: i64 = 0-PF_BIG
      i = 0
      while i < nb {
          let d: i64 = (vx*ux[i] + vz*uz[i])/PF_Q14
          if d > bd { bd = d; bi = i }
          i = i+1
      }
      bsum[bi] = bsum[bi] + bd; bcnt[bi] = bcnt[bi] + 1
      if bd > best[bi] { best[bi] = bd }
      k = k+1
  }
  // dimensionless ratio vs the fitted ellipse; empty bins filled from the nearest occupied neighbour
  i = 0
  while i < nb {
      if bcnt[i] < 1 { rat[i] = 0 } else { rat[i] = (bsum[i]/bcnt[i])*1000/ul[i] }
      i = i+1
  }
  var filled: i64 = 0
  i = 0
  while i < nb { if rat[i] > 0 { filled = filled+1 } i = i+1 }
  if filled < nb/2 { return 0 }
  var pass: i64 = 0
  while pass < nb {
      i = 0
      while i < nb {
          if rat[i] == 0 {
              let a: i64 = rat[(i+1)%nb]
              let b: i64 = rat[(i+nb-1)%nb]
              if a > 0 { if b > 0 { rat[i] = (a+b)/2 } else { rat[i] = a } } else { if b > 0 { rat[i] = b } }
          }
          i = i+1
      }
      pass = pass+1
  }
  return 1
236}
237
238// ★SAGITTAL SYMMETRISATION for the midline parts (torso, head). A cadaver is not perfectly symmetric and a
239// slice picks up scan noise; a GENERATED body is mirrored about x=0, so an asymmetric prior would apply one
240// side's noise to both. Averaging theta with 180-theta keeps the anatomy (flat back, sternal hollow) and
241// cancels the asymmetry we could not honestly reproduce anyway. Limb profiles are left as measured: their
242// asymmetry (medial vs lateral) is real and the emitter flips the angle for the mirrored side.
243func pf_symmetrize(rat: *i64, nb: i64) -> i64 {
  let tmp: *i64 = sys_mmap(nb*8) as *i64
  var i: i64 = 0
  while i < nb { tmp[i] = rat[i]; i = i+1 }
  i = 0
  while i < nb {
      let m: i64 = (nb/2 - i + nb) % nb
      rat[i] = (tmp[i] + tmp[m])/2
      i = i+1
  }
  return 0
254}
255
256
257// ★FACTORISE MEASURED STATIONS INTO CONTROL HANDLES -- the Infinigen step we had been skipping. Their part
258// templates carry handles factorised from real reference data; ours were TYPED. Given every measured station
259// of a part, choose the K stations that reconstruct the whole run best: start from the two ends and greedily
260// insert whichever station deviates most from the straight line between its selected neighbours.
261// ★THE POINT: ring density then follows WHERE THE SHAPE CHANGES, instead of being uniform. GX-34 proved a
262// uniform-linear generator scores WORSE than the typed table precisely because the table encoded dense rings
263// at the shoulder and sparse ones down the forearm. Here that density is measured, not authored.
264func pf_factorise(cY: *i64, cRA: *i64, cRB: *i64, cXC: *i64, cZC: *i64, base: i64, n: i64, K: i64, sel: *i64) -> i64 {
  var i: i64 = 0
  while i < n { sel[i] = 0; i = i+1 }
  if n < 2 { if n == 1 { sel[0] = 1 } return n }
  sel[0] = 1; sel[n-1] = 1
  var have: i64 = 2
  while have < K {
      var bi: i64 = 0-1
      var be: i64 = 0-1
      var a: i64 = 0
      while a < n-1 {
          if sel[a] == 1 {
              var b: i64 = a+1
              var go: i64 = 1
              while go == 1 { if b >= n-1 { go = 0 } else { if sel[b] == 1 { go = 0 } else { b = b+1 } } }
              // every unselected station between the selected pair (a,b): error vs the linear reconstruction
              var m: i64 = a+1
              while m < b {
                  var w: i64 = 0
                  if cY[base+b] != cY[base+a] { w = (cY[base+m]-cY[base+a])*1000/(cY[base+b]-cY[base+a]) }
                  var e: i64 = 0
                  var d1: i64 = cRA[base+m] - (cRA[base+a] + (cRA[base+b]-cRA[base+a])*w/1000)
                  if d1 < 0 { d1 = 0-d1 }
                  var d2: i64 = cRB[base+m] - (cRB[base+a] + (cRB[base+b]-cRB[base+a])*w/1000)
                  if d2 < 0 { d2 = 0-d2 }
                  var d3: i64 = cXC[base+m] - (cXC[base+a] + (cXC[base+b]-cXC[base+a])*w/1000)
                  if d3 < 0 { d3 = 0-d3 }
                  var d4: i64 = cZC[base+m] - (cZC[base+a] + (cZC[base+b]-cZC[base+a])*w/1000)
                  if d4 < 0 { d4 = 0-d4 }
                  e = d1+d2+d3+d4
                  if e > be { be = e; bi = m }
                  m = m+1
              }
              a = b
          } else { a = a+1 }
      }
      if bi < 0 { have = K } else { sel[bi] = 1; have = have+1 }
  }
  return have
303}
304// emit one factorised part as canon P/R rows. Midline parts force xoff 0 (a generated body is bilaterally
305// symmetric; the cadaver's own asymmetry is not something we could honestly reproduce anyway).
306func pf_emit_part(buf: *NxBufOwned, pos: *i64, cY: *i64, cRA: *i64, cRB: *i64, cXC: *i64, cZC: *i64,
                base: i64, n: i64, sel: *i64, mir: i64, mat: i64, zref: i64) -> i64 {
  pf_puts(buf, pos, "P " as *u8)
  pf_putint(buf, pos, mir, 32); pf_putint(buf, pos, 0, 32); pf_putint(buf, pos, 0, 32)
  pf_putint(buf, pos, 0, 32);   pf_putint(buf, pos, 0, 32); pf_putint(buf, pos, mat, 10)
  var i: i64 = 0
  while i < n {
      if sel[i] == 1 {
          var xo: i64 = cXC[base+i]
          if mir == 0 { xo = 0 }
          pf_puts(buf, pos, "R " as *u8)
          pf_putint(buf, pos, cY[base+i], 32)
          pf_putint(buf, pos, xo, 32)
          // ★z is measured ABSOLUTE to the oracle's own origin, so every part came out fitted at its own
          // depth and the parts stopped agreeing with each other -- measured as the side silhouette
          // collapsing 813 -> 678 while the front hit its best ever 886. One global reference subtracted
          // keeps the RELATIVE depths (arms behind the chest plane is real anatomy) and removes the shift.
          pf_putint(buf, pos, cZC[base+i]-zref, 32)
          pf_putint(buf, pos, cRA[base+i], 32)
          pf_putint(buf, pos, cRB[base+i], 10)
      }
      i = i+1
  }
  return 0
330}
331
332// ANATOMICAL LANDMARKS -- the registration primitive. kind 1 = height of MAX radius in the band, 0 = MIN.
333func pf_landmark(cY: *i64, cR: *i64, base: i64, n: i64, lo: i64, hi: i64, kind: i64) -> i64 {
  var bi: i64 = 0-1
  var bv: i64 = 0
  var i: i64 = 0
  while i < n {
      let y: i64 = cY[base+i]
      if y >= lo { if y <= hi {
          let v: i64 = cR[base+i]
          if bi < 0 { bi = i; bv = v } else {
              if kind == 1 { if v > bv { bv = v; bi = i } } else { if v < bv { bv = v; bi = i } }
          }
      }}
      i = i+1
  }
  if bi < 0 { return 0 }
  return cY[base+bi]
349}
350
351func pf_output_run(argc: i64, argv: *i64) -> i64 {
  if argc < 3 { pf_hw("{\x22error\x22:\x22usage: nx_profile_fit <oracle.nxmesh> <out.dat> [step_permil]\x22}\n" as *u8); return 2 }
  let orap: *u8 = argv[1] as *u8
  // Source paths are emitted inside comment rows; reject controls before any file read or output.
  var sourceByte: i64 = 0
  while orap[sourceByte] != (0 as u8) {
      let ch: i64 = orap[sourceByte] as i64
      if ch < 32 { pf_hw("source path contains control bytes\n" as *u8); return 2 }
      if ch == 127 { pf_hw("source path contains control bytes\n" as *u8); return 2 }
      sourceByte = sourceByte + 1
  }
  let outp: *u8 = argv[2] as *u8
  var STEP: i64 = 6
  if argc > 3 { STEP = pf_satoi(argv[3] as *u8) }
  if STEP < 2 { STEP = 2 }
  // ★ORGAN MODE (argv[5]). The band table is BODY anatomy expressed in per-mille of the oracle's OWN AABB
  // height, so aiming this organ at a SINGLE-ORGAN oracle silently misclassifies it: for a skull the
  // mandible and maxilla fall in the LEG band, the midface in TORSO, and only the top 148 permil reads as
  // HEAD. Worse, the two-fused-legs recovery fires whenever nrun==1 inside the leg band and SAWS THE SKULL
  // DOWN ITS MIDLINE to fit the +x half as a limb. That is measured, not feared: debt 1785438981 records
  // that the 156 rows in profile_human.dat are body sections, and feeding them to a skull lifted the front
  // (+5 headline) while DEGRADING side_iou 559->531 and quarter_iou 665->627 -- right mechanism, wrong data.
  // Declaring the part makes every station belong to it. ORGANON==0 leaves the body path byte-identical.
  var ORGAN: i64 = 0-1
  var ORGANON: i64 = 0
  // ★ORGANON KEYED ON THE VALUE, NOT ON argc (2026-08-23). It was `if argc > 5 { ORGANON = 1; ... }`,
  // so ANY later positional argument -- PIDHI at argv[8], and the new NB at argv[9] -- SILENTLY forced
  // single-organ mode: every station collapsed into one part, limb detection was disabled, and the
  // landmark table came back with wrist/elbow/trochanter/knee/calf/ankle ALL ZERO. Measured the first
  // time NB was passed, and it would have mis-measured the prior while looking like it worked.
  // ★A POSITIONAL CONTRACT THAT BREAKS WHEN IT IS EXTENDED IS A TRAP FOR EVERY FUTURE ARGUMENT --
  // keying on the VALUE makes it extensible by construction. -1 (the default) = whole-body mode.
  if argc > 5 { ORGAN = pf_satoi(argv[5] as *u8); if ORGAN >= 0 { ORGANON = 1 } }
  // the head band spills a duplicate torso row where the two overlap; one organ has no such overlap
  var spillHi: i64 = PF_TORSO_HI
  if ORGANON == 1 { spillHi = 0-1 }
  // ★TARGET Y-BAND (argv[6],argv[7], per-mille of STATURE). Identity by default, so nothing changes for a
  // whole-body oracle. See the frame-mapping note in the station loop for why a single-organ oracle needs it.
  var YLO: i64 = 0
  var YHI: i64 = 1000
  if argc > 7 { YLO = pf_satoi(argv[6] as *u8); YHI = pf_satoi(argv[7] as *u8) }
  if YHI <= YLO { YLO = 0; YHI = 1000 }
  // ★HIGHEST CANON PART ID to also emit each row under (argv[8]). Default -1 = emit for `part` only, so every
  // existing caller is byte-identical. See the emission site for the measured reason this exists.
  var PIDHI: i64 = 0-1
  if argc > 8 { PIDHI = pf_satoi(argv[8] as *u8) }
  // ★ANGULAR BIN COUNT (argv[9]) -- THE HIGH-FREQUENCY DETAIL CEILING OF THE HUMAN GENERATOR, made
  // liftable. It was PF_NB=48, a PICKED constant with no override, while the oracle holds up to
  // PF_MAXPT=4096 points per section and the consumer (nx_body_gen BG_NBMAX) can already hold 96.
  // We were binning measured anatomy to 48 and discarding the rest. Default is PF_NB so every existing
  // caller is BYTE-IDENTICAL by construction; raising it is a DATA decision, not a taste decision.
  // ⚠The honest upper bound is the DATA's own support: a bin whose points are fewer than ~1 is a hole
  // the neighbour-fill has to invent, so nb must not exceed the smallest admitted section's point count.
  // That floor is MEASURED and ANNOUNCED below as nb_supported rather than assumed here.
  var NB: i64 = PF_NB
  if argc > 9 { NB = pf_satoi(argv[9] as *u8) }
  if NB < 4 { NB = 4 }
  let sinT: *i64 = sys_mmap(400*8) as *i64
  pf_sin_fill(sinT)
410
  let ln: *i64 = sys_mmap(16) as *i64
  let mb: *u8 = sys_read_file(orap, ln)
  if (mb as i64) == 0 { pf_hw("{\x22error\x22:\x22cannot read oracle mesh\x22}\n" as *u8); return 3 }
  let nl: i64 = pf_rdbits(mb, 8)
  let nt: i64 = pf_rdbits(mb, 12)
  let tb: i64 = 16 + nl*24
417
  // pass 0: scale-invariant working precision (a metre-authored mesh must not collapse to zero)
  var q0mn: i64 = PF_BIG; var q0mx: i64 = 0-PF_BIG
  var t: i64 = 0
  while t < nt {
      let o0: i64 = tb + t*84
      var c0: i64 = 0
      while c0 < 3 { let vq: i64 = pf_f32mul(mb, o0 + c0*4, PF_POSQ0); if vq < q0mn { q0mn = vq } if vq > q0mx { q0mx = vq } c0 = c0+1 }
      t = t+1
  }
  var span0: i64 = q0mx - q0mn
  if span0 < 1 { span0 = 1 }
  var posq: i64 = PF_POSQ0 * PF_TARGET / span0
  if posq < 1 { posq = 1 }
431
  // pass 1: AABB -> stature and body midline
  var mnx: i64 = PF_BIG; var mny: i64 = PF_BIG; var mnz: i64 = PF_BIG
  var mxx: i64 = 0-PF_BIG; var mxy: i64 = 0-PF_BIG; var mxz: i64 = 0-PF_BIG
  t = 0
  while t < nt {
      var v: i64 = 0
      while v < 3 {
          let o: i64 = tb + t*84 + v*12
          let x: i64 = pf_f32mul(mb,o,posq); let y: i64 = pf_f32mul(mb,o+4,posq); let z: i64 = pf_f32mul(mb,o+8,posq)
          if x<mnx {mnx=x} if x>mxx {mxx=x} if y<mny {mny=y} if y>mxy {mxy=y} if z<mnz {mnz=z} if z>mxz {mxz=z}
          v = v+1
      }
      t = t+1
  }
  var stature: i64 = mxy - mny
  if stature < 1 { stature = 1 }
  let cxmid: i64 = (mnx+mxx)/2
  let nst: i64 = 1000/STEP + 1
  if nst > PF_MAXST { pf_hw("{\x22error\x22:\x22step too small for station table\x22}\n" as *u8); return 4 }
451
  // pass 2: slice. ONE pass over triangles; each triangle contributes to the few stations it spans.
  let spx: *i64 = sys_mmap(PF_MAXST*PF_MAXPT*8) as *i64
  let spz: *i64 = sys_mmap(PF_MAXST*PF_MAXPT*8) as *i64
  let scn: *i64 = sys_mmap(PF_MAXST*8) as *i64
  var s: i64 = 0
  while s < nst { scn[s] = 0; s = s+1 }
  let vx: *i64 = sys_mmap(3*8) as *i64
  let vy: *i64 = sys_mmap(3*8) as *i64
  let vz: *i64 = sys_mmap(3*8) as *i64
  t = 0
  while t < nt {
      var v: i64 = 0
      var ymn: i64 = PF_BIG; var ymx: i64 = 0-PF_BIG
      while v < 3 {
          let o: i64 = tb + t*84 + v*12
          vx[v] = pf_f32mul(mb,o,posq); vy[v] = pf_f32mul(mb,o+4,posq); vz[v] = pf_f32mul(mb,o+8,posq)
          if vy[v] < ymn { ymn = vy[v] }
          if vy[v] > ymx { ymx = vy[v] }
          v = v+1
      }
      var s0: i64 = (ymn - mny)*1000/stature/STEP
      var s1: i64 = (ymx - mny)*1000/stature/STEP + 1
      if s0 < 0 { s0 = 0 }
      if s1 > nst-1 { s1 = nst-1 }
      var st: i64 = s0
      while st <= s1 {
          let Y: i64 = mny + st*STEP*stature/1000
          var e: i64 = 0
          while e < 3 {
              let a: i64 = e; let b: i64 = (e+1)%3
              var lo: i64 = a; var hi: i64 = b
              if vy[a] > vy[b] { lo = b; hi = a }
              if vy[lo] <= Y { if vy[hi] > Y {
                  var den: i64 = vy[hi]-vy[lo]
                  if den < 1 { den = 1 }
                  let f: i64 = (Y - vy[lo])*1000/den
                  let ix: i64 = vx[lo] + (vx[hi]-vx[lo])*f/1000
                  let iz: i64 = vz[lo] + (vz[hi]-vz[lo])*f/1000
                  let c: i64 = scn[st]
                  if c < PF_MAXPT { spx[st*PF_MAXPT+c] = ix; spz[st*PF_MAXPT+c] = iz; scn[st] = c+1 }
              }}
              e = e+1
          }
          st = st+1
      }
      t = t+1
  }
499
  // pass 3: per station, cluster on x, assign clusters to canon parts, fit each section
  let opos: *i64 = sys_mmap(3*8) as *i64
  let obuf: *NxBufOwned = pf_output_new(opos)
  pf_puts(obuf, opos, "; Nishi measured cross-section profiles; dimensionless ellipse residuals.
504" as *u8)
  pf_puts(obuf, opos, "; Source mesh: " as *u8); pf_puts(obuf, opos, orap)
  pf_puts(obuf, opos, "
507; Preserve the source asset provenance and rights receipt; no anatomical or licensing identity inferred.
508" as *u8)
  pf_puts(obuf, opos, "; S <part> <ymil> <ra_permil> <rb_permil> <ratio x N, theta 0=+X lateral, 90=+Z front>\n" as *u8)
  // the bin count travels WITH the data, so the consumer can never assume a different resolution
  pf_puts(obuf, opos, "N " as *u8)
  pf_putint(obuf, opos, NB, 10)
513
  let hist: *i64 = sys_mmap(PF_XBINS*8) as *i64
  let runLo: *i64 = sys_mmap(PF_MAXRUN*8) as *i64
  let runHi: *i64 = sys_mmap(PF_MAXRUN*8) as *i64
  let sel: *i64 = sys_mmap(PF_MAXPT*8) as *i64
  let fit: *i64 = sys_mmap(8*8) as *i64
  let rat: *i64 = sys_mmap(NB*8) as *i64
  var rows: i64 = 0
  var devsum: i64 = 0; var devcnt: i64 = 0
  // measured control-handle tables, per part (the raw material the canon is factorised from)
  let cN: *i64 = sys_mmap(PF_MAXPARTS*8) as *i64
  let cY: *i64 = sys_mmap(PF_MAXPARTS*PF_MAXST*8) as *i64
  let cRA: *i64 = sys_mmap(PF_MAXPARTS*PF_MAXST*8) as *i64
  let cRB: *i64 = sys_mmap(PF_MAXPARTS*PF_MAXST*8) as *i64
  let cXC: *i64 = sys_mmap(PF_MAXPARTS*PF_MAXST*8) as *i64
  let cZC: *i64 = sys_mmap(PF_MAXPARTS*PF_MAXST*8) as *i64
  var pz0: i64 = 0
  while pz0 < PF_MAXPARTS { cN[pz0] = 0; pz0 = pz0+1 }
  s = 0
  while s < nst {
      let ymil: i64 = s*STEP
      // ★FRAME MAPPING. ymil is per-mille of the ORACLE'S OWN height, but the consumer looks the prior up in
      // per-mille of STATURE (nx_body_gen: ymq = yri/1000, the canon's own R-row units). For a whole-body
      // oracle those two frames coincide, which is why nothing needed this before. For a SINGLE-ORGAN oracle
      // they do NOT: nx_skullgen emits R rows spanning y 872..1000, so a skull profile written at 0..1000
      // would be queried ONLY over its top 128 per-mille -- every part of the skull modulated by the CROWN's
      // cross-section, and silently, because the rows exist and the lookup succeeds. Map the oracle's own
      // extent onto the band the canon actually occupies.
      var yout: i64 = ymil
      if ORGANON == 1 { yout = YLO + ymil*(YHI-YLO)/1000 }
      let cnt: i64 = scn[s]
      if cnt >= NB {
          var xmn: i64 = PF_BIG; var xmx: i64 = 0-PF_BIG
          var k: i64 = 0
          while k < cnt {
              let x: i64 = spx[s*PF_MAXPT+k]
              if x < xmn { xmn = x }
              if x > xmx { xmx = x }
              k = k+1
          }
          var xsp: i64 = xmx - xmn
          if xsp < 1 { xsp = 1 }
          var h: i64 = 0
          while h < PF_XBINS { hist[h] = 0; h = h+1 }
          k = 0
          while k < cnt {
              var bi: i64 = (spx[s*PF_MAXPT+k] - xmn)*(PF_XBINS-1)/xsp
              if bi < 0 { bi = 0 }
              if bi > PF_XBINS-1 { bi = PF_XBINS-1 }
              hist[bi] = hist[bi] + 1
              k = k+1
          }
          // contiguous runs of occupied bins, split where PF_GAP or more bins are empty
          var nrun: i64 = 0
          var inrun: i64 = 0
          var gap: i64 = 0
          h = 0
          while h < PF_XBINS {
              if hist[h] > 0 {
                  if inrun == 0 { if nrun < PF_MAXRUN { runLo[nrun] = h; runHi[nrun] = h; nrun = nrun+1; inrun = 1 } }
                  else { runHi[nrun-1] = h }
                  gap = 0
              } else {
                  if inrun == 1 { gap = gap+1; if gap >= PF_GAP { inrun = 0 } else { runHi[nrun-1] = h } }
              }
              h = h+1
          }
          // pick the centre run (torso/head) and the outermost run (arm/leg)
          var ic: i64 = 0-1; var io: i64 = 0-1
          var bestc: i64 = PF_BIG; var besto: i64 = 0-1
          var r: i64 = 0
          while r < nrun {
              let rc: i64 = xmn + (runLo[r]+runHi[r])*xsp/(2*(PF_XBINS-1))
              var dc: i64 = rc - cxmid
              if dc < 0 { dc = 0-dc }
              if dc < bestc { bestc = dc; ic = r }
              if rc > besto { besto = rc; io = r }
              r = r+1
          }
          // ---- centre run -> torso and/or head ----
          if ic >= 0 {
              let lo: i64 = xmn + runLo[ic]*xsp/(PF_XBINS-1) - 1
              let hi: i64 = xmn + runHi[ic]*xsp/(PF_XBINS-1) + 1
              var nsel: i64 = 0
              k = 0
              while k < cnt {
                  let x: i64 = spx[s*PF_MAXPT+k]
                  if x >= lo { if x <= hi { if nsel < PF_MAXPT { sel[nsel] = s*PF_MAXPT+k; nsel = nsel+1 } } }
                  k = k+1
              }
              if pf_fit_section(spx, spz, sel, nsel, sinT, fit, rat, NB) == 1 {
                  pf_symmetrize(rat, NB)
                  var part: i64 = 0-1
                  if ymil >= PF_TORSO_LO { if ymil <= PF_TORSO_HI { part = PF_PTORSO } }
                  if ymil >= PF_HEAD_LO { part = PF_PHEAD }
                  if ORGANON == 1 { part = ORGAN }
                  if part >= 0 {
                      // ★DO NOT RECORD A HANDLE WHERE THE SECTION IS NOT MEASURABLE. Through the arm band the
                      // arms touch the torso, so the x-clustering returns ONE run and the "torso" section
                      // silently includes both arms -- measured as ra jumping 88 -> 148 at shoulder height.
                      // A handle fitted there is an artifact, and the greedy factoriser will faithfully
                      // select it BECAUSE it is the largest change. Skip it and let the spline interpolate
                      // across the gap: an honest hole beats a confident wrong number.
                      var meas: i64 = 1
                      if nrun < 2 { if ymil >= PF_ARM_LO { if ymil <= PF_ARM_HI { meas = 0 } } }
                      if ORGANON == 1 { meas = 1 }
                      if meas == 1 { if cN[part] < PF_MAXST {
                          let ci: i64 = part*PF_MAXST + cN[part]
                          cY[ci]=yout; cRA[ci]=fit[0]*1000/stature; cRB[ci]=fit[1]*1000/stature
                          cXC[ci]=fit[2]*1000/stature; cZC[ci]=fit[3]*1000/stature
                          cN[part] = cN[part]+1
                      }}
                      // ★★★EMIT UNDER EVERY CANON PART THAT SPANS THIS HEIGHT. MEASURED 2026-07-30: with rows for
                      // part 0 ONLY, the vault moved at full strength while supraorbital and zygomatic -- which
                      // both span canon y958 -- had no rows for their id, returned 1000, and STOOD STILL.
                      // nx_meshprofile caught it as a NEW radius jump at station 671 that PROF=0 and PROF=250
                      // do not have. A per-part EDGE feather cannot fix that: y958 is the vault's INTERIOR,
                      // exactly where an edge rule is designed not to act. LAW: a prior on ONE part but not the
                      // parts it OVERLAPS steps worst in that part's interior. Correspondence stays honest --
                      // the rows span the whole canon band, so part p reads the section measured at p's own y.
                      var pend: i64 = part
                      if PIDHI > part { pend = PIDHI }
                      var pid: i64 = part
                      while pid <= pend {
                      pf_puts(obuf, opos, "S " as *u8)
                      pf_putint(obuf, opos, pid, 32)
                      pf_putint(obuf, opos, yout, 32)
                      pf_putint(obuf, opos, fit[0]*1000/stature, 32)
                      pf_putint(obuf, opos, fit[1]*1000/stature, 32)
                      var i2: i64 = 0
                      while i2 < NB {
                          var sepc: i64 = 32
                          if i2 == NB-1 { sepc = 10 }
                          pf_putint(obuf, opos, rat[i2], sepc)
                          var d2: i64 = rat[i2]-1000
                          if d2 < 0 { d2 = 0-d2 }
                          devsum = devsum + d2; devcnt = devcnt + 1
                          i2 = i2+1
                      }
                      rows = rows+1
                      // the head band also feeds the torso tube where they overlap, so the neck keeps a profile
                      if part == PF_PHEAD { if ymil <= spillHi {
                          pf_puts(obuf, opos, "S " as *u8)
                          pf_putint(obuf, opos, PF_PTORSO, 32)
                          pf_putint(obuf, opos, ymil, 32)
                          pf_putint(obuf, opos, fit[0]*1000/stature, 32)
                          pf_putint(obuf, opos, fit[1]*1000/stature, 32)
                          i2 = 0
                          while i2 < NB {
                              var sepd: i64 = 32
                              if i2 == NB-1 { sepd = 10 }
                              pf_putint(obuf, opos, rat[i2], sepd)
                              i2 = i2+1
                          }
                          rows = rows+1
                      }}
                      pid = pid + 1
                      }
                  }
              }
          }
          // ---- outermost run -> arm (above the crotch) or leg (below it) ----
          // TWO FUSED LEGS ARE A KNOWN GEOMETRY, NOT AN UNMEASURABLE ONE. Below mid-thigh the legs
          // converge, the x-clustering returns ONE run, and the not-measurable guard refused to record
          // anything -- which is why leg stations stopped at 282 permil and calf/ankle landmarks read
          // zero. An arm fused to a torso is genuinely unrecoverable; two legs are not, because we know
          // the seam is the midline. Split the single run at its x-midpoint and take the +x half.
          var io2: i64 = io
          var forceLo: i64 = 0
          var forceHi: i64 = 0
          var forced: i64 = 0
          if nrun == 1 { if ymil <= PF_LEG_HI { if ymil >= PF_LEG_LO {
              let rlo: i64 = xmn + runLo[0]*xsp/(PF_XBINS-1)
              let rhi: i64 = xmn + runHi[0]*xsp/(PF_XBINS-1)
              forceLo = (rlo+rhi)/2
              forceHi = rhi + 1
              forced = 1
              io2 = 0
          }}}
          if forced == 1 { io = io2 }
          if io >= 0 { if io != ic { forced = forced } else { if forced == 0 { io = 0-1 } }
          if io >= 0 {
              var lo2: i64 = xmn + runLo[io]*xsp/(PF_XBINS-1) - 1
              var hi2: i64 = xmn + runHi[io]*xsp/(PF_XBINS-1) + 1
              if forced == 1 { lo2 = forceLo; hi2 = forceHi }
              var nsel2: i64 = 0
              k = 0
              while k < cnt {
                  let x: i64 = spx[s*PF_MAXPT+k]
                  if x >= lo2 { if x <= hi2 { if nsel2 < PF_MAXPT { sel[nsel2] = s*PF_MAXPT+k; nsel2 = nsel2+1 } } }
                  k = k+1
              }
              if pf_fit_section(spx, spz, sel, nsel2, sinT, fit, rat, NB) == 1 {
                  var part2: i64 = 0-1
                  if ymil >= PF_ARM_LO { if ymil <= PF_ARM_HI { part2 = PF_PARM } }
                  if ymil <= PF_LEG_HI { if ymil >= PF_LEG_LO { part2 = PF_PLEG } else { part2 = 0-1 } }
                  // a single-organ oracle has no limbs: the outer run IS the organ, already taken above
                  if ORGANON == 1 { part2 = 0-1 }
                  if part2 >= 0 {
                      if cN[part2] < PF_MAXST {
                          let c2: i64 = part2*PF_MAXST + cN[part2]
                          cY[c2]=ymil; cRA[c2]=fit[0]*1000/stature; cRB[c2]=fit[1]*1000/stature
                          cXC[c2]=fit[2]*1000/stature; cZC[c2]=fit[3]*1000/stature
                          cN[part2] = cN[part2]+1
                      }
                      pf_puts(obuf, opos, "S " as *u8)
                      pf_putint(obuf, opos, part2, 32)
                      pf_putint(obuf, opos, ymil, 32)
                      pf_putint(obuf, opos, fit[0]*1000/stature, 32)
                      pf_putint(obuf, opos, fit[1]*1000/stature, 32)
                      var i3: i64 = 0
                      while i3 < NB {
                          var sepe: i64 = 32
                          if i3 == NB-1 { sepe = 10 }
                          pf_putint(obuf, opos, rat[i3], sepe)
                          var d3: i64 = rat[i3]-1000
                          if d3 < 0 { d3 = 0-d3 }
                          devsum = devsum + d3; devcnt = devcnt + 1
                          i3 = i3+1
                      }
                      rows = rows+1
                  }
              }
          }}
      }
      s = s+1
  }
740
  let outputRc: i64 = pf_output_commit(obuf, opos, outp)
  if outputRc < 0 { pf_hw("profile_output_failed rc=" as *u8); pf_pn(outputRc); pf_hw("\n" as *u8); return 6 }
743
  // ★FACTORISED CANON (argv[4]): control handles derived from the reference, not typed. This is the
  // Infinigen construction end to end -- measure a real reference, factorise it into a small set of
  // handles, and let the genome scale them. The emitter is UNCHANGED: these are ordinary canon rows.
  var kept: i64 = 0
  if argc > 4 {
      let kpos: *i64 = sys_mmap(3*8) as *i64
      let kbuf: *NxBufOwned = pf_output_new(kpos)
      pf_puts(kbuf, kpos, "# Canon factorised from measured reference sections by nx_profile_fit.
752# Source mesh: " as *u8)
      pf_puts(kbuf, kpos, orap)
      pf_puts(kbuf, kpos, "
755# Preserve the source asset provenance and rights receipt; no anatomical or licensing identity inferred.
756" as *u8)
      let sel: *i64 = sys_mmap(PF_MAXST*8) as *i64
      // global depth reference = the torso's middle handle
      var zref: i64 = 0
      if cN[PF_PTORSO] > 0 { zref = cZC[PF_PTORSO*PF_MAXST + cN[PF_PTORSO]/2] }
      var pp: i64 = 0
      while pp < PF_MAXPARTS {
          if cN[pp] > 2 {
              var mir: i64 = 0
              var mat: i64 = 0
              if pp == PF_PARM { mir = 1 }
              if pp == PF_PLEG { mir = 1 }
              if pp == PF_PHEAD { mat = 5 }
              let hv: i64 = pf_factorise(cY,cRA,cRB,cXC,cZC, pp*PF_MAXST, cN[pp], PF_MAXK, sel)
              pf_emit_part(kbuf,kpos, cY,cRA,cRB,cXC,cZC, pp*PF_MAXST, cN[pp], sel, mir, mat, zref)
              kept = kept + hv
          }
          pp = pp+1
      }
      let canonRc: i64 = pf_output_commit(kbuf, kpos, argv[4] as *u8)
      if canonRc < 0 { pf_hw("canon_output_failed rc=" as *u8); pf_pn(canonRc); pf_hw("\n" as *u8); return 7 }
  }
778
  if devcnt < 1 { devcnt = 1 }
  pf_hw("{\x22organ\x22:\x22nx_profile_fit\x22,\x22tris\x22:" as *u8); pf_pn(nt)
  pf_hw(",\x22stations\x22:" as *u8); pf_pn(nst)
  pf_hw(",\x22rows\x22:" as *u8); pf_pn(rows)
  pf_hw(",\x22bytes\x22:" as *u8); pf_pn(opos[0])
  // ★NON-VACUITY: how far a real human section actually is from the ellipse the emitter used to assume.
  // Near zero here would mean the whole rung is pointless -- publish it either way.
  pf_hw(",\x22mean_abs_dev_permil\x22:" as *u8); pf_pn(devsum/devcnt)
  // landmark block: measured on THIS mesh in per-mille of its OWN stature, so two meshes become comparable.
  // Five measured-transfer attempts failed because the reference anatomy at a coordinate is not OUR anatomy
  // at that coordinate; these points ARE that correspondence, and every one is an extremum of the per-station
  // series this organ already measured and was discarding.
  pf_hw(" lm_acromion=" as *u8); pf_pn(pf_landmark(cY,cRA, PF_PTORSO*PF_MAXST, cN[PF_PTORSO], 760, 908, 1))
  pf_hw(" lm_waist=" as *u8); pf_pn(pf_landmark(cY,cRA, PF_PTORSO*PF_MAXST, cN[PF_PTORSO], 500, 660, 0))
  pf_hw(" lm_iliac=" as *u8); pf_pn(pf_landmark(cY,cRA, PF_PTORSO*PF_MAXST, cN[PF_PTORSO], 430, 520, 1))
  pf_hw(" lm_neck=" as *u8); pf_pn(pf_landmark(cY,cRA, PF_PTORSO*PF_MAXST, cN[PF_PTORSO], 860, 940, 0))
  pf_hw(" lm_wrist=" as *u8); pf_pn(pf_landmark(cY,cRA, PF_PARM*PF_MAXST, cN[PF_PARM], 470, 560, 0))
  pf_hw(" lm_elbow=" as *u8); pf_pn(pf_landmark(cY,cRA, PF_PARM*PF_MAXST, cN[PF_PARM], 580, 700, 0))
  pf_hw(" lm_trochanter=" as *u8); pf_pn(pf_landmark(cY,cRA, PF_PLEG*PF_MAXST, cN[PF_PLEG], 380, 452, 1))
  pf_hw(" lm_knee=" as *u8); pf_pn(pf_landmark(cY,cRA, PF_PLEG*PF_MAXST, cN[PF_PLEG], 170, 300, 0))
  pf_hw(" lm_calf=" as *u8); pf_pn(pf_landmark(cY,cRA, PF_PLEG*PF_MAXST, cN[PF_PLEG], 110, 220, 1))
  pf_hw(" lm_ankle=" as *u8); pf_pn(pf_landmark(cY,cRA, PF_PLEG*PF_MAXST, cN[PF_PLEG], 60, 120, 0))
  pf_hw(",\x22note\x22:\x22dimensionless shape prior only; sizes stay procedural\x22}\n" as *u8)
  return 0
803}
804
805// Candidate-only native harness. The canonical delta excludes this wrapper and function rename.
806func main(argc: i64, argv: *i64) -> i64 {
  if argc != 1 { return pf_output_run(argc, argv) }
  let args: *i64 = sys_mmap(3*8) as *i64
  args[0] = "nx_profile_fit_output_t320" as i64
  args[2] = "/tmp/nx_profile_path_guard_must_not_write.dat" as i64
  args[1] = "source\nN 8\nS 0 1 1 1" as i64
  if pf_output_run(3, args) != 2 { return 21 }
  args[1] = "source\rN 8" as i64
  if pf_output_run(3, args) != 2 { return 22 }
  args[1] = "source\tN 8" as i64
  if pf_output_run(3, args) != 2 { return 23 }
  args[1] = "source\x7fN 8" as i64
  if pf_output_run(3, args) != 2 { return 24 }
  let pos: *i64 = sys_mmap(3*8) as *i64
  let out: *NxBufOwned = pf_output_new(pos)
  let extent: i64 = 1048576+1 // one byte beyond the removed legacy output allocation
  let src: *u8 = sys_mmap(extent+1)
  var k: i64 = 0
  while k < extent { src[k] = 65 as u8; k = k+1 }
  src[extent] = 0 as u8
  if pf_puts(out,pos,src) != 0 { return 31 }
  if out.len != extent { return 32 }
  k = 0; while k < extent { if out.buf[k] != (65 as u8) { return 33 }; k = k+1 }
  if pf_putint(out,pos,0-9223372036854775807-1,10) != 0 { return 34 }
  let expected: *u8 = "-9223372036854775808\n" as *u8
  k = 0; while k < 21 { if out.buf[extent+k] != expected[k] { return 35 }; k = k+1 }
  // A genuine append refusal must remain sticky and prevent a file commit.
  let before: i64 = out.len
  let aliasRc: i64 = pf_puts(out,pos,out.buf)
  if aliasRc != NX_BO_ALIAS { return 36 }
  if out.len != before { return 37 }
  if pf_puts(out,pos,"ignored" as *u8) != NX_BO_ALIAS { return 38 }
  if pf_output_commit(out,pos,"" as *u8) != NX_BO_ALIAS { return 39 }
  sys_munmap(src,extent+1)
  let failpos: *i64 = sys_mmap(3*8) as *i64
  let failout: *NxBufOwned = pf_output_new(failpos)
  pf_puts(failout,failpos,"record" as *u8)
  if pf_output_commit(failout,failpos,"" as *u8) != AR_CHECK_OPEN { return 40 }
  pf_hw("native output adapters PASS: beyond legacy capacity, every byte preserved, i64MIN, sticky alias refusal, commit failure\n" as *u8)
  pf_hw("native provenance guard PASS 4/4: LF CR TAB DEL rejected by fitter before file read\n" as *u8)
  return 0
847}
nx_profile_fit_output_t320.nx source

`nx_profile_fit_output_t320.nx` source
