`nx_kind.nx` source

↩ module page · 586 lines · 25392 B
1// nx_kind.nx -- L0 OF THE SEMANTIC LADDER, OMNI EDITION (debts 1785954089 + 1785955711; operator
2// 2026-08-05: "animal, human, humanoid, real, fantasy, natural object, mechanical -- whatever fits the
3// ontological goal"). Successor to nx_bodyparts v1, which COMPILED IN "humanoid" and could therefore
4// only ever recognise one species -- the exact magic-number/spec-as-data violation the estate forbids.
5//
6// A KIND IS A ROW, NOT A FUNCTION. Schemas are predicates over a mesh's structural signature; the
7// organ evaluates a mesh against EVERY registered kind and reports the best match plus WHY each other
8// failed. Adding "quadruped" or "fastener" is an append, never a recompile.
9//
10// SIGNATURE (rig-free, works on any mesh soup): slice along the declared stack axis into bands; in each
11// band build a histogram over the declared cluster axis; count occupied runs (clusters) and the span
12// width. Triangle SPANS are rasterised, not vertices (a coarse box must occupy every band it crosses --
13// a refusal from an empty measurement is not a refusal from a measurement).
14//
15// SCHEMA ROWS (plane knowledge/store/kind-, tab-separated, key-first; last-wins by convention):
16//   <kind>  stack   <axis 0=x 1=y 2=z>  <cluster-axis>          -- declares the frame
17//   <kind>  band    <lo>  <hi>  <minclust>  <maxclust>  <label>  -- lo/hi are per-mille of extent
18//   <kind>  narrow  <lo>  <hi>  <frac-permil-of-max>  <label>    -- a waist/neck: a width MINIMUM
19// Unknown verbs are IGNORED ADDITIVELY so new predicate kinds (radial-symmetry, periodicity, genus)
20// can be seeded before this organ learns to test them.
21//
22//   nx_kind <mesh.nxmesh> [bands]              (schemas from the plane)
23//   nx_kind schema <file> <mesh.nxmesh> [bands] (schemas from a file -- offline/selftest)
24//   nx_kind selftest
25// license_tier: ORIGINAL  expect_exit: 0
26import "nx_syscalls.nx"
27import "nx_store_seed_lib.nx"
28const KD_MAGIC_65536: i64 = 65536
29const KD_MAGIC_1600: i64 = 1600
30const KD_MAGIC_262144: i64 = 262144
31const KD_MAGIC_1350: i64 = 1350
32const KD_MAGIC_1300: i64 = 1300
33const KD_MAGIC_1430: i64 = 1430
34const KD_MAGIC_1100: i64 = 1100
35
36const KD_CAP: i64 = 33554432
37const KD_SCAP: i64 = 262144
38const KD_MAXTRI: i64 = 400000
39const KD_MAXBAND: i64 = 256
40const KD_BINS: i64 = 128
41const KD_GAP: i64 = 2
42const KD_MAXTAX: i64 = 32
43const KD_MAXRULE: i64 = 256
44const KD_NAMECAP: i64 = 32
45const KD_M8388607: i64 = 8388607
46const KD_M8388608: i64 = 8388608
47const KD_BIG: i64 = 4611686018427387903
48const KD_TAB: i64 = 9
49const KD_NL: i64 = 10
50
51func hw(s: *u8) -> i64 { var n: i64=0; while s[n]!=(0 as u8){n=n+1} sys_write(1,s,n); return 0 }
52func pn(v: i64) -> i64 { let b: *u8=sys_mmap(32) as *u8; 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 }
53func kd_pr(b: *u8, a: i64, e: i64) -> i64 { if e > a { sys_write(1, ((b as i64)+a) as *u8, e-a) } return 0 }
54func kd_u32(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) }
55func kd_f32q(w: i64) -> i64 {
  let sign: i64 = (w >> 31) & 1
  let expo: i64 = (w >> 23) & 255
  if expo == 0 { return 0 }
  var mant: i64 = (w & KD_M8388607) | KD_M8388608
  let sh: i64 = expo - 127
  var v: i64 = 0
  if sh >= 23 { if sh - 23 > 30 { return 0 } }
  if sh >= 23 { v = mant * 100 * (1 << (sh - 23)) }
  if sh < 23 { if 23 - sh > 62 { return 0 } }
  if sh < 23 { v = (mant * 100) >> (23 - sh) }
  if sign == 1 { return 0 - v }
  return v
68}
69func kd_refuse(reason: *u8) -> i64 { hw("KIND REFUSED: " as *u8); hw(reason); hw("\n" as *u8); return 0 }
70
71func kd_load(path: *u8, vx: *i64) -> i64 {
  let fd: i64 = sys_openat_rd(path)
  if fd < 0 { return 0 - 1 }
  let b: *u8 = sys_mmap(KD_CAP + 64)
  var n: i64 = 0
  var go: i64 = 1
  while go == 1 {
      let r: i64 = sys_read(fd, ((b as i64) + n) as *u8, KD_CAP - n)
      if r <= 0 { go = 0 } else { n = n + r }
      if n >= KD_CAP { go = 0 }
  }
  sys_close(fd)
  if n < 44 { return 0 - 1 }
  if b[0] != (78 as u8) { return 0 - 1 }
  if b[5] != (50 as u8) { return 0 - 1 }
  let nlay: i64 = kd_u32(b, 8)
  let nt: i64 = kd_u32(b, 12)
  if nt <= 0 { return 0 - 1 }
  if nt > KD_MAXTRI { return 0 - 1 }
  let hdr: i64 = 16 + nlay*24
  if hdr + nt*84 > n { return 0 - 1 }
  var t: i64 = 0
  while t < nt {
      var c: i64 = 0
      while c < 9 { vx[t*9+c] = kd_f32q(kd_u32(b, hdr + t*84 + c*4)); c = c + 1 }
      t = t + 1
  }
  return nt
99}
100func kd_readfile(path: *u8, buf: *u8, cap: i64) -> i64 {
  let fd: i64 = sys_openat_rd(path)
  if fd < 0 { return 0 - 1 }
  var n: i64 = 0
  var go: i64 = 1
  while go == 1 {
      let r: i64 = sys_read(fd, ((buf as i64) + n) as *u8, cap - n)
      if r <= 0 { go = 0 } else { n = n + r }
      if n >= cap { go = 0 }
  }
  sys_close(fd)
  return n
112}
113
114// ---- signature: clusters + width per band, over declared axes ----
115static KD_CL: i64
116static KD_WD: i64
117static KD_NB: i64
118func kd_clusters(occ: *i64) -> i64 {
  var runs: i64 = 0
  var inrun: i64 = 0
  var empty: i64 = 0
  var i: i64 = 0
  while i < KD_BINS {
      if occ[i] > 0 {
          if inrun == 0 { runs = runs + 1; inrun = 1 }
          empty = 0
      } else {
          empty = empty + 1
          if empty >= KD_GAP { inrun = 0 }
      }
      i = i + 1
  }
  return runs
134}
135func kd_width(occ: *i64) -> i64 {
  var lo: i64 = 0 - 1
  var hi: i64 = 0 - 1
  var i: i64 = 0
  while i < KD_BINS {
      if occ[i] > 0 { if lo < 0 { lo = i } hi = i }
      i = i + 1
  }
  if lo < 0 { return 0 }
  return hi - lo + 1
145}
146// ★A PREDICATE OVER A 2-AXIS PROJECTION MEASURES A SHADOW UNLESS IT WINDOWS THE THIRD AXIS
147// (found 2026-08-05 by the quadruped fixture: its barrel spans the same z as the legs beneath it, so
148// legs+barrel merged into ONE cluster and 'four legs' was untestable). wlo/whi are per-mille of the
149// THIRD axis extent (the one that is neither stack nor cluster); 0..1000 = no filter.
150func kd_sig(vx: *i64, nt: i64, nband: i64, sa: i64, ca: i64, wlo: i64, whi: i64) -> i64 {
  var wa: i64 = 3 - sa - ca
  var wmn: i64 = KD_BIG
  var wmx: i64 = 0-KD_BIG
  var tw: i64 = 0
  while tw < nt {
      var cw: i64 = 0
      while cw < 3 {
          let wv: i64 = vx[tw*9+cw*3+wa]
          if wv < wmn { wmn = wv }
          if wv > wmx { wmx = wv }
          cw = cw + 1
      }
      tw = tw + 1
  }
  var wext: i64 = wmx - wmn
  if wext < 1 { wext = 1 }
  var smn: i64 = KD_BIG
  var smx: i64 = 0-KD_BIG
  var cmn: i64 = KD_BIG
  var cmx: i64 = 0-KD_BIG
  var t: i64 = 0
  while t < nt {
      var c: i64 = 0
      while c < 3 {
          let s: i64 = vx[t*9+c*3+sa]
          let u: i64 = vx[t*9+c*3+ca]
          if s < smn { smn = s }
          if s > smx { smx = s }
          if u < cmn { cmn = u }
          if u > cmx { cmx = u }
          c = c + 1
      }
      t = t + 1
  }
  var ext: i64 = smx - smn
  if ext < 1 { return 0 - 1 }
  var wid: i64 = cmx - cmn
  if wid < 1 { wid = 1 }
  let grid: *i64 = sys_mmap(KD_MAXBAND*KD_BINS*8 + 64) as *i64
  var g: i64 = 0
  while g < nband*KD_BINS { grid[g] = 0; g = g + 1 }
  t = 0
  while t < nt {
      var slo: i64 = vx[t*9+sa]
      var shi: i64 = slo
      var ulo: i64 = vx[t*9+ca]
      var uhi: i64 = ulo
      var c2: i64 = 1
      while c2 < 3 {
          let ss: i64 = vx[t*9+c2*3+sa]
          let uu: i64 = vx[t*9+c2*3+ca]
          if ss < slo { slo = ss }
          if ss > shi { shi = ss }
          if uu < ulo { ulo = uu }
          if uu > uhi { uhi = uu }
          c2 = c2 + 1
      }
      // third-axis window filter (per-mille of that axis' extent)
      var wc: i64 = (vx[t*9+wa] + vx[t*9+3+wa] + vx[t*9+6+wa])/3
      var wpm: i64 = (wc - wmn)*1000/wext
      var keep: i64 = 0
      if wpm >= wlo { if wpm <= whi { keep = 1 } }
      var b0: i64 = (slo - smn)*nband/ext
      var b1: i64 = (shi - smn)*nband/ext
      if b0 < 0 { b0 = 0 }
      if b1 >= nband { b1 = nband-1 }
      var i0: i64 = (ulo - cmn)*KD_BINS/wid
      var i1: i64 = (uhi - cmn)*KD_BINS/wid
      if i0 < 0 { i0 = 0 }
      if i1 >= KD_BINS { i1 = KD_BINS-1 }
      if keep == 1 {
          var bb: i64 = b0
          while bb <= b1 {
              var ii: i64 = i0
              while ii <= i1 { grid[bb*KD_BINS + ii] = grid[bb*KD_BINS + ii] + 1; ii = ii + 1 }
              bb = bb + 1
          }
      }
      t = t + 1
  }
  if KD_CL == 0 { KD_CL = sys_mmap(KD_MAXBAND*8) as i64; KD_WD = sys_mmap(KD_MAXBAND*8) as i64 }
  let cl: *i64 = KD_CL as *i64
  let wd: *i64 = KD_WD as *i64
  var b3: i64 = 0
  while b3 < nband {
      cl[b3] = kd_clusters(((grid as i64) + b3*KD_BINS*8) as *i64)
      wd[b3] = kd_width(((grid as i64) + b3*KD_BINS*8) as *i64)
      b3 = b3 + 1
  }
  KD_NB = nband
  return ext
242}
243
244// ---- schema parsing ----
245func kd_eol(b: *u8, n: i64, i: i64) -> i64 {
  var e: i64 = i
  while e < n { if b[e] == (KD_NL as u8) { return e } else { e = e + 1 } }
  return n
249}
250// fill col[0..2k] with start/end of up to maxc tab-separated fields in [ls,le)
251func kd_cols(b: *u8, ls: i64, le: i64, col: *i64, maxc: i64) -> i64 {
  var c: i64 = 0
  var p: i64 = ls
  while c < maxc {
      // ★A BREAK-BY-SENTINEL THAT OVERWRITES THE CURSOR DESTROYS THE POSITION IT EXISTS TO REPORT
      // (banked law, re-broken here 2026-08-05 = 4th occurrence: q=le+le then q-le-le is 0, so every
      // field parsed EMPTY and all 7 kinds came back nameless). Terminate with a FLAG, never the cursor.
      var q: i64 = p
      var fnd: i64 = 0
      while fnd == 0 {
          if q >= le { fnd = 1 } else { if b[q] == (KD_TAB as u8) { fnd = 1 } else { q = q + 1 } }
      }
      col[c*2] = p
      col[c*2+1] = q
      if q >= le { c = c + 1; while c < maxc { col[c*2] = le; col[c*2+1] = le; c = c + 1 } return c }
      p = q + 1
      c = c + 1
  }
  return c
270}
271func kd_int(b: *u8, a: i64, e: i64) -> i64 {
  var v: i64 = 0
  var neg: i64 = 0
  var i: i64 = a
  if i < e { if b[i] == (45 as u8) { neg = 1; i = i + 1 } }
  while i < e {
      let ch: i64 = b[i] as i64
      if ch >= 48 { if ch <= 57 { v = v*10 + (ch-48) } }
      i = i + 1
  }
  if neg == 1 { return 0 - v }
  return v
283}
284func kd_same(b: *u8, a: i64, e: i64, lit: *u8) -> i64 {
  var l: i64 = 0
  while lit[l] != (0 as u8) { l = l + 1 }
  if e - a != l { return 0 }
  var i: i64 = 0
  while i < l { if b[a+i] != lit[i] { return 0 } i = i + 1 }
  return 1
291}
292func kd_streq(b: *u8, a1: i64, e1: i64, a2: i64, e2: i64) -> i64 {
  if e1-a1 != e2-a2 { return 0 }
  var i: i64 = 0
  while i < e1-a1 { if b[a1+i] != b[a2+i] { return 0 } i = i + 1 }
  return 1
297}
298
299func kd_run(meshp: *u8, sb: *u8, sn: i64, nband: i64) -> i64 {
  let vx: *i64 = sys_mmap(KD_MAXTRI*9*8 + 64) as *i64
  let nt: i64 = kd_load(meshp, vx)
  if nt < 0 { kd_refuse("mesh unreadable or not NXMSH2" as *u8); return 3 }
  if sn <= 0 { kd_refuse("no kind schemas (plane empty or file unreadable) -- refusing to guess an ontology" as *u8); return 4 }
  // distinct kind names (first field of each row)
  let tn0: *i64 = sys_mmap(KD_MAXTAX*8) as *i64
  let tn1: *i64 = sys_mmap(KD_MAXTAX*8) as *i64
  var ntax: i64 = 0
  let col: *i64 = sys_mmap(24*2*8) as *i64
  var i: i64 = 0
  while i < sn {
      let le: i64 = kd_eol(sb, sn, i)
      if le > i {
          kd_cols(sb, i, le, col, 10)
          var seen: i64 = 0
          var k: i64 = 0
          while k < ntax { if kd_streq(sb, col[0], col[1], tn0[k], tn1[k]) == 1 { seen = 1; k = ntax } else { k = k + 1 } }
          if seen == 0 { if ntax < KD_MAXTAX { tn0[ntax] = col[0]; tn1[ntax] = col[1]; ntax = ntax + 1 } }
      }
      i = le + 1
  }
  hw("{\x22organ\x22:\x22nx_kind\x22,\x22level\x22:\x22L0-kind\x22,\x22tris\x22:" as *u8); pn(nt)
  hw(",\x22bands\x22:" as *u8); pn(nband)
  hw(",\x22kinds_registered\x22:" as *u8); pn(ntax)
  hw(",\x22results\x22:[" as *u8)
  var best: i64 = 0 - 1
  var best_rules: i64 = 0
  var tix: i64 = 0
  while tix < ntax {
      // frame: default stack=y(1) cluster=x(0); a stack row overrides
      var sa: i64 = 1
      var ca: i64 = 0
      i = 0
      while i < sn {
          let le2: i64 = kd_eol(sb, sn, i)
          if le2 > i {
              kd_cols(sb, i, le2, col, 8)
              if kd_streq(sb, col[0], col[1], tn0[tix], tn1[tix]) == 1 {
                  if kd_same(sb, col[2], col[3], "stack" as *u8) == 1 { sa = kd_int(sb, col[4], col[5]); ca = kd_int(sb, col[6], col[7]) }
              }
          }
          i = le2 + 1
      }
      if kd_sig(vx, nt, nband, sa, ca, 0, 1000) < 0 { kd_refuse("degenerate extent on the declared stack axis" as *u8); return 5 }
      let cl: *i64 = KD_CL as *i64
      let wd: *i64 = KD_WD as *i64
      var wmax: i64 = 0
      var b4: i64 = 0
      while b4 < nband { if wd[b4] > wmax { wmax = wd[b4] } b4 = b4 + 1 }
      var rules: i64 = 0
      var passed: i64 = 0
      var f0: i64 = 0
      var f1: i64 = 0
      i = 0
      while i < sn {
          let le3: i64 = kd_eol(sb, sn, i)
          if le3 > i {
              kd_cols(sb, i, le3, col, 10)
              if kd_streq(sb, col[0], col[1], tn0[tix], tn1[tix]) == 1 {
                  if kd_same(sb, col[2], col[3], "band" as *u8) == 1 {
                      rules = rules + 1
                      let lo: i64 = kd_int(sb, col[4], col[5])
                      let hi: i64 = kd_int(sb, col[6], col[7])
                      let mnc: i64 = kd_int(sb, col[8], col[9])
                      let mxc: i64 = kd_int(sb, col[10], col[11])
                      // optional third-axis window in fields 7,8 (per-mille); absent = whole extent
                      var rwlo: i64 = 0
                      var rwhi: i64 = 1000
                      if col[15] > col[14] { rwlo = kd_int(sb, col[14], col[15]); rwhi = kd_int(sb, col[16], col[17]) }
                      if rwhi <= rwlo { rwlo = 0; rwhi = 1000 }
                      kd_sig(vx, nt, nband, sa, ca, rwlo, rwhi)
                      var got: i64 = 0
                      var b5: i64 = 0
                      while b5 < nband {
                          let pm: i64 = b5*1000/nband
                          if pm >= lo { if pm <= hi { if cl[b5] > got { got = cl[b5] } } }
                          b5 = b5 + 1
                      }
                      var ok: i64 = 0
                      if got >= mnc { if got <= mxc { ok = 1 } }
                      if ok == 1 { passed = passed + 1 } else { if f1 == 0 { f0 = col[12]; f1 = col[13] } }
                      kd_sig(vx, nt, nband, sa, ca, 0, 1000)
                  }
                  if kd_same(sb, col[2], col[3], "narrow" as *u8) == 1 {
                      rules = rules + 1
                      let lo2: i64 = kd_int(sb, col[4], col[5])
                      let hi2: i64 = kd_int(sb, col[6], col[7])
                      let frac: i64 = kd_int(sb, col[8], col[9])
                      var wmin: i64 = KD_BIG
                      var b6: i64 = 0
                      while b6 < nband {
                          let pm2: i64 = b6*1000/nband
                          if pm2 >= lo2 { if pm2 <= hi2 { if wd[b6] > 0 { if wd[b6] < wmin { wmin = wd[b6] } } } }
                          b6 = b6 + 1
                      }
                      var ok2: i64 = 0
                      if wmin < KD_BIG { if wmax > 0 { if wmin*1000 <= wmax*frac { ok2 = 1 } } }
                      if ok2 == 1 { passed = passed + 1 } else { if f1 == 0 { f0 = col[10]; f1 = col[11] } }
                  }
              }
          }
          i = le3 + 1
      }
      if tix > 0 { hw("," as *u8) }
      hw("{\x22kind\x22:\x22" as *u8); kd_pr(sb, tn0[tix], tn1[tix])
      hw("\x22,\x22rules\x22:" as *u8); pn(rules)
      hw(",\x22passed\x22:" as *u8); pn(passed)
      if passed == rules { if rules > 0 { hw(",\x22match\x22:1" as *u8) } else { hw(",\x22match\x22:0" as *u8) } } else { hw(",\x22match\x22:0,\x22first_fail\x22:\x22" as *u8); kd_pr(sb, f0, f1); hw("\x22" as *u8) }
      hw("}" as *u8)
      if passed == rules { if rules > best_rules { best = tix; best_rules = rules } }
      tix = tix + 1
  }
  hw("]" as *u8)
  if best >= 0 { hw(",\x22verdict\x22:\x22" as *u8); kd_pr(sb, tn0[best], tn1[best]); hw("\x22,\x22matched_rules\x22:" as *u8); pn(best_rules) } else { hw(",\x22verdict\x22:\x22NO-KIND-MATCH\x22" as *u8) }
  hw(",\x22note\x22:\x22kinds are DATA (plane rows); unknown verbs ignored additively so radial-symmetry/periodicity/genus can be seeded before they are testable\x22}\n" as *u8)
  if best >= 0 { return 0 }
  return 1
417}
418
419// ---- fixtures ----
420func kd_encf(v: i64, scale: i64) -> i64 {
  if v == 0 { return 0 }
  var neg: i64 = 0
  var m: i64 = v
  if m < 0 { neg = 1; m = 0-m }
  var e: i64 = 0
  var num: i64 = m
  var den: i64 = scale
  while num >= den*2 { den = den*2; e = e+1 }
  while num < den { num = num*2; e = e-1 }
  let frac: i64 = ((num - den)*KD_M8388608)/den
  var bits: i64 = ((e+127) << 23) | (frac & KD_M8388607)
  if neg == 1 { bits = bits | (1<<31) }
  return bits
434}
435func kd_w32(b: *u8, o: i64, v: i64) -> i64 { b[o]=(v&255) as u8; b[o+1]=((v>>8)&255) as u8; b[o+2]=((v>>16)&255) as u8; b[o+3]=((v>>24)&255) as u8; return 0 }
436func kd_tri(b: *u8, off: i64, x0: i64, y0: i64, z0: i64, x1: i64, y1: i64, z1: i64, x2: i64, y2: i64, z2: i64) -> i64 {
  kd_w32(b, off, kd_encf(x0,1)); kd_w32(b, off+4, kd_encf(y0,1)); kd_w32(b, off+8, kd_encf(z0,1))
  kd_w32(b, off+12, kd_encf(x1,1)); kd_w32(b, off+16, kd_encf(y1,1)); kd_w32(b, off+20, kd_encf(z1,1))
  kd_w32(b, off+24, kd_encf(x2,1)); kd_w32(b, off+28, kd_encf(y2,1)); kd_w32(b, off+32, kd_encf(z2,1))
  var q: i64 = 36
  while q < 84 { b[off+q] = 0 as u8; q = q + 1 }
  return 0
443}
444func kd_box(b: *u8, off: i64, xlo: i64, xhi: i64, ylo: i64, yhi: i64, zlo: i64, zhi: i64) -> i64 {
  var o: i64 = off
  kd_tri(b, o, xlo,ylo,zlo, xhi,ylo,zlo, xhi,yhi,zlo); o = o + 84
  kd_tri(b, o, xlo,ylo,zlo, xhi,yhi,zlo, xlo,yhi,zlo); o = o + 84
  kd_tri(b, o, xlo,ylo,zhi, xhi,ylo,zhi, xhi,yhi,zhi); o = o + 84
  kd_tri(b, o, xlo,ylo,zhi, xhi,yhi,zhi, xlo,yhi,zhi); o = o + 84
  kd_tri(b, o, xlo,ylo,zlo, xlo,yhi,zlo, xlo,yhi,zhi); o = o + 84
  kd_tri(b, o, xlo,ylo,zlo, xlo,yhi,zhi, xlo,ylo,zhi); o = o + 84
  kd_tri(b, o, xhi,ylo,zlo, xhi,yhi,zlo, xhi,yhi,zhi); o = o + 84
  kd_tri(b, o, xhi,ylo,zlo, xhi,yhi,zhi, xhi,ylo,zhi); o = o + 84
  kd_tri(b, o, xlo,ylo,zlo, xhi,ylo,zlo, xhi,ylo,zhi); o = o + 84
  kd_tri(b, o, xlo,ylo,zlo, xhi,ylo,zhi, xlo,ylo,zhi); o = o + 84
  kd_tri(b, o, xlo,yhi,zlo, xhi,yhi,zlo, xhi,yhi,zhi); o = o + 84
  kd_tri(b, o, xlo,yhi,zhi, xhi,yhi,zlo, xlo,yhi,zhi); o = o + 84
  return 12
459}
460func kd_hdr(b: *u8, ntri: i64) -> i64 {
  b[0]=78 as u8; b[1]=88 as u8; b[2]=77 as u8; b[3]=83 as u8
  b[4]=72 as u8; b[5]=50 as u8; b[6]=0 as u8; b[7]=0 as u8
  kd_w32(b, 8, 1); kd_w32(b, 12, ntri)
  var q: i64 = 0
  while q < 16 { b[16+q] = 0 as u8; q = q + 1 }
  b[16]=115 as u8; b[17]=107 as u8; b[18]=105 as u8; b[19]=110 as u8
  kd_w32(b, 32, 0); kd_w32(b, 36, ntri)
  return 40
469}
470func kd_save(path: *u8, b: *u8, ntri: i64) -> i64 {
  var z: i64 = 0
  while z < ntri { kd_w32(b, 40 + ntri*84 + z*4, 0); z = z + 1 }
  let fd: i64 = sys_openat_wr(path, 420)
  if fd < 0 { return 0 - 1 }
  sys_write(fd, b, 40 + ntri*84 + ntri*4)
  sys_close(fd)
  return 0
478}
479func kd_fix_blob(path: *u8) -> i64 {
  let b: *u8 = sys_mmap(KD_MAGIC_65536)
  kd_hdr(b, 12)
  kd_box(b, 40, 0-150, 150, 0, KD_MAGIC_1600, 0-100, 100)
  return kd_save(path, b, 12)
484}
485func kd_fix_human(path: *u8) -> i64 {
  let b: *u8 = sys_mmap(KD_MAGIC_262144)
  var o: i64 = 40
  var n: i64 = 0
  n = n + kd_box(b, o, 0-150, 150, 700, KD_MAGIC_1350, 0-100, 100); o = o + 12*84
  n = n + kd_box(b, o, 0-450, 0-250, 1000, KD_MAGIC_1300, 0-60, 60); o = o + 12*84
  n = n + kd_box(b, o, 250, 450, 1000, KD_MAGIC_1300, 0-60, 60); o = o + 12*84
  n = n + kd_box(b, o, 0-140, 0-40, 60, 700, 0-80, 80); o = o + 12*84
  n = n + kd_box(b, o, 40, 140, 60, 700, 0-80, 80); o = o + 12*84
  n = n + kd_box(b, o, 0-60, 60, KD_MAGIC_1350, KD_MAGIC_1430, 0-60, 60); o = o + 12*84
  n = n + kd_box(b, o, 0-110, 110, KD_MAGIC_1430, KD_MAGIC_1600, 0-110, 110); o = o + 12*84
  kd_hdr(b, n)
  return kd_save(path, b, n)
498}
499// a QUADRUPED: long horizontal body (x = long axis) on 4 legs -- proves the schema frame is data
500func kd_fix_quad(path: *u8) -> i64 {
  let b: *u8 = sys_mmap(KD_MAGIC_262144)
  var o: i64 = 40
  var n: i64 = 0
  n = n + kd_box(b, o, 0-600, 600, 700, 1000, 0-200, 200); o = o + 12*84   // barrel
  n = n + kd_box(b, o, 0-560, 0-440, 0, 700, 0-180, 0-60); o = o + 12*84   // legs (4, split in z too)
  n = n + kd_box(b, o, 0-560, 0-440, 0, 700, 60, 180); o = o + 12*84
  n = n + kd_box(b, o, 440, 560, 0, 700, 0-180, 0-60); o = o + 12*84
  n = n + kd_box(b, o, 440, 560, 0, 700, 60, 180); o = o + 12*84
  n = n + kd_box(b, o, 600, 900, 900, KD_MAGIC_1100, 0-120, 120); o = o + 12*84     // head+neck forward
  kd_hdr(b, n)
  return kd_save(path, b, n)
512}
513func kd_wr(path: *u8, s: *u8) -> i64 {
  var n: i64 = 0
  while s[n] != (0 as u8) { n = n + 1 }
  let fd: i64 = sys_openat_wr(path, 420)
  if fd < 0 { return 0 - 1 }
  sys_write(fd, s, n)
  sys_close(fd)
  return 0
521}
522func kd_selftest() -> i64 {
  var fails: i64 = 0
  kd_fix_blob("/tmp/kd_blob.nxmesh" as *u8)
  kd_fix_human("/tmp/kd_human.nxmesh" as *u8)
  kd_fix_quad("/tmp/kd_quad.nxmesh" as *u8)
  kd_wr("/tmp/kd_schema.txt" as *u8, "humanoid\tstack\t1\t0\nhumanoid\tband\t550\t800\t3\t9\tarms-clear-of-torso\nhumanoid\tband\t80\t420\t2\t4\tlegs-separated\nhumanoid\tnarrow\t800\t920\t600\tneck-minimum\nquadruped\tstack\t0\t2\nquadruped\tband\t0\t1000\t2\t6\tlegs-along-length\t0\t450\nquadruped\tband\t100\t900\t1\t2\tbarrel-body\t500\t1000\n" as *u8)
  let sb: *u8 = sys_mmap(KD_SCAP)
  let sn: i64 = kd_readfile("/tmp/kd_schema.txt" as *u8, sb, KD_SCAP)
  hw("T0 blob must match NO kind:\n" as *u8)
  if kd_run("/tmp/kd_blob.nxmesh" as *u8, sb, sn, 64) == 0 { fails = fails + 1; hw("T0 FAIL blob matched a kind\n" as *u8) } else { hw("T0 PASS blob unmatched\n" as *u8) }
  hw("T1 humanoid fixture must match humanoid:\n" as *u8)
  if kd_run("/tmp/kd_human.nxmesh" as *u8, sb, sn, 64) != 0 { fails = fails + 1; hw("T1 FAIL humanoid unmatched\n" as *u8) } else { hw("T1 PASS\n" as *u8) }
  hw("T2 quadruped fixture must match quadruped (proves the FRAME is data, not code):\n" as *u8)
  if kd_run("/tmp/kd_quad.nxmesh" as *u8, sb, sn, 64) != 0 { fails = fails + 1; hw("T2 FAIL quadruped unmatched\n" as *u8) } else { hw("T2 PASS\n" as *u8) }
  hw("T3 empty schema must REFUSE (never guess an ontology):\n" as *u8)
  if kd_run("/tmp/kd_human.nxmesh" as *u8, sb, 0, 64) == 0 { fails = fails + 1; hw("T3 FAIL empty schema accepted\n" as *u8) } else { hw("T3 PASS refused\n" as *u8) }
  if fails == 0 { hw("KIND-SELFTEST GREEN 4/4\n" as *u8); return 0 }
  hw("KIND-SELFTEST RED fails=" as *u8); pn(fails); hw("\n" as *u8)
  return 1
541}
542
543func main(argc: i64, argv: *i64) -> i64 {
  if argc >= 2 {
      let a1: *u8 = argv[1] as *u8
      var m: i64 = 0
      while a1[m] != (0 as u8) { m = m + 1 }
      if m == 8 {
          var ok: i64 = 1
          let lit: *u8 = "selftest" as *u8
          var i: i64 = 0
          while i < 8 { if a1[i] != lit[i] { ok = 0; i = 8 } else { i = i + 1 } }
          if ok == 1 { let rc: i64 = kd_selftest(); sys_exit(rc); return rc }
      }
      if m == 6 {
          var ok2: i64 = 1
          let lit2: *u8 = "schema" as *u8
          var j: i64 = 0
          while j < 6 { if a1[j] != lit2[j] { ok2 = 0; j = 6 } else { j = j + 1 } }
          if ok2 == 1 {
              if argc < 4 { hw("usage: nx_kind schema <file> <mesh.nxmesh> [bands]\n" as *u8); sys_exit(2); return 2 }
              let sb2: *u8 = sys_mmap(KD_SCAP)
              let sn2: i64 = kd_readfile(argv[2] as *u8, sb2, KD_SCAP)
              var nb2: i64 = 64
              let rc2: i64 = kd_run(argv[3] as *u8, sb2, sn2, nb2)
              sys_exit(rc2)
              return rc2
          }
      }
  }
  if argc < 2 { hw("usage: nx_kind <mesh.nxmesh> [bands] | schema <file> <mesh> | selftest\n" as *u8); sys_exit(2); return 2 }
  let sb3: *u8 = sys_mmap(KD_SCAP)
  let sn3: i64 = sts_load("knowledge/store/kind-" as *u8, sb3, KD_SCAP - 16)
  var nb3: i64 = 64
  if argc >= 3 {
      let a2: *u8 = argv[2] as *u8
      nb3 = 0
      var q: i64 = 0
      while a2[q] != (0 as u8) { nb3 = nb3*10 + ((a2[q] as i64) - 48); q = q + 1 }
      if nb3 < 16 { nb3 = 16 }
      if nb3 > KD_MAXBAND { nb3 = KD_MAXBAND }
  }
  let rc3: i64 = kd_run(argv[1] as *u8, sb3, sn3, nb3)
  sys_exit(rc3)
  return rc3
586}
nx_kind.nx source

`nx_kind.nx` source
