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

↩ module page · 562 lines · 26156 B
1// nx_vacuity_census.nx -- WHICH RENDER-GATES CANNOT SEE A MISSING FEATURE AT ALL.
2//
3// THE DEFECT IT MEASURES, from a real one caught 2026-08-14. nx_wasm_craft_gate passed 58/58 while the
4// game had NO CHARACTERS IN THE PICTURE. Its mob teeth (T16/T17/T28/T29) assert the girls exist in
5// STATE; its frame teeth (T3/T19/T23) assert the frame has colour VARIETY. Both are true of a frame
6// with every character missing, because the terrain alone satisfies them. The renderer had started
7// writing one pixel per ray while mob_draw still projected into the framebuffer CEILING, so every girl
8// landed outside the written region -- and not one tooth could tell.
9//
10// THE EXACT PREDICATE, and it is a PROOF rather than a heuristic: to detect that feature X is absent
11// from a picture, a gate must hold TWO frames that differ only in X and compare them. A gate that
12// renders EXACTLY ONCE cannot do that -- there is no second frame to compare against.
13// ⚠WHAT THIS IS AND IS NOT. It is a STRONG CANDIDATE FILTER, not a proof. v1 of this header called
14// render_calls==1 a sound certificate with no false negatives; that was wrong twice over, and both
15// corrections are recorded here rather than quietly edited away:
16//   1. a call SITE is not a render -- one site inside a helper main invokes N times is N renders
17//      (nx_wasm_mineworld_gate, which v1 wrongly accused). FIXED: each site is multiplied by its
18//      enclosing function's invocation count.
19//   2. an invocation inside a LOOP is one static site but many runtime renders, and this organ does
20//      no brace matching, so such a gate still reads as 1. That is the remaining false-positive
21//      class and it is NOT fixed -- read the gate before acting on its row.
22// The converse was never claimed and still is not: a gate that renders MANY times can be just as
23// blind. nx_wasm_craft_gate rendered dozens of times and still could not see that every character
24// was missing, because it never compared two frames differing only in the characters.
25// Both directions land in the same place: this names candidates, and nx_gate_bite decides.
26//
27// WHY THIS IS TRIAGE AND NOT A SECOND RULER: nx_gate_bite mutates the SUBJECT and rebuilds it. For
28// nx_wasm_craft that is ~30 minutes per mutant, so it can never sweep a fleet. This census is static
29// and instant, and its whole job is to tell the expensive instrument where to spend. Composition,
30// not duplication -- the same reason the estate has one line-differ and many tallies.
31//
32// DECLARED IMPRECISION (so the next reader does not trust it as exact):
33//  - a gate that renders through a wrapper it defines itself counts as 0 render calls
34//  - a backslash-escaped quote inside a string literal is not tracked, so a token inside such a
35//    string could be counted as code
36//  - the token list below is the render entries this estate actually uses; a new render entry must
37//    be added here or its gates read as NOT-A-RENDER-GATE
38// license_tier: ORIGINAL
39import "nx_syscalls.nx"
40
41const VC_DIRBUF: i64 = 131072
42const VC_NAMEBUF: i64 = 4096
43const VC_MAXSHOW: i64 = 60          // printed worklist head; the COUNTS are always the full population
44const VC_CH_NL: i64 = 10
45const VC_CH_SP: i64 = 32
46const VC_CH_QUOTE: i64 = 34
47const VC_CH_SLASH: i64 = 47
48// anti-vacuity floor: this estate has thousands of gate sources. Finding almost none means the scan
49// is pointed at the wrong tree, and a census that reports a confident near-zero is worse than one
50// that refuses. Measured 2026-08-14: 2,317 gate sources estate-wide.
51const VC_MIN_GATES: i64 = 200
52// THE RATCHET. A census nobody enforces is a report, and a report is a comment. This floor only ever
53// falls: fixing a gate tightens it automatically, and a NEW render-once gate pushes the count above it
54// and goes RED with the offenders NAMED above -- a count without a worklist is not actionable.
55const VC_CONF: *u8 = "knowledge/status/vacuity.conf"
56
57func vc_puts(s: *u8) -> i64 { var n: i64 = 0; while s[n] != (0 as u8) { n = n + 1 } sys_write(1, s, n); return 0 }
58func vc_num(v: i64) -> i64 {
  if v == 0 { vc_puts("0" as *u8); return 0 }
  var x: i64 = v
  var neg: i64 = 0
  if x < 0 { neg = 1; x = 0 - x }
  let d: *u8 = sys_mmap(32)
  var k: i64 = 0
  while x > 0 { d[k] = (48 + (x % 10)) as u8; x = x / 10; k = k + 1 }
  let o: *u8 = sys_mmap(34)
  var w: i64 = 0
  if neg == 1 { o[0] = 45 as u8; w = 1 }
  var j: i64 = 0
  while j < k { o[w+j] = d[k-1-j]; j = j + 1 }
  sys_write(1, o, w + k)
  return 0
73}
74
75// name ends with "_gate.nx"
76func vc_is_gate(nm: *u8) -> i64 {
  var n: i64 = 0
  while nm[n] != (0 as u8) { n = n + 1 }
  if n < 9 { return 0 }
  let s: i64 = n - 8
  if nm[s] != (95 as u8) { return 0 }
  if nm[s+1] != (103 as u8) { return 0 }
  if nm[s+2] != (97 as u8) { return 0 }
  if nm[s+3] != (116 as u8) { return 0 }
  if nm[s+4] != (101 as u8) { return 0 }
  if nm[s+5] != (46 as u8) { return 0 }
  if nm[s+6] != (110 as u8) { return 0 }
  if nm[s+7] != (120 as u8) { return 0 }
  return 1
90}
91
92func vc_match(b: *u8, n: i64, p: i64, t: *u8) -> i64 {
  var i: i64 = 0
  var ok: i64 = 1
  var go: i64 = 1
  while go == 1 {
      if t[i] == (0 as u8) { go = 0 } else {
          if p + i >= n { ok = 0; go = 0 } else {
              if b[p+i] != t[i] { ok = 0; go = 0 } else { i = i + 1 }
          }
      }
  }
  return ok
104}
105
106// a definition ("func render_impl(") is NOT a call site. Without this the engine's own source, and any
107// gate that re-declares a helper, would be counted as if it rendered.
108func vc_after_func(b: *u8, p: i64) -> i64 {
  var q: i64 = p - 1
  var stop: i64 = 0
  while stop == 0 {
      if q < 0 { stop = 1 } else {
          if b[q] == (VC_CH_SP as u8) { q = q - 1 } else { stop = 1 }
      }
  }
  if q < 3 { return 0 }
  if b[q] != (99 as u8) { return 0 }
  if b[q-1] != (110 as u8) { return 0 }
  if b[q-2] != (117 as u8) { return 0 }
  if b[q-3] != (102 as u8) { return 0 }
  return 1
122}
123
124const VC_MAXFN: i64 = 1024
125static VC_FNS: i64
126static VC_FNL: i64
127static VC_FBS: i64
128// allocated ONCE, never in the per-file loop: 3 tables x 1024 x 8 B re-mmap'd across 3,217 files
129// would be 77 MB of churn to answer a question that needs 24 KB.
130func vc_tables() -> i64 {
  if VC_FNS == 0 {
      VC_FNS = sys_mmap(VC_MAXFN*8) as i64
      VC_FNL = sys_mmap(VC_MAXFN*8) as i64
      VC_FBS = sys_mmap(VC_MAXFN*8) as i64
  }
  return 0
137}
138
139func vc_name_end(b: *u8, n: i64, s: i64) -> i64 {
  var q: i64 = s
  var stop: i64 = 0
  while stop == 0 {
      if q >= n { stop = 1 } else {
          let c: i64 = b[q] as i64
          if c == 40 { stop = 1 } else { if c == VC_CH_SP { stop = 1 } else { if c == VC_CH_NL { stop = 1 } else { q = q + 1 } } }
      }
  }
  return q
149}
150
151func vc_eq(b: *u8, a: i64, alen: i64, p: i64, n: i64) -> i64 {
  if p + alen > n { return 0 }
  var i: i64 = 0
  var ok: i64 = 1
  while i < alen { if b[p+i] != b[a+i] { ok = 0; i = alen } else { i = i + 1 } }
  return ok
157}
158
159func vc_isword(c: i64) -> i64 {
  if c == 95 { return 1 }
  if c >= 48 { if c <= 57 { return 1 } }
  if c >= 65 { if c <= 90 { return 1 } }
  if c >= 97 { if c <= 122 { return 1 } }
  return 0
165}
166
167// how many times is this function INVOKED. A name followed by '(' that is not its own definition and
168// not the tail of a longer identifier.
169func vc_invocations(b: *u8, n: i64, a: i64, alen: i64) -> i64 {
  var cnt: i64 = 0
  var p: i64 = 0
  var incom: i64 = 0
  var instr: i64 = 0
  while p < n {
      let c: i64 = b[p] as i64
      if c == VC_CH_NL { incom = 0; instr = 0 }
      if incom == 0 {
          if instr == 1 {
              if c == VC_CH_QUOTE { instr = 0 }
          } else {
              if c == VC_CH_QUOTE { instr = 1 } else {
                  var isc: i64 = 0
                  if c == VC_CH_SLASH { if p + 1 < n { if b[p+1] == (VC_CH_SLASH as u8) { isc = 1 } } }
                  if isc == 1 { incom = 1 } else {
                      if vc_eq(b, a, alen, p, n) == 1 {
                          if p + alen < n {
                              if b[p+alen] == (40 as u8) {
                                  var okpre: i64 = 1
                                  if p > 0 { if vc_isword(b[p-1] as i64) == 1 { okpre = 0 } }
                                  if okpre == 1 { if vc_after_func(b, p) == 0 { cnt = cnt + 1 } }
                              }
                          }
                      }
                  }
              }
          }
      }
      p = p + 1
  }
  return cnt
201}
202
203func vc_is_main(b: *u8, a: i64, alen: i64) -> i64 {
  if alen != 4 { return 0 }
  if b[a] != (109 as u8) { return 0 }
  if b[a+1] != (97 as u8) { return 0 }
  if b[a+2] != (105 as u8) { return 0 }
  if b[a+3] != (110 as u8) { return 0 }
  return 1
210}
211
212// out[0] = EFFECTIVE render count, out[1] = framebuffer reads
213// ★CORRECTED AFTER A FALSE POSITIVE, 2026-08-14. v1 counted render CALL SITES and called
214// render_calls==1 a SOUND certificate. nx_wasm_mineworld_gate refuted that within the hour: it has
215// exactly ONE call site, sitting inside a helper rend() that main invokes many times, and it does
216// genuinely difference frames (checksum compare, far vs spawn). A CALL SITE IS NOT A RENDER.
217// This version attributes every render site to its enclosing function and multiplies by how many
218// times that function is invoked; a render written directly in main counts once.
219// Comments and string literals are excluded throughout -- a scanner that does not skip comments
220// measures the documentation, and this organ hunts a defect whose description contains its own
221// pattern, so an unstripped scan would accuse its own header.
222func vc_scan_buf(b: *u8, n: i64, out: *i64) -> i64 {
  out[0] = 0
  out[1] = 0
  vc_tables()
  let fns: *i64 = VC_FNS as *i64
  let fnl: *i64 = VC_FNL as *i64
  let fbs: *i64 = VC_FBS as *i64
  var nf: i64 = 0
  var p: i64 = 0
  var incom: i64 = 0
  var instr: i64 = 0
  while p < n {
      let c: i64 = b[p] as i64
      if c == VC_CH_NL { incom = 0; instr = 0 }
      if incom == 0 {
          if instr == 1 {
              if c == VC_CH_QUOTE { instr = 0 }
          } else {
              if c == VC_CH_QUOTE { instr = 1 } else {
                  var isc: i64 = 0
                  if c == VC_CH_SLASH { if p + 1 < n { if b[p+1] == (VC_CH_SLASH as u8) { isc = 1 } } }
                  if isc == 1 { incom = 1 } else {
                      var atl: i64 = 0
                      if p == 0 { atl = 1 } else { if b[p-1] == (VC_CH_NL as u8) { atl = 1 } }
                      if atl == 1 {
                          if vc_match(b, n, p, "func " as *u8) == 1 {
                              if nf < VC_MAXFN {
                                  let s: i64 = p + 5
                                  fns[nf] = s
                                  fnl[nf] = vc_name_end(b, n, s) - s
                                  fbs[nf] = p
                                  nf = nf + 1
                              }
                          }
                      }
                  }
              }
          }
      }
      p = p + 1
  }
  p = 0
  incom = 0
  instr = 0
  while p < n {
      let c2: i64 = b[p] as i64
      if c2 == VC_CH_NL { incom = 0; instr = 0 }
      if incom == 0 {
          if instr == 1 {
              if c2 == VC_CH_QUOTE { instr = 0 }
          } else {
              if c2 == VC_CH_QUOTE { instr = 1 } else {
                  var isc2: i64 = 0
                  if c2 == VC_CH_SLASH { if p + 1 < n { if b[p+1] == (VC_CH_SLASH as u8) { isc2 = 1 } } }
                  if isc2 == 1 { incom = 1 } else {
                      var hit: i64 = 0
                      if vc_match(b, n, p, "render_impl(" as *u8) == 1 { hit = 1 }
                      if vc_match(b, n, p, "trimesh_render(" as *u8) == 1 { hit = 1 }
                      if vc_match(b, n, p, "trimesh_render_aa(" as *u8) == 1 { hit = 1 }
                      if vc_match(b, n, p, "render_at(" as *u8) == 1 { hit = 1 }
                      if hit == 1 { if vc_after_func(b, p) == 0 {
                          var k: i64 = 0
                          var enc: i64 = 0 - 1
                          while k < nf { if fbs[k] <= p { enc = k } k = k + 1 }
                          var mult: i64 = 1
                          if enc >= 0 { if vc_is_main(b, fns[enc], fnl[enc]) == 0 {
                              mult = vc_invocations(b, n, fns[enc], fnl[enc])
                              if mult < 1 { mult = 1 }
                          } }
                          out[0] = out[0] + mult
                      } }
                      if vc_match(b, n, p, "wfb(" as *u8) == 1 { if vc_after_func(b, p) == 0 { out[1] = out[1] + 1 } }
                  }
              }
          }
      }
      p = p + 1
  }
  return 0
301}
302
303// sys_read_file sizes its buffer FROM THE FILE, so there is no cap to guess and no silent short read
304func vc_scan_file(path: *u8, out: *i64) -> i64 {
  let lp: *i64 = sys_mmap(16) as *i64
  let b: *u8 = sys_read_file(path, lp)
  if (b as i64) == 0 { return 0 }
  vc_scan_buf(b, lp[0], out)
  return 1
310}
311
312// tallies[0]=gate files  [1]=not-a-render-gate  [2]=RENDER-ONCE  [3]=RENDER-MULTI
313func vc_scan_dir(dir: *u8, nbuf: *u8, out: *i64, tal: *i64, shown: *i64) -> i64 {
  let fd: i64 = sys_openat_rd(dir)
  if fd < 0 { return 0 }
  let dbuf: *u8 = sys_mmap(VC_DIRBUF)
  var go: i64 = 1
  while go == 1 {
      let nb: i64 = sys_getdents64(fd, dbuf, VC_DIRBUF)
      if nb <= 0 { go = 0 } else {
          var off: i64 = 0
          while off < nb {
              let rec: *u8 = ((dbuf as i64) + off) as *u8
              let rl: i64 = dirent_reclen(rec)
              if rl <= 0 { off = nb } else {
                  let nm: *u8 = dirent_name(rec)
                  if vc_is_gate(nm) == 1 {
                      var c: i64 = 0
                      while dir[c] != (0 as u8) { nbuf[c] = dir[c]; c = c + 1 }
                      nbuf[c] = 47 as u8
                      c = c + 1
                      var d: i64 = 0
                      while nm[d] != (0 as u8) { nbuf[c+d] = nm[d]; d = d + 1 }
                      nbuf[c+d] = 0 as u8
                      if vc_scan_file(nbuf, out) == 1 {
                          tal[0] = tal[0] + 1
                          if out[0] == 0 {
                              tal[1] = tal[1] + 1
                          } else {
                              if out[0] == 1 {
                                  tal[2] = tal[2] + 1
                                  if shown[0] < VC_MAXSHOW {
                                      vc_puts("  CANNOT-SEE-AN-ABSENT-FEATURE " as *u8); vc_puts(nbuf)
                                      vc_puts(" renders=1 fb_reads=" as *u8); vc_num(out[1])
                                      vc_puts("\n" as *u8)
                                      shown[0] = shown[0] + 1
                                  }
                              } else {
                                  tal[3] = tal[3] + 1
                              }
                          }
                      }
                  }
                  off = off + rl
              }
          }
      }
  }
  sys_close(fd)
  sys_munmap(dbuf, VC_DIRBUF)
  return 0
362}
363
364func vc_write_fixture(path: *u8, body: *u8) -> i64 {
  var n: i64 = 0
  while body[n] != (0 as u8) { n = n + 1 }
  let fd: i64 = sys_openat_wr(path, MODE_0644)
  if fd < 0 { return 0 }
  sys_write(fd, body, n)
  sys_close(fd)
  return 1
372}
373
374// A DETECTOR THAT HAS ONLY EVER AGREED WITH ME IS UNVERIFIED. Each fixture below is a trap this
375// estate has actually fallen into: a comment that contains the pattern, and a DEFINITION mistaken
376// for a call. Both must read ZERO, or the census would accuse every engine source of rendering.
377func vc_selftest() -> i64 {
  sys_mkdir("/tmp/nx_vacuity_census" as *u8, MODE_0755)
  let out: *i64 = sys_mmap(64) as *i64
  var pass: i64 = 0
  var total: i64 = 0
382
  vc_write_fixture("/tmp/nx_vacuity_census/one.nx" as *u8, "func main() -> i64 { render_impl(0); return 0 }\n" as *u8)
  vc_scan_file("/tmp/nx_vacuity_census/one.nx" as *u8, out)
  total = total + 1
  vc_puts("  T1 a single render call reads renders=1 got=" as *u8); vc_num(out[0])
  if out[0] == 1 { pass = pass + 1; vc_puts(" PASS\n" as *u8) } else { vc_puts(" FAIL\n" as *u8) }
388
  vc_write_fixture("/tmp/nx_vacuity_census/two.nx" as *u8, "func main() -> i64 { render_impl(0); render_impl(1); return 0 }\n" as *u8)
  vc_scan_file("/tmp/nx_vacuity_census/two.nx" as *u8, out)
  total = total + 1
  vc_puts("  T2 two render calls read renders=2 got=" as *u8); vc_num(out[0])
  if out[0] == 2 { pass = pass + 1; vc_puts(" PASS\n" as *u8) } else { vc_puts(" FAIL\n" as *u8) }
394
  vc_write_fixture("/tmp/nx_vacuity_census/com.nx" as *u8, "func main() -> i64 { return 0 }\n// render_impl(0) named in prose only\n" as *u8)
  vc_scan_file("/tmp/nx_vacuity_census/com.nx" as *u8, out)
  total = total + 1
  vc_puts("  T3 neg-control-comment a render call inside a comment reads 0 got=" as *u8); vc_num(out[0])
  if out[0] == 0 { pass = pass + 1; vc_puts(" PASS\n" as *u8) } else { vc_puts(" FAIL\n" as *u8) }
400
  vc_write_fixture("/tmp/nx_vacuity_census/def.nx" as *u8, "func render_impl(base: i64) -> i64 { return 0 }\n" as *u8)
  vc_scan_file("/tmp/nx_vacuity_census/def.nx" as *u8, out)
  total = total + 1
  vc_puts("  T4 neg-control-definition a DEFINITION is not a call, reads 0 got=" as *u8); vc_num(out[0])
  if out[0] == 0 { pass = pass + 1; vc_puts(" PASS\n" as *u8) } else { vc_puts(" FAIL\n" as *u8) }
406
  // T5 neg-control-string: a render token inside a STRING LITERAL must read 0. The fixture is
  // ASSEMBLED BYTE-WISE, quotes injected as byte 34, so it tests THE SCANNER rather than this
  // compiler's escape convention -- and so that this source does not itself contain the pattern.
  let sb: *u8 = sys_mmap(256)
  var w5: i64 = 0
  let pre5: *u8 = "func main() -> i64 { vc_puts(" as *u8
  var q5: i64 = 0
  while pre5[q5] != (0 as u8) { sb[w5] = pre5[q5]; w5 = w5 + 1; q5 = q5 + 1 }
  sb[w5] = VC_CH_QUOTE as u8
  w5 = w5 + 1
  let mid5: *u8 = "render_impl( sitting inside a string" as *u8
  q5 = 0
  while mid5[q5] != (0 as u8) { sb[w5] = mid5[q5]; w5 = w5 + 1; q5 = q5 + 1 }
  sb[w5] = VC_CH_QUOTE as u8
  w5 = w5 + 1
  let post5: *u8 = " as *u8); return 0 }\n" as *u8
  q5 = 0
  while post5[q5] != (0 as u8) { sb[w5] = post5[q5]; w5 = w5 + 1; q5 = q5 + 1 }
  sb[w5] = 0 as u8
  vc_write_fixture("/tmp/nx_vacuity_census/str.nx" as *u8, sb)
  vc_scan_file("/tmp/nx_vacuity_census/str.nx" as *u8, out)
  total = total + 1
  vc_puts("  T5 neg-control-string a render token inside a STRING reads 0 got=" as *u8); vc_num(out[0])
  if out[0] == 0 { pass = pass + 1; vc_puts(" PASS\n" as *u8) } else { vc_puts(" FAIL\n" as *u8) }
431
  // T6 THE CASE THAT REFUTED v1. One render CALL SITE inside a helper that main invokes twice is
  // TWO renders. nx_wasm_mineworld_gate is exactly this shape and v1 accused it of being unable to
  // difference frames while it was doing so on every run. A regression here revives that false
  // positive, which is the worst kind: it sends the expensive instrument at an innocent gate.
  vc_write_fixture("/tmp/nx_vacuity_census/helper.nx" as *u8, "func rend(b: i64) -> i64 { render_impl(b); return 0 }\nfunc main() -> i64 { rend(0); rend(1); return 0 }\n" as *u8)
  vc_scan_file("/tmp/nx_vacuity_census/helper.nx" as *u8, out)
  total = total + 1
  vc_puts("  T6 one render site in a helper invoked twice counts as 2 got=" as *u8); vc_num(out[0])
  if out[0] == 2 { pass = pass + 1; vc_puts(" PASS\n" as *u8) } else { vc_puts(" FAIL\n" as *u8) }
441
  // T7 and the other direction: a helper invoked ONCE is still one render, so the correction did
  // not simply inflate every count until nothing is ever flagged.
  vc_write_fixture("/tmp/nx_vacuity_census/helper1.nx" as *u8, "func rend(b: i64) -> i64 { render_impl(b); return 0 }\nfunc main() -> i64 { rend(0); return 0 }\n" as *u8)
  vc_scan_file("/tmp/nx_vacuity_census/helper1.nx" as *u8, out)
  total = total + 1
  vc_puts("  T7 neg-control-helper-once a helper invoked once is still 1 got=" as *u8); vc_num(out[0])
  if out[0] == 1 { pass = pass + 1; vc_puts(" PASS\n" as *u8) } else { vc_puts(" FAIL\n" as *u8) }
449
  vc_puts("NX-VACUITY-CENSUS selftest passed " as *u8); vc_num(pass); vc_puts("/" as *u8); vc_num(total)
  if pass == total { vc_puts(" verdict=GREEN\n" as *u8); return 0 }
  vc_puts(" verdict=RED\n" as *u8)
  return 1
454}
455
456func vc_read_floor() -> i64 {
  let lp: *i64 = sys_mmap(16) as *i64
  let b: *u8 = sys_read_file(VC_CONF, lp)
  if (b as i64) == 0 { return 0 - 1 }
  var i: i64 = 0
  var v: i64 = 0
  var seen: i64 = 0
  while i < lp[0] {
      let c: i64 = b[i] as i64
      if c >= 48 { if c <= 57 { v = v*10 + (c - 48); seen = 1 } }
      i = i + 1
  }
  if seen == 0 { return 0 - 1 }
  return v
470}
471
472func vc_write_floor(v: i64) -> i64 {
  let fd: i64 = sys_openat_wr(VC_CONF, MODE_0644)
  if fd < 0 { return 0 }
  let d: *u8 = sys_mmap(32)
  var x: i64 = v
  var k: i64 = 0
  if x == 0 { d[0] = 48 as u8; k = 1 } else {
      while x > 0 { d[k] = (48 + (x % 10)) as u8; x = x / 10; k = k + 1 }
  }
  let o: *u8 = sys_mmap(34)
  var j: i64 = 0
  while j < k { o[j] = d[k-1-j]; j = j + 1 }
  o[k] = VC_CH_NL as u8
  sys_write(fd, o, k + 1)
  sys_close(fd)
  return 1
488}
489
490func main(argc: i64, argv: *i64) -> i64 {
  if argc > 1 {
      let a1: *u8 = argv[1] as *u8
      if a1[0] == (115 as u8) { return vc_selftest() }
  }
  let out: *i64 = sys_mmap(64) as *i64
  let tal: *i64 = sys_mmap(64) as *i64
  let shown: *i64 = sys_mmap(16) as *i64
  var z: i64 = 0
  while z < 8 { tal[z] = 0; z = z + 1 }
  shown[0] = 0
  let nbuf: *u8 = sys_mmap(VC_NAMEBUF)
502
  vc_puts("nx_vacuity_census -- render-gates that CANNOT detect a feature missing from the picture\n\n" as *u8)
  vc_scan_dir("buildroot/runtime/_hdl_build" as *u8, nbuf, out, tal, shown)
  vc_scan_dir("buildroot/runtime" as *u8, nbuf, out, tal, shown)
506
  vc_puts("\n  gate_sources=" as *u8); vc_num(tal[0])
  vc_puts(" not_a_render_gate=" as *u8); vc_num(tal[1])
  vc_puts(" RENDER_ONCE=" as *u8); vc_num(tal[2])
  vc_puts(" render_multi=" as *u8); vc_num(tal[3])
  let sum: i64 = tal[1] + tal[2] + tal[3]
  vc_puts("\n  partition sum=" as *u8); vc_num(sum)
  vc_puts(" of gate_sources=" as *u8); vc_num(tal[0])
  if sum == tal[0] { vc_puts(" RECONCILES\n" as *u8) } else { vc_puts(" LEAKS -- do not trust these numbers\n" as *u8) }
  if shown[0] >= VC_MAXSHOW {
      vc_puts("  worklist head shown=" as *u8); vc_num(shown[0])
      vc_puts(" of RENDER_ONCE=" as *u8); vc_num(tal[2])
      vc_puts(" -- the COUNT is the full population, the LIST is its head\n" as *u8)
  }
  if tal[0] < VC_MIN_GATES {
      vc_puts("\nREFUSING: only " as *u8); vc_num(tal[0])
      vc_puts(" gate sources found, below the floor of " as *u8); vc_num(VC_MIN_GATES)
      vc_puts(". A census pointed at the wrong tree reports a confident near-zero; that is worse than refusing.\nverdict=UNPROVEN\n" as *u8)
      return 3
  }
  let floor: i64 = vc_read_floor()
  if floor < 0 {
      vc_write_floor(tal[2])
      vc_puts("\n  ratchet SEEDED at " as *u8); vc_num(tal[2])
      vc_puts(" -- first run, nothing to compare against yet\n" as *u8)
  } else {
      vc_puts("\n  ratchet floor=" as *u8); vc_num(floor)
      vc_puts(" now=" as *u8); vc_num(tal[2])
      if tal[2] > floor {
          vc_puts(" ROSE -- a render-gate that cannot see an absent feature was ADDED. The offenders are\n" as *u8)
          vc_puts("  named above; give the new one a second frame to compare against.\nverdict=RED\n" as *u8)
          return 1
      }
      if tal[2] < floor {
          vc_write_floor(tal[2])
          vc_puts(" FELL -- ratchet tightened to the new value\n" as *u8)
      } else {
          vc_puts(" HELD\n" as *u8)
      }
  }
  vc_puts("\n  RENDER_ONCE is a CANDIDATE FILTER, not a proof. One static render means there is no second\n" as *u8)
  vc_puts("  frame to compare against, so such a gate very likely cannot tell a picture with the feature\n" as *u8)
  vc_puts("  from one without it -- but an invocation inside a LOOP is one static site and many runtime\n" as *u8)
  vc_puts("  renders, and this organ does no brace matching. READ THE GATE before acting on its row.\n" as *u8)
  vc_puts("  The converse is NOT claimed: rendering many times buys nothing on its own. nx_wasm_craft_gate\n" as *u8)
  vc_puts("  rendered dozens of times and still could not see that every character was missing.\n" as *u8)
  vc_puts("  nx_gate_bite is the ruler that decides; this only tells it where to spend.\n" as *u8)
  vc_puts("\n  ⚠THIS COUNT DOES NOT MEASURE WHETHER THE LISTED GATES HAVE BEEN FIXED. There are two valid\n" as *u8)
  vc_puts("  remedies and this metric only sees one. Adding a SECOND RENDER (re-render with the feature\n" as *u8)
  vc_puts("  removed, compare frames) moves a gate off this list. Comparing TWO SAMPLES WITHIN ONE FRAME\n" as *u8)
  vc_puts("  -- the usual remedy for a sprite-presence tooth, e.g. 'this pixel differs from the\n" as *u8)
  vc_puts("  background two tiles over' -- is equally sound and leaves the gate rendering once, so it\n" as *u8)
  vc_puts("  STAYS LISTED. On 2026-08-14 five listed gates were fixed that way and remain on this list.\n" as *u8)
  vc_puts("  Read the ratchet as a guard against NEW render-once gates, never as a fix-progress bar.\n" as *u8)
  vc_puts("verdict=GREEN\n" as *u8)
  return 0
562}
nx_vacuity_census.nx source

`nx_vacuity_census.nx` source
