`nx_rigfloor.nx` source

↩ module page · 675 lines · 33090 B
1// nx_rigfloor.nx -- DERIVE THE ASSET FLOOR FROM THE REFERENCE CORPUS INSTEAD OF DECLARING IT.
2//
3// WHY THIS EXISTS. nx_asset_floor_gate is THE ruler for "is this character game-ready", and it
4// carried five HAND-PICKED bounds: AF_VERT_MIN 4000, AF_TRI_MIN 8000, AF_TRI_MAX 120000,
5// AF_JOINT_MIN 40, AF_MIDLINE 3000. A picked bound structurally cannot answer the question the
6// operator actually asks -- can we emit something that MATCHES THE MODELS WE HAVE -- because it
7// is not a function of the models we have. This organ makes the bound a MEASUREMENT of the
8// reference population, so the gate stops ASSERTING a floor and starts REPORTING one.
9//
10// THIS IS NOT A SECOND RULER. nx_asset_floor_gate remains the one ruler; this is the PRODUCER
11// that derives its bounds into a conf the gate reads. Producer and consumer cannot disagree
12// because there is exactly one of each. nx_spendgate ranked nx_asset_floor_gate as the top
13// incumbent for this intent -- extending it is the entire point, and a rival floor organ would
14// be the duplicate-ruler defect.
15//
16// ROSTER-DRIVEN, NOT DIRECTORY-WALKING, ON PURPOSE. sys_getdents64 exists and a bounded walker
17// is proven in nx_wiki_content_loader. It is still the wrong primitive HERE: the corpus IS the
18// thing under measurement, so a silently-truncated listing would not merely lose a file, it would
19// corrupt the derived bound itself and then publish that bound as a fact. A roster is complete by
20// construction and its coverage is DECIDABLE -- rows declared vs rows read, both printed, and if
21// they do not sum then no floor is written at all.
22//
23// METHOD: OBSERVED RANGE OVER THE FULL POPULATION. No percentile index is chosen, because
24// choosing one would reintroduce exactly the picked constant this organ exists to remove. The
25// band is [min, max] of what the reference assets actually are.
26//
27// WHY n>=2 IS NOT A MAGIC NUMBER. A range needs two observations to HAVE WIDTH. At n=1 the band
28// is a point and would refuse every asset except that one file -- a bar that is not a bar. So the
29// organ abstains at n<2. That is the arity of the operation, not a threshold anyone selected.
30//
31// EXITS: 0 OK | 1 OUT-OF-BAND | 2 usage | 3 UNOBSERVABLE (no corpus / degenerate / partial read)
32// A partial roster read NEVER degrades to a floor: it abstains, because a floor derived from an
33// unknown fraction of the corpus is worse than no floor -- it looks authoritative and is not.
34//
35// license_tier: ORIGINAL   No hw writes (Rule 26).   expect_exit: 0
36import "nx_syscalls.nx"
37
38// ---- exit contract ----
39const RF_EXIT_OK:           i64 = 0
40const RF_EXIT_OUT_OF_BAND:  i64 = 1
41const RF_EXIT_USAGE:        i64 = 2
42const RF_EXIT_UNOBSERVABLE: i64 = 3
43
44// ---- NXA container layout (mirrors nx_asset_floor_gate; one format, one reader shape) ----
45const RF_HDR_BYTES:       i64 = 32
46const RF_SECHDR_BYTES:    i64 = 32
47const RF_SEC_OFF_FIELD:   i64 = 8
48const RF_NSEC_FIELD:      i64 = 16
49const RF_MAGIC_BYTES:     i64 = 8
50const RF_TAG_BYTES:       i64 = 4
51const RF_WORD_BYTES:      i64 = 8
52const RF_PERMIL:          i64 = 1000
53const RF_BYTE_RADIX:      i64 = 256
54const RF_BYTE_MASK:       i64 = 255
55
56// ---- ASCII ----
57const RF_ASCII_ZERO:  i64 = 48
58const RF_ASCII_NINE:  i64 = 57
59const RF_ASCII_MINUS: i64 = 45
60const RF_ASCII_EQ:    i64 = 61
61const RF_ASCII_NL:    i64 = 10
62const RF_ASCII_CR:    i64 = 13
63const RF_ASCII_HASH:  i64 = 35
64const RF_VERB_DERIVE: i64 = 100
65const RF_VERB_SCORE:  i64 = 115
66const RF_DECIMAL:     i64 = 10
67
68// ---- buffers. Every cap here REFUSES rather than truncating (no silent caps). ----
69const RF_CONF_CAP:    i64 = 65536
70const RF_SCRATCH_CAP: i64 = 64
71const RF_PATH_CAP:    i64 = 4096
72const RF_MAX_ROWS:    i64 = 4096
73const RF_STDOUT:      i64 = 1
74const RF_PAIR:        i64 = 2
75
76// ---- CONTAINERS. Two live in this estate and BOTH START WITH 'N', so one byte cannot tell them
77// apart -- the estate's own readers check only b[0] and therefore cannot either. NXANIM01 is an
78// exact EIGHT-byte check, so testing it FIRST is unambiguous and everything else beginning with
79// 'N' falls through to NXMSH2.
80const RF_CONTAINER_UNKNOWN: i64 = 0
81const RF_CONTAINER_NXA:     i64 = 1   // NXANIM01 -- our shipped rigged asset
82const RF_CONTAINER_MSH:     i64 = 2   // NXMSH2  -- what nx_gltf2mesh emits from a glTF donor
83// The magic is EIGHT bytes, "NXMSH2\0\0". Every shipping consumer validates byte 0 and byte 5 --
84// checking byte 0 alone is NOT enough here, because 'NXANIM01' also begins with 'N'. NXANIM01 is
85// tested exhaustively first, so byte 5 is belt-and-braces against any other N-file.
86const RF_MSH_MAGIC_BYTE:    i64 = 78  // 'N' at offset 0
87const RF_MSH_VER_OFF:       i64 = 5
88const RF_MSH_VER_BYTE:      i64 = 50  // '2' at offset 5 -- the version discriminator
89const RF_MSH_NLAYER_FIELD:  i64 = 8   // u32 LE layer count
90const RF_MSH_NTRI_FIELD:    i64 = 12  // u32 LE triangle count
91const RF_MSH_HDR_BYTES:     i64 = 16  // FIXED header; the FULL header is 16 + nlay*24
92const RF_MSH_LAYROW_BYTES:  i64 = 24
93const RF_U32_BYTES:         i64 = 4
94// A triangle record is 84 BYTES = 21 float32: nine position (three vertices x xyz), nine normal,
95// and THREE per-triangle colour. Positions are unindexed -- there is no shared-vertex table and no
96// joint section anywhere in the format. That is a property of the container, not of any one asset.
97const RF_MSH_TRIREC_BYTES:  i64 = 84
98
99// ---- AXES. Seven exist; WHICH ONES A CONTAINER CAN ANSWER IS A PROPERTY OF THE CONTAINER, and an
100// axis a container cannot answer is reported UNAVAILABLE rather than filled with a plausible
101// substitute. Deriving "verts" for NXMSH2 as tris*3 would be arithmetic dressed as a measurement:
102// it would be the SAME number for every mesh in existence and would silently add a zero-width axis
103// that dilutes axes_with_width. Name a bucket for what was measured, never for what you wish it was.
104const RF_AXES:          i64 = 7
105const RF_AX_VERTS:      i64 = 0
106const RF_AX_TRIS:       i64 = 1
107const RF_AX_JOINTS:     i64 = 2
108const RF_AX_TPV_PERMIL: i64 = 3
109const RF_AX_VPJ:        i64 = 4
110const RF_AX_PARTS:      i64 = 5
111const RF_AX_TPP:        i64 = 6   // triangles per named part -- the NXMSH2 shape signal
112
113func rf_out(s: *u8) -> i64 {
  var n: i64 = 0
  while s[n] != 0 { n = n + 1 }
  sys_write(RF_STDOUT, s, n)
  return 0
118}
119// little-endian i64 read, byte by byte -- the container is not alignment-guaranteed
120func rf_rd64(b: *u8, off: i64) -> i64 {
  var v: i64 = 0
  var i: i64 = RF_WORD_BYTES - 1
  while i >= 0 { v = v*RF_BYTE_RADIX + ((b[off + i] & RF_BYTE_MASK) as i64); i = i - 1 }
  return v
125}
126func rf_tag_eq(b: *u8, off: i64, t: *u8) -> i64 {
  var i: i64 = 0
  while i < RF_TAG_BYTES { if b[off + i] != t[i] { return 0 } i = i + 1 }
  return 1
130}
131// section byte-offset by tag, or -1. Walks EVERY declared section: the table is small and a
132// partial scan would report a capability absent that the asset actually carries.
133func rf_find(b: *u8, nsec: i64, t: *u8) -> i64 {
  var s: i64 = 0
  while s < nsec {
      let e: i64 = RF_HDR_BYTES + s*RF_SECHDR_BYTES
      if rf_tag_eq(b, e, t) == 1 { return rf_rd64(b, e + RF_SEC_OFF_FIELD) }
      s = s + 1
  }
  return 0 - 1
141}
142
143// ---- text emission into a buffer (build the line, then ONE write) ----
144func rf_bputs(buf: *u8, off: i64, s: *u8) -> i64 {
  var o: i64 = off
  var i: i64 = 0
  while s[i] != 0 { buf[o] = s[i]; o = o + 1; i = i + 1 }
  return o
149}
150// scratch is passed IN, never allocated here -- this runs per row per axis
151func rf_bputnum(buf: *u8, off: i64, v: i64, scratch: *u8) -> i64 {
  var o: i64 = off
  var n: i64 = v
  if n < 0 { buf[o] = RF_ASCII_MINUS; o = o + 1; n = 0 - n }
  var k: i64 = 0
  if n == 0 { scratch[k] = RF_ASCII_ZERO; k = 1 }
  while n > 0 {
      let q: i64 = n / RF_DECIMAL
      scratch[k] = RF_ASCII_ZERO + (n - q*RF_DECIMAL)
      n = q
      k = k + 1
  }
  while k > 0 { k = k - 1; buf[o] = scratch[k]; o = o + 1 }
  return o
165}
166func rf_kv(buf: *u8, off: i64, key: *u8, v: i64, scratch: *u8) -> i64 {
  var o: i64 = rf_bputs(buf, off, key)
  buf[o] = RF_ASCII_EQ
  o = o + 1
  o = rf_bputnum(buf, o, v, scratch)
  buf[o] = RF_ASCII_NL
  return o + 1
173}
174// Emit one axis band ONLY if the corpus's container could answer it. An axis the container cannot
175// answer must be ABSENT from the conf, never present-with-a-plausible-value: rf_score treats an
176// absent bound as UNOBSERVABLE, so omission propagates the honest answer instead of inventing one.
177func rf_emit_band(cb: *u8, off: i64, kmin: *u8, kmax: *u8, idx: i64,
                lo: *i64, hi: *i64, corpus_av: *i64, scratch: *u8) -> i64 {
  if corpus_av[idx] == 0 { return off }
  var o: i64 = rf_kv(cb, off, kmin, lo[idx], scratch)
  o = rf_kv(cb, o, kmax, hi[idx], scratch)
  return o
183}
184func rf_say(label: *u8, v: i64, scratch: *u8, line: *u8) -> i64 {
  var o: i64 = rf_bputs(line, 0, label)
  o = rf_bputnum(line, o, v, scratch)
  line[o] = RF_ASCII_NL
  sys_write(RF_STDOUT, line, o + 1)
  return 0
190}
191
192// ---- conf reading. LINE-ANCHORED: a key matched mid-line would read a number out of a comment
193// and answer confidently with the wrong bound. Returns `miss` when absent, so an ABSENT key stays
194// distinguishable from a key whose value is legitimately zero.
195func rf_conf_i64(buf: *u8, n: i64, key: *u8, miss: i64) -> i64 {
  var i: i64 = 0
  var at_line_start: i64 = 1
  var found: i64 = 0
  var result: i64 = miss
  while i < n {
      if found == 0 { if at_line_start == 1 {
          var k: i64 = 0
          var matched: i64 = 1
          while key[k] != 0 {
              if i + k >= n { matched = 0 }
              if matched == 1 { if buf[i + k] != key[k] { matched = 0 } }
              k = k + 1
          }
          if matched == 1 { if i + k < n { if buf[i + k] == RF_ASCII_EQ {
              var o: i64 = i + k + 1
              var neg: i64 = 0
              if o < n { if buf[o] == RF_ASCII_MINUS { neg = 1; o = o + 1 } }
              var v: i64 = 0
              var digits: i64 = 0
              var scanning: i64 = 1
              while scanning == 1 {
                  if o >= n { scanning = 0 }
                  if scanning == 1 {
                      let c: i64 = (buf[o] & RF_BYTE_MASK) as i64
                      if c < RF_ASCII_ZERO { scanning = 0 }
                      if c > RF_ASCII_NINE { scanning = 0 }
                      if scanning == 1 {
                          v = v*RF_DECIMAL + (c - RF_ASCII_ZERO)
                          digits = digits + 1
                          o = o + 1
                      }
                  }
              }
              if digits > 0 {
                  if neg == 1 { v = 0 - v }
                  result = v
                  found = 1
              }
          } } }
      } }
      if buf[i] == RF_ASCII_NL { at_line_start = 1 } else { at_line_start = 0 }
      i = i + 1
  }
  return result
240}
241
242// little-endian u32 -- NXMSH2 uses 32-bit counts where NXANIM01 uses 64
243func rf_rd32(b: *u8, off: i64) -> i64 {
  var v: i64 = 0
  var i: i64 = RF_U32_BYTES - 1
  while i >= 0 { v = v*RF_BYTE_RADIX + ((b[off + i] & RF_BYTE_MASK) as i64); i = i - 1 }
  return v
248}
249
250// ---- one asset measurement ----
251// Fills out[] on the seven axes and avail[] with 1 for each axis this CONTAINER can answer.
252// Returns the container kind (RF_CONTAINER_NXA / _MSH), or RF_CONTAINER_UNKNOWN when the asset is
253// unmeasurable -- and it SAYS WHICH, because an unmeasurable asset and a failing asset demand
254// opposite actions.
255func rf_measure(path: *u8, out: *i64, avail: *i64) -> i64 {
  var a: i64 = 0
  while a < RF_AXES { out[a] = 0; avail[a] = 0; a = a + 1 }
  let lp: *i64 = sys_mmap(RF_WORD_BYTES*RF_PAIR) as *i64
  let b: *u8 = sys_read_file(path, lp)
  if (b as i64) == 0 { rf_out("      UNREADABLE (cannot open)\n" as *u8); return RF_CONTAINER_UNKNOWN }
  let n: i64 = lp[0]
  if n < RF_HDR_BYTES { rf_out("      UNREADABLE (shorter than a container header)\n" as *u8); return RF_CONTAINER_UNKNOWN }
263
  // NXANIM01 FIRST, on all eight bytes. Both containers start with 'N', so the exact check must
  // run before the one-byte one or every NXA would be misread as an NXMSH2.
  let mg: *u8 = "NXANIM01" as *u8
  var magic: i64 = 1
  var i: i64 = 0
  while i < RF_MAGIC_BYTES { if b[i] != mg[i] { magic = 0 } i = i + 1 }
270
  if magic == 1 {
      let nsec: i64 = rf_rd64(b, RF_NSEC_FIELD)
      let ov: i64 = rf_find(b, nsec, "VERT" as *u8)
      let ot: i64 = rf_find(b, nsec, "TRIS" as *u8)
      let ok: i64 = rf_find(b, nsec, "SKEL" as *u8)
      if ov < 0 { rf_out("      UNREADABLE (no VERT section)\n" as *u8); return RF_CONTAINER_UNKNOWN }
      if ot < 0 { rf_out("      UNREADABLE (no TRIS section)\n" as *u8); return RF_CONTAINER_UNKNOWN }
      if ok < 0 { rf_out("      UNREADABLE (no SKEL section -- not a RIGGED asset)\n" as *u8); return RF_CONTAINER_UNKNOWN }
      let nv: i64 = rf_rd64(b, ov)
      let nt: i64 = rf_rd64(b, ot)
      let nj: i64 = rf_rd64(b, ok)
      if nv <= 0 { rf_out("      UNREADABLE (VERT count is zero)\n" as *u8); return RF_CONTAINER_UNKNOWN }
      if nj <= 0 { rf_out("      UNREADABLE (SKEL count is zero)\n" as *u8); return RF_CONTAINER_UNKNOWN }
      out[RF_AX_VERTS] = nv
      out[RF_AX_TRIS] = nt
      out[RF_AX_JOINTS] = nj
      // SCALE-FREE axes: these answer "does it match", because a larger or smaller character is
      // still the same KIND of character. Raw counts are scale-bound.
      out[RF_AX_TPV_PERMIL] = nt*RF_PERMIL/nv
      out[RF_AX_VPJ] = nv/nj
      avail[RF_AX_VERTS] = 1
      avail[RF_AX_TRIS] = 1
      avail[RF_AX_JOINTS] = 1
      avail[RF_AX_TPV_PERMIL] = 1
      avail[RF_AX_VPJ] = 1
      return RF_CONTAINER_NXA
  }
298
  var msh: i64 = 0
  if (b[0] & RF_BYTE_MASK) == RF_MSH_MAGIC_BYTE {
      if (b[RF_MSH_VER_OFF] & RF_BYTE_MASK) == RF_MSH_VER_BYTE { msh = 1 }
  }
  if msh == 1 {
      let nl: i64 = rf_rd32(b, RF_MSH_NLAYER_FIELD)
      let nt: i64 = rf_rd32(b, RF_MSH_NTRI_FIELD)
      if nt <= 0 { rf_out("      UNREADABLE (NXMSH2 triangle count is zero)\n" as *u8); return RF_CONTAINER_UNKNOWN }
      // SIZE CHECK against the format's own arithmetic: 16 + nlay*24 + nt*84. A truncated file
      // whose header still parses would otherwise report a confident count for data that is not
      // there -- the same class as a partial scan publishing its prefix as a total.
      let need: i64 = RF_MSH_HDR_BYTES + nl*RF_MSH_LAYROW_BYTES + nt*RF_MSH_TRIREC_BYTES
      if n < need {
          rf_out("      UNREADABLE (NXMSH2 shorter than its own declared header+records)\n" as *u8)
          return RF_CONTAINER_UNKNOWN
      }
      // ONLY WHAT THE CONTAINER ACTUALLY HOLDS. NXMSH2 has no vertex table and no joint section,
      // so verts/joints/ratios stay UNAVAILABLE. Deriving verts as a fixed multiple of tris would
      // be identical for every mesh ever written -- a zero-width axis masquerading as a
      // measurement, which would also dilute axes_with_width.
      out[RF_AX_TRIS] = nt
      avail[RF_AX_TRIS] = 1
      // A ZERO-LAYER MESH IS VALID, NOT BROKEN. nx_bvhfk is a shipping producer that writes
      // nlay=0. Rejecting it would call a conformant file unreadable; dividing by it would be a
      // SIGFPE. The honest answer is that the parts axes are simply UNAVAILABLE for such a file.
      if nl > 0 {
          out[RF_AX_PARTS] = nl
          out[RF_AX_TPP] = nt/nl
          avail[RF_AX_PARTS] = 1
          avail[RF_AX_TPP] = 1
      }
      return RF_CONTAINER_MSH
  }
332
  rf_out("      UNREADABLE (magic is neither NXANIM01 nor NXMSH2)\n" as *u8)
  return RF_CONTAINER_UNKNOWN
335}
336
337func rf_usage() -> i64 {
  rf_out("usage: nx_rigfloor derive <roster> <out.conf>    -- measure the FULL roster, write the floor\n" as *u8)
  rf_out("       nx_rigfloor score  <asset.nxa> <floor.conf> -- score one asset against that floor\n" as *u8)
  rf_out("  roster: one NXA path per line; blank lines and # comments ignored.\n" as *u8)
  rf_out("  exits: 0 OK | 1 OUT-OF-BAND | 2 usage | 3 UNOBSERVABLE\n" as *u8)
  return RF_EXIT_USAGE
343}
344
345func rf_derive(roster: *u8, outconf: *u8) -> i64 {
  let line: *u8 = sys_mmap(RF_PATH_CAP)
  let scratch: *u8 = sys_mmap(RF_SCRATCH_CAP)
  let pathbuf: *u8 = sys_mmap(RF_PATH_CAP)
  let m: *i64 = sys_mmap(RF_WORD_BYTES*RF_AXES) as *i64
  let lo: *i64 = sys_mmap(RF_WORD_BYTES*RF_AXES) as *i64
  let hi: *i64 = sys_mmap(RF_WORD_BYTES*RF_AXES) as *i64
  let av: *i64 = sys_mmap(RF_WORD_BYTES*RF_AXES) as *i64
  let corpus_av: *i64 = sys_mmap(RF_WORD_BYTES*RF_AXES) as *i64
  var ai: i64 = 0
  while ai < RF_AXES { corpus_av[ai] = 0; ai = ai + 1 }
  var container: i64 = RF_CONTAINER_UNKNOWN
  var mixed: i64 = 0
358
  let rp: *i64 = sys_mmap(RF_WORD_BYTES*RF_PAIR) as *i64
  let rb: *u8 = sys_read_file(roster, rp)
  if (rb as i64) == 0 {
      rf_out("NX-RIGFLOOR verdict=UNOBSERVABLE reason=roster-unreadable path=" as *u8)
      rf_out(roster)
      rf_out("\n" as *u8)
      return RF_EXIT_UNOBSERVABLE
  }
  let rn: i64 = rp[0]
  rf_out("NX-RIGFLOOR derive\n  roster: " as *u8)
  rf_out(roster)
  rf_out("\n" as *u8)
371
  var declared: i64 = 0
  var read_ok: i64 = 0
  var failed: i64 = 0
  var capped: i64 = 0
  var first: i64 = 1
  var i: i64 = 0
  while i < rn {
      var e: i64 = i
      var eol: i64 = 0
      while eol == 0 {
          if e >= rn { eol = 1 }
          if eol == 0 { if rb[e] == RF_ASCII_NL { eol = 1 } else { e = e + 1 } }
      }
      var len: i64 = e - i
      if len > 0 { if rb[i + len - 1] == RF_ASCII_CR { len = len - 1 } }
      var skip: i64 = 0
      if len <= 0 { skip = 1 }
      if skip == 0 { if rb[i] == RF_ASCII_HASH { skip = 1 } }
      if skip == 0 { if len >= RF_PATH_CAP { skip = 1; capped = 1 } }
      if skip == 0 {
          declared = declared + 1
          if declared > RF_MAX_ROWS { capped = 1 }
          if capped == 0 {
              var c: i64 = 0
              while c < len { pathbuf[c] = rb[i + c]; c = c + 1 }
              pathbuf[len] = 0
              rf_out("  - " as *u8)
              rf_out(pathbuf)
              rf_out("\n" as *u8)
              let kind: i64 = rf_measure(pathbuf, m, av)
              if kind != RF_CONTAINER_UNKNOWN {
                  read_ok = read_ok + 1
                  // A MIXED-CONTAINER CORPUS IS NOT A CORPUS. NXANIM01 answers verts/joints;
                  // NXMSH2 answers parts and cannot answer either. Ranging across both would put
                  // two different quantities in one band and publish it as a bound.
                  if container == RF_CONTAINER_UNKNOWN { container = kind }
                  if container != kind { mixed = 1 }
                  if kind == RF_CONTAINER_NXA {
                      rf_say("      container=NXANIM01 verts=" as *u8, m[RF_AX_VERTS], scratch, line)
                      rf_say("      tris=" as *u8, m[RF_AX_TRIS], scratch, line)
                      rf_say("      joints=" as *u8, m[RF_AX_JOINTS], scratch, line)
                      rf_say("      tris_per_vert_permil=" as *u8, m[RF_AX_TPV_PERMIL], scratch, line)
                      rf_say("      verts_per_joint=" as *u8, m[RF_AX_VPJ], scratch, line)
                  }
                  if kind == RF_CONTAINER_MSH {
                      rf_say("      container=NXMSH2 tris=" as *u8, m[RF_AX_TRIS], scratch, line)
                      rf_say("      parts=" as *u8, m[RF_AX_PARTS], scratch, line)
                      rf_say("      tris_per_part=" as *u8, m[RF_AX_TPP], scratch, line)
                  }
                  var a: i64 = 0
                  while a < RF_AXES {
                      if av[a] == 1 {
                          // an axis enters the corpus set the first time ANY row answers it, and
                          // its band opens on that row -- not on row zero, which may not have it
                          if corpus_av[a] == 0 { corpus_av[a] = 1; lo[a] = m[a]; hi[a] = m[a] }
                          else {
                              if m[a] < lo[a] { lo[a] = m[a] }
                              if m[a] > hi[a] { hi[a] = m[a] }
                          }
                      }
                      a = a + 1
                  }
                  first = 0
              } else { failed = failed + 1 }
          }
      }
      i = e + 1
  }
440
  rf_say("  n_declared=" as *u8, declared, scratch, line)
  rf_say("  n_read=" as *u8, read_ok, scratch, line)
  rf_say("  n_failed=" as *u8, failed, scratch, line)
  // A PARTITION IS A CLAIM: CHECK THE PARTS SUM.
  var sums: i64 = 0
  if read_ok + failed == declared { sums = 1 }
  rf_say("  partition_reconciles=" as *u8, sums, scratch, line)
448
  if capped == 1 {
      rf_out("NX-RIGFLOOR verdict=UNOBSERVABLE reason=roster-hit-the-row-or-path-cap -- RAISE IT DELIBERATELY, a floor is NOT written from a prefix\n" as *u8)
      return RF_EXIT_UNOBSERVABLE
  }
  if sums == 0 {
      rf_out("NX-RIGFLOOR verdict=UNOBSERVABLE reason=partition-does-not-reconcile\n" as *u8)
      return RF_EXIT_UNOBSERVABLE
  }
  if failed > 0 {
      rf_out("NX-RIGFLOOR verdict=UNOBSERVABLE reason=corpus-incomplete -- a floor derived from an unknown fraction of the corpus looks authoritative and is not\n" as *u8)
      return RF_EXIT_UNOBSERVABLE
  }
  if read_ok < RF_PAIR {
      rf_out("NX-RIGFLOOR verdict=UNOBSERVABLE reason=degenerate-band-too-few -- a range needs two observations to have width; at n<2 the band is a point and would refuse every asset but one\n" as *u8)
      return RF_EXIT_UNOBSERVABLE
  }
  // n>=2 IS NECESSARY BUT NOT SUFFICIENT, AND REAL DATA REFUTED THE FIRST VERSION OF THIS GUARD.
  // Measured 2026-08-22 over the estate's own corpus: eleven rigged NXA files that are BYTE
  // IDENTICAL in geometry (verts=14164 tris=28092 joints=104, every one) satisfy n>=2 and still
  // produce a ZERO-WIDTH band on every axis -- a bar that admits only the reference itself and
  // rejects every other asset in existence. The invariant is not the COUNT of observations, it
  // is the WIDTH those observations produce. Counting was the wrong SHAPE, not the wrong number.
  if mixed == 1 {
      rf_out("NX-RIGFLOOR verdict=UNOBSERVABLE reason=mixed-container-corpus -- this roster holds both NXANIM01 and NXMSH2 rows. They answer DIFFERENT axes, so a band across them would range over two different quantities and publish the result as one bound. Split the roster by container.\n" as *u8)
      return RF_EXIT_UNOBSERVABLE
  }
  var axes_available: i64 = 0
  var axes_with_width: i64 = 0
  var w: i64 = 0
  while w < RF_AXES {
      if corpus_av[w] == 1 {
          axes_available = axes_available + 1
          if hi[w] > lo[w] { axes_with_width = axes_with_width + 1 }
      }
      w = w + 1
  }
  rf_say("  axes_available=" as *u8, axes_available, scratch, line)
  rf_say("  axes_with_width=" as *u8, axes_with_width, scratch, line)
  if axes_with_width == 0 {
      rf_out("NX-RIGFLOOR verdict=UNOBSERVABLE reason=degenerate-corpus-every-asset-identical -- n>=2 but ZERO axes have width. This corpus is ONE distinct shape repeated, so it cannot express a range and a floor from it would admit only itself. This is a CORPUS defect, not an organ defect: acquire distinct reference assets.\n" as *u8)
      return RF_EXIT_UNOBSERVABLE
  }
491
  let cb: *u8 = sys_mmap(RF_CONF_CAP)
  var o: i64 = 0
  o = rf_bputs(cb, o, "# nx_rigfloor derived asset floor -- GENERATED ARTEFACT, DO NOT HAND-EDIT\n" as *u8)
  o = rf_bputs(cb, o, "# Every bound below is a MEASUREMENT of the reference corpus, never a chosen number.\n" as *u8)
  o = rf_bputs(cb, o, "# method: observed range over the FULL population. No percentile index is selected,\n" as *u8)
  o = rf_bputs(cb, o, "# because selecting one would reintroduce the picked constant this file exists to remove.\n" as *u8)
  o = rf_bputs(cb, o, "method=observed-range-full-population\n" as *u8)
  o = rf_bputs(cb, o, "roster=" as *u8)
  o = rf_bputs(cb, o, roster)
  cb[o] = RF_ASCII_NL
  o = o + 1
  o = rf_kv(cb, o, "n_declared" as *u8, declared, scratch)
  o = rf_kv(cb, o, "n_read" as *u8, read_ok, scratch)
  o = rf_kv(cb, o, "n_failed" as *u8, failed, scratch)
  o = rf_kv(cb, o, "corpus_complete" as *u8, 1, scratch)
  // published so a consumer can see HOW MANY axes actually discriminate. A floor whose bands are
  // mostly zero-width is technically valid and nearly useless; that has to be visible, not buried.
  o = rf_kv(cb, o, "axes_total" as *u8, RF_AXES, scratch)
  o = rf_kv(cb, o, "axes_available" as *u8, axes_available, scratch)
  o = rf_kv(cb, o, "axes_with_width" as *u8, axes_with_width, scratch)
  // the container is part of the claim: a floor derived from NXMSH2 donors says nothing about
  // joints, and a consumer must be able to see that WITHOUT inferring it from missing keys
  o = rf_kv(cb, o, "container" as *u8, container, scratch)
  o = rf_emit_band(cb, o, "verts_min" as *u8, "verts_max" as *u8, RF_AX_VERTS, lo, hi, corpus_av, scratch)
  o = rf_emit_band(cb, o, "tris_min" as *u8, "tris_max" as *u8, RF_AX_TRIS, lo, hi, corpus_av, scratch)
  o = rf_emit_band(cb, o, "joints_min" as *u8, "joints_max" as *u8, RF_AX_JOINTS, lo, hi, corpus_av, scratch)
  o = rf_emit_band(cb, o, "tris_per_vert_permil_min" as *u8, "tris_per_vert_permil_max" as *u8, RF_AX_TPV_PERMIL, lo, hi, corpus_av, scratch)
  o = rf_emit_band(cb, o, "verts_per_joint_min" as *u8, "verts_per_joint_max" as *u8, RF_AX_VPJ, lo, hi, corpus_av, scratch)
  o = rf_emit_band(cb, o, "parts_min" as *u8, "parts_max" as *u8, RF_AX_PARTS, lo, hi, corpus_av, scratch)
  o = rf_emit_band(cb, o, "tris_per_part_min" as *u8, "tris_per_part_max" as *u8, RF_AX_TPP, lo, hi, corpus_av, scratch)
522
  let fd: i64 = sys_openat_wr(outconf, MODE_0644)
  if fd < 0 {
      rf_out("NX-RIGFLOOR verdict=UNOBSERVABLE reason=cannot-open-out-conf path=" as *u8)
      rf_out(outconf)
      rf_out("\n" as *u8)
      return RF_EXIT_UNOBSERVABLE
  }
  let wr: i64 = sys_write(fd, cb, o)
  sys_close(fd)
  // ANNOUNCE THE WRITE: an unannounced publish makes "did it land" a hunt instead of a number.
  rf_say("  conf_bytes_built=" as *u8, o, scratch, line)
  rf_say("  conf_bytes_written=" as *u8, wr, scratch, line)
  if wr != o {
      rf_out("NX-RIGFLOOR verdict=UNOBSERVABLE reason=short-write\n" as *u8)
      return RF_EXIT_UNOBSERVABLE
  }
  rf_out("  wrote: " as *u8)
  rf_out(outconf)
  rf_out("\n" as *u8)
  rf_out("NX-RIGFLOOR verdict=DERIVED\n" as *u8)
  return RF_EXIT_OK
544}
545
546// An ABSENT bound is UNOBSERVABLE, never a pass. The caller passes an EMPTY band (lo=1, hi=0) as
547// the miss sentinel, so a key missing from the conf reports bound-absent instead of silently
548// scoring IN-BAND -- which would be a gate passing on the empty set.
549func rf_band(name: *u8, v: i64, lo: i64, hi: i64, scratch: *u8, line: *u8, bad: *i64) -> i64 {
  var o: i64 = rf_bputs(line, 0, "  " as *u8)
  o = rf_bputs(line, o, name)
  o = rf_bputs(line, o, " value=" as *u8)
  o = rf_bputnum(line, o, v, scratch)
  o = rf_bputs(line, o, " band=[" as *u8)
  o = rf_bputnum(line, o, lo, scratch)
  o = rf_bputs(line, o, "," as *u8)
  o = rf_bputnum(line, o, hi, scratch)
  o = rf_bputs(line, o, "] " as *u8)
  if lo > hi {
      o = rf_bputs(line, o, "UNOBSERVABLE-bound-absent\n" as *u8)
      bad[1] = bad[1] + 1
  } else {
      var ok: i64 = 0
      if v >= lo { if v <= hi { ok = 1 } }
      if ok == 1 { o = rf_bputs(line, o, "IN-BAND\n" as *u8) }
      if ok == 0 {
          o = rf_bputs(line, o, "OUT-OF-BAND\n" as *u8)
          bad[0] = bad[0] + 1
      }
  }
  sys_write(RF_STDOUT, line, o)
  return 0
573}
574
575func rf_score(asset: *u8, conf: *u8) -> i64 {
  let line: *u8 = sys_mmap(RF_PATH_CAP)
  let scratch: *u8 = sys_mmap(RF_SCRATCH_CAP)
  let m: *i64 = sys_mmap(RF_WORD_BYTES*RF_AXES) as *i64
  let av: *i64 = sys_mmap(RF_WORD_BYTES*RF_AXES) as *i64
  let bad: *i64 = sys_mmap(RF_WORD_BYTES*RF_PAIR) as *i64
  bad[0] = 0
  bad[1] = 0
583
  let cp: *i64 = sys_mmap(RF_WORD_BYTES*RF_PAIR) as *i64
  let cbuf: *u8 = sys_read_file(conf, cp)
  if (cbuf as i64) == 0 {
      rf_out("NX-RIGFLOOR verdict=UNOBSERVABLE reason=floor-conf-unreadable path=" as *u8)
      rf_out(conf)
      rf_out("\n" as *u8)
      return RF_EXIT_UNOBSERVABLE
  }
  let cn: i64 = cp[0]
  // A FLOOR DERIVED FROM A PARTIAL CORPUS MUST NOT BE USED AS ONE.
  let complete: i64 = rf_conf_i64(cbuf, cn, "corpus_complete" as *u8, 0 - 1)
  if complete != 1 {
      rf_out("NX-RIGFLOOR verdict=UNOBSERVABLE reason=floor-conf-not-corpus-complete\n" as *u8)
      return RF_EXIT_UNOBSERVABLE
  }
  rf_out("NX-RIGFLOOR score\n  asset: " as *u8)
  rf_out(asset)
  rf_out("\n  floor: " as *u8)
  rf_out(conf)
  rf_out("\n" as *u8)
  let n_read: i64 = rf_conf_i64(cbuf, cn, "n_read" as *u8, 0 - 1)
  rf_say("  corpus_n=" as *u8, n_read, scratch, line)
606
  let kind: i64 = rf_measure(asset, m, av)
  if kind == RF_CONTAINER_UNKNOWN {
      rf_out("NX-RIGFLOOR verdict=UNOBSERVABLE reason=asset-unmeasurable\n" as *u8)
      return RF_EXIT_UNOBSERVABLE
  }
  // SCORING ACROSS CONTAINERS IS A SUBJECT MISMATCH, NOT A STRICTER TEST. A floor derived from
  // NXMSH2 donors has no joints band at all; scoring an NXANIM01 asset against it would silently
  // grade a rigged character on three form axes and report the result as a pass.
  let conf_container: i64 = rf_conf_i64(cbuf, cn, "container" as *u8, 0 - 1)
  rf_say("  asset_container=" as *u8, kind, scratch, line)
  rf_say("  floor_container=" as *u8, conf_container, scratch, line)
  if conf_container != kind {
      rf_out("NX-RIGFLOOR verdict=UNOBSERVABLE reason=container-mismatch -- this asset and this floor are different container kinds and answer different axes. Derive a floor from a corpus of the same kind.\n" as *u8)
      return RF_EXIT_UNOBSERVABLE
  }
  if av[RF_AX_VERTS] == 1 { rf_band("verts               " as *u8, m[RF_AX_VERTS],
      rf_conf_i64(cbuf, cn, "verts_min" as *u8, 1),
      rf_conf_i64(cbuf, cn, "verts_max" as *u8, 0), scratch, line, bad) }
  if av[RF_AX_TRIS] == 1 { rf_band("tris                " as *u8, m[RF_AX_TRIS],
      rf_conf_i64(cbuf, cn, "tris_min" as *u8, 1),
      rf_conf_i64(cbuf, cn, "tris_max" as *u8, 0), scratch, line, bad) }
  if av[RF_AX_JOINTS] == 1 { rf_band("joints              " as *u8, m[RF_AX_JOINTS],
      rf_conf_i64(cbuf, cn, "joints_min" as *u8, 1),
      rf_conf_i64(cbuf, cn, "joints_max" as *u8, 0), scratch, line, bad) }
  if av[RF_AX_TPV_PERMIL] == 1 { rf_band("tris_per_vert_permil" as *u8, m[RF_AX_TPV_PERMIL],
      rf_conf_i64(cbuf, cn, "tris_per_vert_permil_min" as *u8, 1),
      rf_conf_i64(cbuf, cn, "tris_per_vert_permil_max" as *u8, 0), scratch, line, bad) }
  if av[RF_AX_VPJ] == 1 { rf_band("verts_per_joint     " as *u8, m[RF_AX_VPJ],
      rf_conf_i64(cbuf, cn, "verts_per_joint_min" as *u8, 1),
      rf_conf_i64(cbuf, cn, "verts_per_joint_max" as *u8, 0), scratch, line, bad) }
  if av[RF_AX_PARTS] == 1 { rf_band("parts               " as *u8, m[RF_AX_PARTS],
      rf_conf_i64(cbuf, cn, "parts_min" as *u8, 1),
      rf_conf_i64(cbuf, cn, "parts_max" as *u8, 0), scratch, line, bad) }
  if av[RF_AX_TPP] == 1 { rf_band("tris_per_part       " as *u8, m[RF_AX_TPP],
      rf_conf_i64(cbuf, cn, "tris_per_part_min" as *u8, 1),
      rf_conf_i64(cbuf, cn, "tris_per_part_max" as *u8, 0), scratch, line, bad) }
643
  rf_say("  axes_total=" as *u8, RF_AXES, scratch, line)
  rf_say("  axes_out_of_band=" as *u8, bad[0], scratch, line)
  rf_say("  axes_unobservable=" as *u8, bad[1], scratch, line)
  if bad[1] > 0 {
      rf_out("NX-RIGFLOOR verdict=UNOBSERVABLE reason=at-least-one-bound-absent-from-the-floor-conf\n" as *u8)
      return RF_EXIT_UNOBSERVABLE
  }
  if bad[0] > 0 {
      rf_out("NX-RIGFLOOR verdict=OUT-OF-BAND\n" as *u8)
      return RF_EXIT_OUT_OF_BAND
  }
  rf_out("NX-RIGFLOOR verdict=IN-BAND\n" as *u8)
  return RF_EXIT_OK
657}
658
659func main(argc: i64, argv: *i64) -> i64 {
  if argc < 4 {
      let u: i64 = rf_usage()
      sys_exit(u)
      return u
  }
  let verb: *u8 = argv[1] as *u8
  let a2: *u8 = argv[2] as *u8
  let a3: *u8 = argv[3] as *u8
  var rc: i64 = RF_EXIT_USAGE
  var known: i64 = 0
  if verb[0] == RF_VERB_DERIVE { rc = rf_derive(a2, a3); known = 1 }
  if verb[0] == RF_VERB_SCORE { rc = rf_score(a2, a3); known = 1 }
  if known == 0 { rc = rf_usage() }
  sys_exit(rc)
  return rc
675}
nx_rigfloor.nx source

`nx_rigfloor.nx` source
