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

↩ module page · 1774 lines · 74070 B
1// nx_undefscan.nx -- THE MISSING-SYMBOL CENSUS: report EVERY function a target calls that nobody in its
2// import closure defines, WITHOUT compiling it.
3//
4// WHY THIS EXISTS. The compiler reports undefined symbols ONE AT A TIME, and only AFTER expand_imports
5// succeeds -- so a single mis-layered import hides an unknown number of missing functions behind it, and
6// the outer explanation (bad import) is always true enough to stop the investigation. Measured
7// 2026-07-31: un-darkening 14 libs exposed SEVEN undefined functions no build could ever have reported --
8// nx_pctl_kill_by_cmdline (2 callers), the whole nx_fft decomposed API (4 consumers), nx_bm25_score
9// (5 callers). Each fix revealed the next, so the count was never knowable in advance. This organ makes
10// it knowable in ONE pass: walk the closure, collect every definition, collect every call site, print
11// the DIFFERENCE AS A LIST rather than as the first error.
12//
13// WHAT IT IS NOT. A textual resolver, not the compiler. Two known ways it can be wrong, stated here so a
14// caller never has to guess:
15//   - a call THROUGH A FUNCTION-POINTER VARIABLE looks like an undefined call (false positive)
16//   - a symbol the compiler itself provides, if any exist, has no .nx definition (false positive)
17// Both are bounded by the POSITIVE CONTROL: a target that BUILDS must report ZERO. Any residue on a
18// building target IS that false-positive set, and must be fixed here rather than explained away.
19//
20// PARTIAL IS NOT A SMALLER CLEAN (the 07-31 layerscan law, built in as a tooth). If any import in the
21// closure resolves to no file, or the queue overflows, the definition set is INCOMPLETE -- so every
22// undefined it prints may merely be defined in the file it could not read. In that state the verdict is
23// PARTIAL and a ZERO count exits NONZERO, because a clean report from a truncated scan is the exact lie
24// this class of instrument keeps telling.
25//
26//   nx_undefscan scan <target> -- target = basename WITHOUT .nx, resolved runtime/ then _hdl_build/
27// EXIT: 0 CLEAN+COMPLETE - 1 UNDEFINED FOUND - 2 usage - 3 target not found - 5 PARTIAL (cannot certify)
28// license_tier: ORIGINAL   No hw writes (Rule 26).   expect_exit: 0
29import "nx_syscalls.nx"
30
31const US_MAXF:      i64 = 512
32const US_NAMELEN:   i64 = 64
33const US_SLOTS:     i64 = 32768
34const US_PATHBUF:   i64 = 1024
35const US_RTDIR:     *u8 = "buildroot/runtime" as *u8
36const US_HDDIR:     *u8 = "buildroot/runtime/_hdl_build" as *u8
37const US_HUBDIR:    *u8 = "buildroot/runtime/hub" as *u8
38const US_WIKIDIR:   *u8 = "buildroot/runtime/wiki" as *u8
39
40// RESOLVE AN IMPORT THE WAY nx_cc DOES, not the way I assumed. Measured 2026-07-31: I searched only
41// runtime/ and _hdl_build/ and reported MISSING-IMPORT nx_search_query_parser for a file that lives in
42// runtime/hub/. The compiler resolved it fine -- proven because nx_search_snippet_extract failed with
43// `UNDEFINED label: main` (a no-main library built standalone) rather than an expand_imports error, and
44// expand_imports runs FIRST. An under-searching resolver manufactures both false MISSING-IMPORTs and
45// false NOWHEREs, and a false NOWHERE is the one that gets someone to WRITE CODE THAT ALREADY EXISTS.
46// _retired/ is deliberately excluded: code there is not meant to be importable.
47func us_resolve(path: *u8, nm: *u8) -> i64 {
  us_path(path, US_RTDIR, nm)
  if us_exists(path) == 1 { return 1 }
  us_path(path, US_HDDIR, nm)
  if us_exists(path) == 1 { return 1 }
  us_path(path, US_HUBDIR, nm)
  if us_exists(path) == 1 { return 1 }
  us_path(path, US_WIKIDIR, nm)
  if us_exists(path) == 1 { return 1 }
  return 0
57}
58
59// PER-IMPORTER RESOLUTION -- THE RULE THE COMPILER ACTUALLY USES.
60// us_resolve above takes only a NAME and probes ONE fixed global order, so for a name that exists in more
61// than one probe directory it always returns the same copy no matter who imported it. nx_cc does not work
62// that way: AN IMPORT BINDS THE IMPORTER'S OWN DIRECTORY FIRST.
63// Measured 2026-07-31: nx_m2d_engine lives in _hdl_build/ and is written against
64// _hdl_build/nx_input_abstract.nx (ia_init/2, ia_bind/4). The fixed order handed it
65// runtime/nx_input_abstract.nx (ia_init/1, ia_bind/3) -- a DIFFERENT API wearing the same names -- and the
66// arity pass reported EIGHTEEN mismatches that were not defects. The closure was also one file too big:
67// it had pulled in a file the compiler never binds.
68// THE DAMAGE IS NOT LIMITED TO ARITY. A wrong binding is a wrong DEFINITION SET, so undefined-symbol
69// verdicts go wrong in BOTH directions -- a false CLEAN when the wrong file happens to declare the name,
70// and a false UNDEFINED when it does not. That is why this is fixed at the resolver rather than per-pass.
71// Fallback order is BUILD-TARGET probe rank (_hdl_build first): that is the copy /api/build compiles, so
72// a closure read in that order is the closure the artifact was actually produced from.
73func us_dirp(id: i64) -> *u8 {
  if id == 0 { return US_HDDIR }
  if id == 1 { return US_RTDIR }
  if id == 2 { return US_HUBDIR }
  if id == 3 { return US_WIKIDIR }
  return "" as *u8
79}
80
81// Returns the dir id that won, or 0-1 if no probe directory has the file. prefid<0 means "no importer",
82// which is the ROOT target -- it takes probe rank alone.
83func us_resolve_dir(path: *u8, nm: *u8, prefid: i64) -> i64 {
  if prefid >= 0 {
      us_path(path, us_dirp(prefid), nm)
      if us_exists(path) == 1 { return prefid }
  }
  var i: i64 = 0
  while i < 4 {
      us_path(path, us_dirp(i), nm)
      if us_exists(path) == 1 { return i }
      i = i + 1
  }
  return 0 - 1
95}
96const US_FNV_OFF:   i64 = 1469598103934665603
97const US_FNV_PRIME: i64 = 1099511628211
98const US_EXIT_UNDEF:    i64 = 1
99const US_EXIT_USAGE:    i64 = 2
100const US_EXIT_NOTFOUND: i64 = 3
101const US_EXIT_PARTIAL:  i64 = 5
102const US_EXIT_SELFTEST: i64 = 4
103const US_BICONF:    *u8 = "knowledge/undefscan_builtins.conf" as *u8
104const US_UNDEFCAP:  i64 = 256
105const US_DIRBUF:    i64 = 1048576
106
107// UNDEFINED IN THIS CLOSURE IS NOT THE SAME CLAIM AS DOES NOT EXIST, and the two have OPPOSITE remedies:
108// a symbol defined elsewhere in the corpus is a MISSING IMPORT (one line); a symbol defined nowhere is
109// UNWRITTEN CODE (a module). Measured 2026-07-31: nx_search_neutrality_gate reported 7 undefined names,
110// and I read that as one absent inverted-index module and filed it sev-8. SIX of the seven were already
111// in runtime/nx_search_inverted.nx with ~25 other consumers -- pure wiring -- and only nx_bm25_tf was
112// genuinely absent. A careful reader got it wrong from the bare list, so the LIST IS NOT THE ANSWER.
113// `corpus` mode resolves each undefined name against both source trees and names the defining file.
114
115func us_puts(s: *u8) {
  var n: i64 = 0
  while s[n] != (0 as u8) { n = n + 1 }
  sys_write(1, s, n)
119}
120
121func us_putn(p: *u8, n: i64) { sys_write(1, p, n) }
122
123func us_puti(x: i64) {
  let buf: *u8 = sys_mmap(64)
  var v: i64 = x
  var neg: i64 = 0
  if v < 0 { neg = 1; v = 0 - v }
  var i: i64 = 40
  if v == 0 { i = i - 1; buf[i] = 48 as u8 }
  while v > 0 {
      let d: i64 = v - (v / 10) * 10
      i = i - 1
      buf[i] = (d + 48) as u8
      v = v / 10
  }
  if neg == 1 { i = i - 1; buf[i] = 45 as u8 }
  sys_write(1, ((buf as i64) + i) as *u8, 40 - i)
138}
139
140func us_isidst(c: i64) -> i64 {
  if c == 95 { return 1 }
  if c >= 97 { if c <= 122 { return 1 } }
  if c >= 65 { if c <= 90 { return 1 } }
  return 0
145}
146
147func us_isidc(c: i64) -> i64 {
  if us_isidst(c) == 1 { return 1 }
  if c >= 48 { if c <= 57 { return 1 } }
  return 0
151}
152
153func us_eqlit(p: *u8, L: i64, lit: *u8, litlen: i64) -> i64 {
  if L != litlen { return 0 }
  var i: i64 = 0
  while i < L {
      if p[i] != lit[i] { return 0 }
      i = i + 1
  }
  return 1
161}
162
163// Idents that can legally sit immediately before ( without being a call. Kept explicit rather than
164// inferred: a keyword silently treated as a call would be reported as a missing function forever.
165func us_iskw(p: *u8, L: i64) -> i64 {
  if us_eqlit(p, L, "if" as *u8, 2) == 1 { return 1 }
  if us_eqlit(p, L, "while" as *u8, 5) == 1 { return 1 }
  if us_eqlit(p, L, "return" as *u8, 6) == 1 { return 1 }
  if us_eqlit(p, L, "else" as *u8, 4) == 1 { return 1 }
  if us_eqlit(p, L, "let" as *u8, 3) == 1 { return 1 }
  if us_eqlit(p, L, "var" as *u8, 3) == 1 { return 1 }
  if us_eqlit(p, L, "const" as *u8, 5) == 1 { return 1 }
  if us_eqlit(p, L, "func" as *u8, 4) == 1 { return 1 }
  if us_eqlit(p, L, "import" as *u8, 6) == 1 { return 1 }
  if us_eqlit(p, L, "struct" as *u8, 6) == 1 { return 1 }
  if us_eqlit(p, L, "for" as *u8, 3) == 1 { return 1 }
  if us_eqlit(p, L, "break" as *u8, 5) == 1 { return 1 }
  if us_eqlit(p, L, "continue" as *u8, 8) == 1 { return 1 }
  if us_eqlit(p, L, "as" as *u8, 2) == 1 { return 1 }
  if us_eqlit(p, L, "static" as *u8, 6) == 1 { return 1 }
  return 0
182}
183
184// A `__`-prefixed identifier that nothing declares is a COMPILER INTRINSIC by naming convention.
185//
186// WHY A RULE AND NOT A LIST: I appended to undefscan_builtins.conf three separate times -- __syscall,
187// then six bit intrinsics, then seven x86 crypto ones -- and the sweep immediately turned up seven more
188// (atomics, __thread_clone, __i16x16_madd) plus __f32_mul/__f32_add. Each batch was verified the same
189// way and each time the list was still incomplete. The corpus convention is absolute: NO .nx file in
190// 19,981 sources declares a `__` name, so the prefix IS the classifier. A rule nothing has to remember
191// beats a list somebody must maintain.
192//
193// THIS DOES NOT HIDE ANYTHING. Presumed intrinsics are counted and printed as their own number, never
194// folded into `undefined` and never silently dropped. And a `__` name that IS declared somewhere in the
195// closure never reaches here -- it resolves as a normal definition.
196func us_is_dunder(p: *u8) -> i64 {
  if p[0] != (95 as u8) { return 0 }
  if p[1] != (95 as u8) { return 0 }
  return 1
200}
201
202func us_hash(s: *u8, n: i64) -> i64 {
  var h: i64 = US_FNV_OFF
  var i: i64 = 0
  while i < n {
      h = h ^ (s[i] as i64)
      h = h * US_FNV_PRIME
      i = i + 1
  }
  if h < 0 { h = 0 - h }
  if h < 0 { h = 0 }
  return h
213}
214
215func us_slot(tab: *u8, i: i64) -> *u8 { return ((tab as i64) + i * US_NAMELEN) as *u8 }
216
217// Open-addressed insert. Returns the slot index, or 0-1 if the name does not fit / the table is full.
218func us_put(tab: *u8, s: *u8, n: i64) -> i64 {
  if n <= 0 { return 0 - 1 }
  if n >= US_NAMELEN { return 0 - 1 }
  let h: i64 = us_hash(s, n)
  var idx: i64 = h - (h / US_SLOTS) * US_SLOTS
  var probes: i64 = 0
  while probes < US_SLOTS {
      let p: *u8 = us_slot(tab, idx)
      if p[0] == (0 as u8) {
          var i: i64 = 0
          while i < n { p[i] = s[i]; i = i + 1 }
          p[n] = 0 as u8
          return idx
      }
      var eq: i64 = 1
      if p[n] != (0 as u8) { eq = 0 }
      var k: i64 = 0
      while k < n {
          if p[k] != s[k] { eq = 0; k = n } else { k = k + 1 }
      }
      if eq == 1 { return idx }
      idx = idx + 1
      if idx >= US_SLOTS { idx = 0 }
      probes = probes + 1
  }
  return 0 - 1
244}
245
246func us_has(tab: *u8, s: *u8, n: i64) -> i64 {
  if n <= 0 { return 0 }
  if n >= US_NAMELEN { return 0 }
  let h: i64 = us_hash(s, n)
  var idx: i64 = h - (h / US_SLOTS) * US_SLOTS
  var probes: i64 = 0
  while probes < US_SLOTS {
      let p: *u8 = us_slot(tab, idx)
      if p[0] == (0 as u8) { return 0 }
      var eq: i64 = 1
      if p[n] != (0 as u8) { eq = 0 }
      var k: i64 = 0
      while k < n {
          if p[k] != s[k] { eq = 0; k = n } else { k = k + 1 }
      }
      if eq == 1 { return 1 }
      idx = idx + 1
      if idx >= US_SLOTS { idx = 0 }
      probes = probes + 1
  }
  return 0
267}
268
269// Queue of closure member basenames. Dedupes against 0..cnt-1 using slot cnt as scratch.
270func us_qpush(q: *u8, cnt: i64, src: *u8, n: i64) -> i64 {
  if n <= 0 { return cnt }
  if n >= US_NAMELEN { return cnt }
  if cnt >= US_MAXF { return cnt }
  let d: *u8 = us_slot(q, cnt)
  var i: i64 = 0
  while i < n { d[i] = src[i]; i = i + 1 }
  d[n] = 0 as u8
  var k: i64 = 0
  while k < cnt {
      if us_eqlit(us_slot(q, k), n, d, n) == 1 {
          let e: *u8 = us_slot(q, k)
          if e[n] == (0 as u8) { return cnt }
      }
      k = k + 1
  }
  return cnt + 1
287}
288
289// out = <dir>/<name>.nx
290func us_path(out: *u8, dir: *u8, name: *u8) {
  var w: i64 = 0
  var i: i64 = 0
  while dir[i] != (0 as u8) { out[w] = dir[i]; w = w + 1; i = i + 1 }
  out[w] = 47 as u8
  w = w + 1
  i = 0
  while name[i] != (0 as u8) { out[w] = name[i]; w = w + 1; i = i + 1 }
  out[w] = 46 as u8
  out[w + 1] = 110 as u8
  out[w + 2] = 120 as u8
  out[w + 3] = 0 as u8
302}
303
304func us_exists(path: *u8) -> i64 {
  let fd: i64 = sys_openat_rd(path)
  if fd < 0 { return 0 }
  sys_close(fd)
  return 1
309}
310
311// Load compiler-provided symbols from the conf. An unreadable/absent conf yields ZERO exclusions, which
312// makes every intrinsic show up as UNDEFINED -- loud and obviously wrong. That direction is deliberate:
313// an empty exclusion set can only add false positives, never hide a real missing function.
314func us_load_builtins(tab: *u8) -> i64 {
  let lenbox: *i64 = sys_mmap(16) as *i64
  lenbox[0] = 0
  let buf: *u8 = sys_read_file(US_BICONF, lenbox)
  let n: i64 = lenbox[0]
  if n <= 0 { return 0 }
  var cnt: i64 = 0
  var i: i64 = 0
  while i < n {
      var e: i64 = i
      var st: i64 = 0
      while st == 0 {
          if e >= n { st = 1 } else {
              if buf[e] == (10 as u8) { st = 1 } else { e = e + 1 }
          }
      }
      var L: i64 = e - i
      var trimming: i64 = 1
      while trimming == 1 {
          if L <= 0 { trimming = 0 } else {
              let ch: i64 = buf[i + L - 1] as i64
              if ch == 13 { L = L - 1 } else {
              if ch == 32 { L = L - 1 } else {
              if ch == 9 { L = L - 1 } else { trimming = 0 } } }
          }
      }
      if L > 0 {
          if buf[i] != (35 as u8) {
              us_put(tab, ((buf as i64) + i) as *u8, L)
              cnt = cnt + 1
          }
      }
      i = e + 1
  }
  return cnt
349}
350
351// After a `func`, `struct`, or `type` keyword the next identifier is a DECLARATION. All three spell it
352// the same way, so one helper serves all three (rule 15) -- and MISSING any of them is expensive: not
353// handling `type` alone accounted for ~32 phantom undefined identifiers, because nx_tier.nx:62 declares
354// `type nx_int = i64` and thirty-odd sibling aliases that the whole corpus then uses as types.
355// Returns the index just past the declared name, or 0-1 if no identifier follows.
356func us_declare_next(buf: *u8, n: i64, from: i64, defs: *u8) -> i64 {
  var k: i64 = from
  var st: i64 = 0
  while st == 0 {
      if k >= n { st = 1 } else {
          if us_isidst(buf[k] as i64) == 1 { st = 1 } else { k = k + 1 }
      }
  }
  if k >= n { return 0 - 1 }
  var e: i64 = k
  var s2: i64 = 0
  while s2 == 0 {
      if e >= n { s2 = 1 } else {
          if us_isidc(buf[e] as i64) == 1 { e = e + 1 } else { s2 = 1 }
      }
  }
  us_put(defs, ((buf as i64) + k) as *u8, e - k)
  return e
374}
375
376func us_isdig(c: i64) -> i64 {
  if c >= 48 { if c <= 57 { return 1 } }
  return 0
379}
380
381// THE SCANNER. One left-to-right pass; comments and string literals are skipped as units so a function
382// name mentioned in prose or in a message string never becomes a phantom call.
383func us_scan(buf: *u8, n: i64, defs: *u8, calls: *u8, refs: *u8, q: *u8, qcnt: i64) -> i64 {
  var qc: i64 = qcnt
  var i: i64 = 0
  while i < n {
      let c: i64 = buf[i] as i64
      var adv: i64 = 1
389
      var iscmt: i64 = 0
      if c == 47 { if i + 1 < n { if buf[i + 1] == (47 as u8) { iscmt = 1 } } }
      if iscmt == 1 {
          var j: i64 = i + 2
          var st: i64 = 0
          while st == 0 {
              if j >= n { st = 1 } else {
                  if buf[j] == (10 as u8) { st = 1 } else { j = j + 1 }
              }
          }
          i = j
          adv = 0
      }
403
      if adv == 1 {
      if c == 34 {
          var j: i64 = i + 1
          var st: i64 = 0
          while st == 0 {
              if j >= n { st = 1 } else {
                  if buf[j] == (92 as u8) { j = j + 2 } else {
                      if buf[j] == (34 as u8) { j = j + 1; st = 1 } else { j = j + 1 }
                  }
              }
          }
          i = j
          adv = 0
      } }
418
      // A NUMERIC LITERAL is consumed WHOLE. Without this, 0x00004000 scans as the digit 0 followed by
      // an identifier x00004000 -- ten phantom undefined names in the first real run, every one a hex
      // constant. A tokenizer that splits a literal invents symbols that were never written.
      if adv == 1 {
      if us_isdig(c) == 1 {
          var j: i64 = i
          var st: i64 = 0
          while st == 0 {
              if j >= n { st = 1 } else {
                  if us_isidc(buf[j] as i64) == 1 { j = j + 1 } else { st = 1 }
              }
          }
          i = j
          adv = 0
      } }
434
      // A PREPROCESSOR DIRECTIVE (@ifdef / @ifndef / @endif). '@' is not an identifier character, so
      // without this the directive NAME leaks through as a bare reference. The condition after it does
      // NOT leak -- TARGET_X86_64 is a genuine compiler-provided flag and is declared in the conf.
      if adv == 1 {
      if c == 64 {
          var j: i64 = i + 1
          var st: i64 = 0
          while st == 0 {
              if j >= n { st = 1 } else {
                  if us_isidc(buf[j] as i64) == 1 { j = j + 1 } else { st = 1 }
              }
          }
          i = j
          adv = 0
      } }
450
      if adv == 1 {
      if us_isidst(c) == 1 {
          var j: i64 = i
          var st: i64 = 0
          while st == 0 {
              if j >= n { st = 1 } else {
                  if us_isidc(buf[j] as i64) == 1 { j = j + 1 } else { st = 1 }
              }
          }
          let L: i64 = j - i
          let p: *u8 = ((buf as i64) + i) as *u8
462
          var done: i64 = 0
464
          // `let` and `var` introduce a binding whose TYPE ANNOTATION IS OPTIONAL. Classifying a
          // declaration by a following ':' therefore misses `let _ = expr` entirely, and the name lands
          // in the reference bucket as a phantom undefined symbol. Measured: nx_search_inverted_test
          // uses `let _ = ...` and `let _2 = ...` as discard bindings and was reported with two
          // undefined identifiers, one of which the corpus resolver then "found" in an unrelated file.
          // A false positive that RESOLVES somewhere is worse than one that does not -- it invites a
          // wrong import. Declare on the KEYWORD, not on the punctuation that may not be there.
          var isdecl: i64 = 0
          if us_eqlit(p, L, "func" as *u8, 4) == 1 { isdecl = 1 }
          if us_eqlit(p, L, "struct" as *u8, 6) == 1 { isdecl = 1 }
          if us_eqlit(p, L, "type" as *u8, 4) == 1 { isdecl = 1 }
          if us_eqlit(p, L, "let" as *u8, 3) == 1 { isdecl = 1 }
          if us_eqlit(p, L, "var" as *u8, 3) == 1 { isdecl = 1 }
          if isdecl == 1 {
              let de: i64 = us_declare_next(buf, n, j, defs)
              if de >= 0 { i = de; done = 1 }
          }
482
          if done == 0 {
          if us_eqlit(p, L, "import" as *u8, 6) == 1 {
              var k: i64 = j
              var qpos: i64 = 0 - 1
              var s4: i64 = 0
              while s4 == 0 {
                  if k >= n { s4 = 1 } else {
                      if buf[k] == (34 as u8) { qpos = k; s4 = 1 } else {
                          if buf[k] == (10 as u8) { s4 = 1 } else { k = k + 1 }
                      }
                  }
              }
              if qpos >= 0 {
                  var e: i64 = qpos + 1
                  var s5: i64 = 0
                  while s5 == 0 {
                      if e >= n { s5 = 1 } else {
                          if buf[e] == (34 as u8) { s5 = 1 } else { e = e + 1 }
                      }
                  }
                  if e < n {
                      let ip: *u8 = ((buf as i64) + qpos + 1) as *u8
                      var IL: i64 = e - (qpos + 1)
                      if IL > 3 {
                          if ip[IL - 3] == (46 as u8) {
                          if ip[IL - 2] == (110 as u8) {
                          if ip[IL - 1] == (120 as u8) { IL = IL - 3 } } }
                      }
                      qc = us_qpush(q, qc, ip, IL)
                      i = e + 1
                      done = 1
                  }
              }
          } }
517
          if done == 0 {
              // CLASSIFY BY THE NEXT SIGNIFICANT CHARACTER. An identifier followed by ':' is a
              // DECLARATION -- parameter, let, var, const, or struct field -- and this language spells
              // all five that one way, so the rule is exact rather than heuristic. Collecting them all
              // OVER-approximates the declared set, which is the safe direction: it cannot invent a
              // false positive from scoping, and a name declared NOWHERE in the closure still stands out.
              var k: i64 = j
              var t4: i64 = 0
              while t4 == 0 {
                  if k >= n { t4 = 1 } else {
                      if buf[k] == (32 as u8) { k = k + 1 } else {
                          if buf[k] == (9 as u8) { k = k + 1 } else { t4 = 1 }
                      }
                  }
              }
              var cls: i64 = 0
              if j < n { if buf[j] == (40 as u8) { cls = 1 } }
              if cls == 0 { if k < n { if buf[k] == (58 as u8) { cls = 2 } } }
              if cls == 1 { if us_iskw(p, L) == 0 { us_put(calls, p, L) } }
              if cls == 2 { us_put(defs, p, L) }
              if cls == 0 { if us_iskw(p, L) == 0 { us_put(refs, p, L) } }
              i = j
          }
          adv = 0
      } }
543
      if adv == 1 { i = i + 1 }
  }
  return qc
547}
548
549// Scan ONE file for top-level declarations and, for any name in the undefined set, record the file that
550// declares it. Only the (small) undefined set is searched for, so memory is O(undefined), not O(corpus).
551func us_scan_decls(buf: *u8, n: i64, und: *u8, undcnt: i64, src: *u8, fname: *u8) -> i64 {
  var hits: i64 = 0
  var i: i64 = 0
  while i < n {
      var adv: i64 = 1
      if us_isidst(buf[i] as i64) == 1 {
          var j: i64 = i
          var st: i64 = 0
          while st == 0 {
              if j >= n { st = 1 } else {
                  if us_isidc(buf[j] as i64) == 1 { j = j + 1 } else { st = 1 }
              }
          }
          let L: i64 = j - i
          let p: *u8 = ((buf as i64) + i) as *u8
          var isd: i64 = 0
          if us_eqlit(p, L, "func" as *u8, 4) == 1 { isd = 1 }
          if us_eqlit(p, L, "struct" as *u8, 6) == 1 { isd = 1 }
          if us_eqlit(p, L, "type" as *u8, 4) == 1 { isd = 1 }
          if us_eqlit(p, L, "const" as *u8, 5) == 1 { isd = 1 }
          if isd == 1 {
              var k: i64 = j
              var s2: i64 = 0
              while s2 == 0 {
                  if k >= n { s2 = 1 } else {
                      if us_isidst(buf[k] as i64) == 1 { s2 = 1 } else { k = k + 1 }
                  }
              }
              if k < n {
                  var e: i64 = k
                  var s3: i64 = 0
                  while s3 == 0 {
                      if e >= n { s3 = 1 } else {
                          if us_isidc(buf[e] as i64) == 1 { e = e + 1 } else { s3 = 1 }
                      }
                  }
                  let dn: *u8 = ((buf as i64) + k) as *u8
                  let dl: i64 = e - k
                  var u: i64 = 0
                  while u < undcnt {
                      let up: *u8 = us_slot(und, u)
                      if us_eqlit(up, dl, dn, dl) == 1 {
                      if up[dl] == (0 as u8) {
                          let sp: *u8 = us_slot(src, u)
                          if sp[0] == (0 as u8) {
                              var z: i64 = 0
                              while fname[z] != (0 as u8) {
                                  if z < US_NAMELEN - 1 { sp[z] = fname[z] }
                                  z = z + 1
                              }
                              if z > US_NAMELEN - 1 { z = US_NAMELEN - 1 }
                              sp[z] = 0 as u8
                              hits = hits + 1
                          }
                      } }
                      u = u + 1
                  }
                  i = e
                  adv = 0
              }
          }
          if adv == 1 { i = j; adv = 0 }
      }
      if adv == 1 { i = i + 1 }
  }
  return hits
617}
618
619// Walk ONE source tree. Deliberately the SAME two directories the import resolver searches (runtime/ then
620// _hdl_build/) and no others: a definition sitting in wiki/ or _retired/ is NOT importable, so reporting
621// it as ELSEWHERE would hand the caller a fix that cannot work.
622func us_corpus_dir(dir: *u8, und: *u8, undcnt: i64, src: *u8) -> i64 {
  let dfd: i64 = sys_openat_rd(dir)
  if dfd < 0 { return 0 }
  let dbuf: *u8 = sys_mmap(US_DIRBUF)
  let path: *u8 = sys_mmap(US_PATHBUF)
  let lenbox: *i64 = sys_mmap(16) as *i64
  var files: i64 = 0
  var go: i64 = 1
  while go == 1 {
      let nb: i64 = sys_getdents64(dfd, dbuf, US_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)
                  var ln: i64 = 0
                  while nm[ln] != (0 as u8) { ln = ln + 1 }
                  var isnx: i64 = 0
                  if ln > 3 {
                      if nm[ln - 3] == (46 as u8) {
                      if nm[ln - 2] == (110 as u8) {
                      if nm[ln - 1] == (120 as u8) { isnx = 1 } } }
                  }
                  if isnx == 1 {
                      var po: i64 = 0
                      var di: i64 = 0
                      while dir[di] != (0 as u8) { path[po] = dir[di]; po = po + 1; di = di + 1 }
                      path[po] = 47 as u8
                      po = po + 1
                      var ni: i64 = 0
                      while nm[ni] != (0 as u8) { path[po] = nm[ni]; po = po + 1; ni = ni + 1 }
                      path[po] = 0 as u8
                      lenbox[0] = 0
                      let fb: *u8 = sys_read_file(path, lenbox)
                      if lenbox[0] > 0 {
                          us_scan_decls(fb, lenbox[0], und, undcnt, src, nm)
                          files = files + 1
                          sys_munmap(fb, lenbox[0])
                      }
                  }
                  off = off + rl
              }
          }
      }
  }
  sys_close(dfd)
  return files
671}
672
673// Collect EVERY top-level declaration name (func/struct/type/const) from a file into tab.
674func us_collect_decls(buf: *u8, n: i64, tab: *u8) -> i64 {
  var cnt: i64 = 0
  var i: i64 = 0
  while i < n {
      var adv: i64 = 1
      var iscmt: i64 = 0
      if buf[i] == (47 as u8) { if i + 1 < n { if buf[i + 1] == (47 as u8) { iscmt = 1 } } }
      if iscmt == 1 {
          var j: i64 = i + 2
          var st: i64 = 0
          while st == 0 {
              if j >= n { st = 1 } else {
                  if buf[j] == (10 as u8) { st = 1 } else { j = j + 1 }
              }
          }
          i = j
          adv = 0
      }
      if adv == 1 { if buf[i] == (34 as u8) {
          var j: i64 = i + 1
          var st: i64 = 0
          while st == 0 {
              if j >= n { st = 1 } else {
                  if buf[j] == (92 as u8) { j = j + 2 } else {
                      if buf[j] == (34 as u8) { j = j + 1; st = 1 } else { j = j + 1 }
                  }
              }
          }
          i = j
          adv = 0
      } }
      if adv == 1 { if us_isidst(buf[i] as i64) == 1 {
          var j: i64 = i
          var st: i64 = 0
          while st == 0 {
              if j >= n { st = 1 } else {
                  if us_isidc(buf[j] as i64) == 1 { j = j + 1 } else { st = 1 }
              }
          }
          let L: i64 = j - i
          let p: *u8 = ((buf as i64) + i) as *u8
          var isd: i64 = 0
          if us_eqlit(p, L, "func" as *u8, 4) == 1 { isd = 1 }
          if us_eqlit(p, L, "struct" as *u8, 6) == 1 { isd = 1 }
          if us_eqlit(p, L, "type" as *u8, 4) == 1 { isd = 1 }
          if us_eqlit(p, L, "const" as *u8, 5) == 1 { isd = 1 }
          if isd == 1 {
              let de: i64 = us_declare_next(buf, n, j, tab)
              if de >= 0 { i = de; cnt = cnt + 1; adv = 0 }
          }
          if adv == 1 { i = j; adv = 0 }
      } }
      if adv == 1 { i = i + 1 }
  }
  return cnt
729}
730
731// Scan ONE target's closure end to end. Returns undefined count (funcs + idents, builtins excluded), or
732// 0-1 if the target resolves to no file. flag[0] = closure_complete, flag[1] = has_main.
733// Allocates and RELEASES its own tables so a sweep over thousands of targets stays bounded -- the memfloor
734// lesson: an allocator that grows per item is a freeze waiting for a big enough input.
735func us_scan_one(name: *u8, bi: *u8, flag: *i64) -> i64 {
  let q: *u8 = sys_mmap(US_MAXF * US_NAMELEN)
  let defs: *u8 = sys_mmap(US_SLOTS * US_NAMELEN)
  let calls: *u8 = sys_mmap(US_SLOTS * US_NAMELEN)
  let refs: *u8 = sys_mmap(US_SLOTS * US_NAMELEN)
  let path: *u8 = sys_mmap(US_PATHBUF)
  let lb: *i64 = sys_mmap(16) as *i64
  flag[0] = 1
  flag[1] = 0
  var nl: i64 = 0
  while name[nl] != (0 as u8) { nl = nl + 1 }
  var qcnt: i64 = us_qpush(q, 0, name, nl)
  var head: i64 = 0
  var rc: i64 = 0
  let qdir: *i64 = sys_mmap(US_MAXF * 8) as *i64
  var qd: i64 = 0
  while qd < US_MAXF { qdir[qd] = 0 - 1; qd = qd + 1 }
  while head < qcnt {
      let nm: *u8 = us_slot(q, head)
      let did: i64 = us_resolve_dir(path, nm, qdir[head])
      if did < 0 {
          if head == 0 { rc = 0 - 1 }
          flag[0] = 0
      } else {
          lb[0] = 0
          let buf: *u8 = sys_read_file(path, lb)
          if lb[0] <= 0 { flag[0] = 0 } else {
              let before: i64 = qcnt
              qcnt = us_scan(buf, lb[0], defs, calls, refs, q, qcnt)
              // Every entry pushed while scanning THIS file was imported BY this file, so its binding
              // preference is the directory this file actually resolved to -- not the root's.
              var kid: i64 = before
              while kid < qcnt { qdir[kid] = did; kid = kid + 1 }
              if head == 0 { flag[1] = us_has(defs, "main" as *u8, 4) }
              sys_munmap(buf, lb[0])
          }
      }
      head = head + 1
      if qcnt >= US_MAXF { flag[0] = 0 }
  }
  sys_munmap(qdir, US_MAXF * 8)
  var undef: i64 = 0
  if rc == 0 {
      var s: i64 = 0
      while s < US_SLOTS {
          let p: *u8 = us_slot(calls, s)
          if p[0] != (0 as u8) {
              var L: i64 = 0
              while p[L] != (0 as u8) { L = L + 1 }
              if us_has(defs, p, L) == 0 { if us_has(bi, p, L) == 0 { if us_is_dunder(p) == 0 { undef = undef + 1 } } }
          }
          let r: *u8 = us_slot(refs, s)
          if r[0] != (0 as u8) {
              var L2: i64 = 0
              while r[L2] != (0 as u8) { L2 = L2 + 1 }
              if us_has(defs, r, L2) == 0 { if us_has(bi, r, L2) == 0 { if us_is_dunder(r) == 0 { undef = undef + 1 } } }
          }
          s = s + 1
      }
  }
  sys_munmap(q, US_MAXF * US_NAMELEN)
  sys_munmap(defs, US_SLOTS * US_NAMELEN)
  sys_munmap(calls, US_SLOTS * US_NAMELEN)
  sys_munmap(refs, US_SLOTS * US_NAMELEN)
  if rc < 0 { return 0 - 1 }
  return undef
801}
802
803// PAGED sweep over a directory. off/lim make this a bounded operation instead of one long run that a
804// 12s deadline would truncate silently -- and a truncated sweep reporting zero is exactly the PARTIAL lie
805// this organ exists to prevent. Prints ONLY targets with findings, plus a tail line naming what was
806// covered so the caller can page the rest and can never mistake a page for the whole corpus.
807func us_sweep(dir: *u8, off0: i64, lim: i64, bi: *u8) -> i64 {
  let dfd: i64 = sys_openat_rd(dir)
  if dfd < 0 { return 0 }
  let dbuf: *u8 = sys_mmap(US_DIRBUF)
  let base: *u8 = sys_mmap(US_PATHBUF)
  let flag: *i64 = sys_mmap(32) as *i64
  var idx: i64 = 0
  var done: i64 = 0
  var hits: i64 = 0
  var go: i64 = 1
  while go == 1 {
      let nb: i64 = sys_getdents64(dfd, dbuf, US_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)
                  var ln: i64 = 0
                  while nm[ln] != (0 as u8) { ln = ln + 1 }
                  var isnx: i64 = 0
                  if ln > 3 {
                      if nm[ln - 3] == (46 as u8) {
                      if nm[ln - 2] == (110 as u8) {
                      if nm[ln - 1] == (120 as u8) { isnx = 1 } } }
                  }
                  if isnx == 1 {
                      if idx >= off0 { if done < lim {
                          var b: i64 = 0
                          while b < ln - 3 { base[b] = nm[b]; b = b + 1 }
                          base[ln - 3] = 0 as u8
                          let u: i64 = us_scan_one(base, bi, flag)
                          if u > 0 {
                              us_puts("TARGET " as *u8)
                              us_puts(base)
                              us_puts(" undefined=" as *u8)
                              us_puti(u)
                              us_puts(" has_main=" as *u8)
                              us_puti(flag[1])
                              if flag[0] == 0 { us_puts(" PARTIAL" as *u8) }
                              us_puts("\n" as *u8)
                              hits = hits + 1
                          }
                          done = done + 1
                      } }
                      idx = idx + 1
                  }
                  off = off + rl
              }
          }
      }
  }
  sys_close(dfd)
  us_puts("sweep_dir_total_nx=" as *u8)
  us_puti(idx)
  us_puts(" scanned=" as *u8)
  us_puti(done)
  us_puts(" offset=" as *u8)
  us_puti(off0)
  us_puts(" with_findings=" as *u8)
  us_puti(hits)
  us_puts("\n" as *u8)
  return hits
871}
872
873func us_join(out: *u8, dir: *u8, name: *u8) {
  var w: i64 = 0
  var i: i64 = 0
  while dir[i] != (0 as u8) { out[w] = dir[i]; w = w + 1; i = i + 1 }
  out[w] = 47 as u8
  w = w + 1
  i = 0
  while name[i] != (0 as u8) { out[w] = name[i]; w = w + 1; i = i + 1 }
  out[w] = 0 as u8
882}
883
884// THE DEDUPE DISCRIMINATOR. For an artifact X.nx.<suffix> the survivor is X.nx. The artifact is a COPY if
885// the survivor declares every symbol it does; it is a COLLISION -- a DELETED CAPABILITY -- if it declares
886// symbols the survivor lacks. Sampling this population found one real deletion by luck and produced two
887// false positives, which is exactly why it has to be measured rather than eyeballed.
888// A nonzero `lost` is a CANDIDATE, not a verdict: confirm by checking whether anything still imports the
889// survivor's name. Nothing here deletes, restores, or rewrites anything -- it only reports.
890func us_dupescan(dir: *u8) -> i64 {
  let dfd: i64 = sys_openat_rd(dir)
  if dfd < 0 { return 0 }
  let dbuf: *u8 = sys_mmap(US_DIRBUF)
  let apath: *u8 = sys_mmap(US_PATHBUF)
  let spath: *u8 = sys_mmap(US_PATHBUF)
  let base: *u8 = sys_mmap(US_PATHBUF)
  let lb: *i64 = sys_mmap(16) as *i64
  var seen: i64 = 0
  var go: i64 = 1
  while go == 1 {
      let nb: i64 = sys_getdents64(dfd, dbuf, US_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)
                  var ln: i64 = 0
                  while nm[ln] != (0 as u8) { ln = ln + 1 }
                  var cut: i64 = 0 - 1
                  var k: i64 = 0
                  while k + 3 < ln {
                      if nm[k] == (46 as u8) {
                      if nm[k + 1] == (110 as u8) {
                      if nm[k + 2] == (120 as u8) {
                      if nm[k + 3] == (46 as u8) { cut = k + 3 } } } }
                      k = k + 1
                  }
                  if cut > 0 {
                      seen = seen + 1
                      var b: i64 = 0
                      while b < cut { base[b] = nm[b]; b = b + 1 }
                      base[cut] = 0 as u8
                      us_join(apath, dir, nm)
                      us_join(spath, US_RTDIR, base)
                      var sfound: i64 = us_exists(spath)
                      if sfound == 0 {
                          us_join(spath, US_HDDIR, base)
                          sfound = us_exists(spath)
                      }
                      us_puts("ARTIFACT " as *u8)
                      us_puts(nm)
                      if sfound == 0 {
                          us_puts("  survivor=NONE -- nothing reclaimed the name\n" as *u8)
                      } else {
                          let ta: *u8 = sys_mmap(US_SLOTS * US_NAMELEN)
                          let tb: *u8 = sys_mmap(US_SLOTS * US_NAMELEN)
                          lb[0] = 0
                          let ab: *u8 = sys_read_file(apath, lb)
                          let an: i64 = lb[0]
                          var adecl: i64 = 0
                          if an > 0 { adecl = us_collect_decls(ab, an, ta) }
                          lb[0] = 0
                          let sb: *u8 = sys_read_file(spath, lb)
                          let sn: i64 = lb[0]
                          if sn > 0 { us_collect_decls(sb, sn, tb) }
                          var lost: i64 = 0
                          var s: i64 = 0
                          while s < US_SLOTS {
                              let p: *u8 = us_slot(ta, s)
                              if p[0] != (0 as u8) {
                                  var L: i64 = 0
                                  while p[L] != (0 as u8) { L = L + 1 }
                                  if us_has(tb, p, L) == 0 { lost = lost + 1 }
                              }
                              s = s + 1
                          }
                          us_puts("  decls=" as *u8)
                          us_puti(adecl)
                          us_puts(" lost=" as *u8)
                          us_puti(lost)
                          if lost > 0 {
                              us_puts("  CANDIDATE-COLLISION -- survivor lacks symbols this file declared\n" as *u8)
                          } else {
                              us_puts("  COPY -- survivor declares everything\n" as *u8)
                          }
                          if an > 0 { sys_munmap(ab, an) }
                          if sn > 0 { sys_munmap(sb, sn) }
                          sys_munmap(ta, US_SLOTS * US_NAMELEN)
                          sys_munmap(tb, US_SLOTS * US_NAMELEN)
                      }
                  }
                  off = off + rl
              }
          }
      }
  }
  sys_close(dfd)
  return seen
981}
982
983// ===================================================================================================
984// CALL-SITE ARITY, ON THE IMPORT CLOSURE.
985//
986// WHY IT LIVES HERE AND NOT IN A SCANNER OF ITS OWN. A directory-scoped arity checker
987// (nx_aritycheck_gate) was built first and produced FOUR successive classes of false positive on the
988// real corpus, each one discovered only by hand-verifying a finding before reporting it:
989//   1. COMMENTS      -- definitions were column-0 anchored but call sites were not, so a call written
990//                       inside a `//` line counted. aa_chain is defined once with 4 params and called
991//                       with 4; the "2-arg call" was a comment.
992//   2. SCOPE         -- definitions were pooled per DIRECTORY, so every organ's own `main` collided.
993//   3. STRING LITERALS -- commas inside a string counted as argument separators, so
994//                       as_append(out, o, "system-ui,-apple-system,Segoe UI,sans-serif") read as 6 args
995//                       against a 3-param definition.
996//   4. CROSS-PROGRAM NAME COLLISION -- and this one is NOT patchable. nx_authorgen_gate.nx calls
997//                       ag_build() with ZERO arguments and is CORRECT: it imports runtime/nx_authorgen.nx
998//                       which declares `func ag_build() -> i64`. The directory scanner compared it against
999//                       an unrelated `func ag_build(parent, value, kind)` in nx_analyst_gate.nx -- a file
1000//                       nx_authorgen_gate.nx does not import and never links against.
1001//
1002// THE LAW THAT MOVED THE CODE: THE ONLY SOUND SCOPE FOR A CALL-SITE CHECK IS THE IMPORT CLOSURE.
1003// A directory is not a scope. Counting definitions to disambiguate does not rescue it -- ag_build is
1004// declared exactly ONCE inside _hdl_build/, so a uniqueness rule still judged it, and still got it wrong,
1005// because the definition that actually binds lives OUTSIDE the directory. Every further heuristic would
1006// have bought one more class and lost the next. This organ already walks the closure, already skips
1007// comments, strings, numeric literals and directives AS UNITS, and already refuses to certify a PARTIAL
1008// closure. Arity belongs where those three properties already hold, and nowhere else.
1009//
1010// WHY THE COMPILER DOES NOT CATCH IT: nx_cc FAILS OPEN on argument count -- a wrong-arity call compiles
1011// green and silent. Same fail-open family as the duplicate definition it now rejects (1785447657) and the
1012// undefined identifier this organ already censuses (seq1012).
1013//
1014// KNOWN FALSE-POSITIVE CLASS, STATED SO NO CALLER HAS TO GUESS: a call THROUGH A FUNCTION-POINTER
1015// VARIABLE that happens to share a name with a declared function is compared against that declaration.
1016// This is the same bounded class the undefined-symbol pass already documents, and it is bounded the same
1017// way -- by the positive control below.
1018// ===================================================================================================
1019
1020const US_ARUNK: i64 = 0 - 2
1021const US_ARAMB: i64 = 0 - 3
1022
1023func us_alen(s: *u8) -> i64 {
  var n: i64 = 0
  while s[n] != (0 as u8) { n = n + 1 }
  return n
1027}
1028
1029// Slot index of an EXISTING name, or 0-1. us_has answers yes/no; arity needs the identity of the slot so
1030// the parameter count can never be read for a different name than the one that was matched.
1031func us_index(tab: *u8, s: *u8, n: i64) -> i64 {
  if n <= 0 { return 0 - 1 }
  if n >= US_NAMELEN { return 0 - 1 }
  let h: i64 = us_hash(s, n)
  var idx: i64 = h - (h / US_SLOTS) * US_SLOTS
  var probes: i64 = 0
  while probes < US_SLOTS {
      let p: *u8 = us_slot(tab, idx)
      if p[0] == (0 as u8) { return 0 - 1 }
      var eq: i64 = 1
      if p[n] != (0 as u8) { eq = 0 }
      var k: i64 = 0
      while k < n {
          if p[k] != s[k] { eq = 0; k = n } else { k = k + 1 }
      }
      if eq == 1 { return idx }
      idx = idx + 1
      if idx >= US_SLOTS { idx = 0 }
      probes = probes + 1
  }
  return 0 - 1
1052}
1053
1054// Count top-level comma-separated items between the parens beginning at `op` (which must index '(').
1055// ONE helper serves BOTH a declaration's parameter list and a call's argument list -- they are the same
1056// shape, and this file already uses one helper for func/struct/type on the same reasoning (rule 15).
1057// Nested parens, string literals and // comments are skipped as units, so a comma inside any of them is
1058// never counted; a fn-pointer parameter type like `f: func(i64, i64) -> i64` therefore reads as ONE item.
1059// Returns 0 for "()", the item count otherwise, or 0-1 if the list never closes (caller must not judge).
1060func us_commas(buf: *u8, n: i64, op: i64) -> i64 {
  var i: i64 = op + 1
  var depth: i64 = 1
  var commas: i64 = 0
  var any: i64 = 0
  while i < n {
      let c: i64 = buf[i] as i64
      var adv: i64 = 1
1068
      if c == 47 {
          if i + 1 < n {
              if buf[i + 1] == (47 as u8) {
                  var j: i64 = i + 2
                  var st: i64 = 0
                  while st == 0 {
                      if j >= n { st = 1 } else {
                          if buf[j] == (10 as u8) { st = 1 } else { j = j + 1 }
                      }
                  }
                  i = j
                  adv = 0
              }
          }
      }
1084
      if adv == 1 {
      if c == 34 {
          any = 1
          var j: i64 = i + 1
          var st: i64 = 0
          while st == 0 {
              if j >= n { st = 1 } else {
                  if buf[j] == (92 as u8) { j = j + 2 } else {
                      if buf[j] == (34 as u8) { j = j + 1; st = 1 } else { j = j + 1 }
                  }
              }
          }
          i = j
          adv = 0
      } }
1100
      if adv == 1 {
          if c == 40 { depth = depth + 1; any = 1 }
          if c == 41 {
              depth = depth - 1
              if depth == 0 {
                  if any == 0 { return 0 }
                  return commas + 1
              }
              any = 1
          }
          if depth == 1 { if c == 44 { commas = commas + 1 } }
          if c != 32 { if c != 10 { if c != 9 { if c != 13 { any = 1 } } } }
          i = i + 1
      }
  }
  return 0 - 1
1117}
1118
1119// Record the parameter count of every `func NAME(...)` in this file, keyed by the SAME slot index the
1120// definition table uses -- so a later lookup can never read the arity of a different name than the one
1121// it matched.
1122// A name that appears TWICE in one closure with DIFFERENT arities is marked AMBIGUOUS and never judged
1123// again. Guessing which declaration a call meant would manufacture exactly the false positive this
1124// rewrite exists to eliminate; and two definitions of one name is a separate defect that nx_cc now
1125// rejects on its own.
1126func us_collect_arity(buf: *u8, n: i64, defs: *u8, defar: *i64) -> i64 {
  var cnt: i64 = 0
  var i: i64 = 0
  while i < n {
      var adv: i64 = 1
1131
      if buf[i] == (47 as u8) {
          if i + 1 < n {
              if buf[i + 1] == (47 as u8) {
                  var j: i64 = i + 2
                  var st: i64 = 0
                  while st == 0 {
                      if j >= n { st = 1 } else {
                          if buf[j] == (10 as u8) { st = 1 } else { j = j + 1 }
                      }
                  }
                  i = j
                  adv = 0
              }
          }
      }
1147
      if adv == 1 {
      if buf[i] == (34 as u8) {
          var j: i64 = i + 1
          var st: i64 = 0
          while st == 0 {
              if j >= n { st = 1 } else {
                  if buf[j] == (92 as u8) { j = j + 2 } else {
                      if buf[j] == (34 as u8) { j = j + 1; st = 1 } else { j = j + 1 }
                  }
              }
          }
          i = j
          adv = 0
      } }
1162
      if adv == 1 {
      if us_isidst(buf[i] as i64) == 1 {
          var j: i64 = i
          var st: i64 = 0
          while st == 0 {
              if j >= n { st = 1 } else {
                  if us_isidc(buf[j] as i64) == 1 { j = j + 1 } else { st = 1 }
              }
          }
          let L: i64 = j - i
          let p: *u8 = ((buf as i64) + i) as *u8
          var handled: i64 = 0
          if us_eqlit(p, L, "func" as *u8, 4) == 1 {
              var k: i64 = j
              var s2: i64 = 0
              while s2 == 0 {
                  if k >= n { s2 = 1 } else {
                      if us_isidst(buf[k] as i64) == 1 { s2 = 1 } else { k = k + 1 }
                  }
              }
              if k < n {
                  var e: i64 = k
                  var s3: i64 = 0
                  while s3 == 0 {
                      if e >= n { s3 = 1 } else {
                          if us_isidc(buf[e] as i64) == 1 { e = e + 1 } else { s3 = 1 }
                      }
                  }
                  let np: *u8 = ((buf as i64) + k) as *u8
                  let NL: i64 = e - k
                  if e < n {
                      if buf[e] == (40 as u8) {
                          let a: i64 = us_commas(buf, n, e)
                          if a >= 0 {
                              let slot: i64 = us_put(defs, np, NL)
                              if slot >= 0 {
                                  if defar[slot] == US_ARUNK {
                                      defar[slot] = a
                                      cnt = cnt + 1
                                  } else {
                                      if defar[slot] != a { defar[slot] = US_ARAMB }
                                  }
                              }
                          }
                      }
                  }
                  i = e
                  handled = 1
              }
          }
          if handled == 0 { i = j }
          adv = 0
      } }
1216
      if adv == 1 { i = i + 1 }
  }
  return cnt
1220}
1221
1222// Compare every call site in this file against the arity recorded from the closure. A name with no
1223// recorded arity (US_ARUNK) is NOT a finding here -- that is the undefined-symbol pass's job, and
1224// double-reporting it would inflate one defect into two. AMBIGUOUS is likewise never judged.
1225func us_check_arity(buf: *u8, n: i64, defs: *u8, defar: *i64, fname: *u8) -> i64 {
  var bad: i64 = 0
  var i: i64 = 0
  while i < n {
      var adv: i64 = 1
1230
      if buf[i] == (47 as u8) {
          if i + 1 < n {
              if buf[i + 1] == (47 as u8) {
                  var j: i64 = i + 2
                  var st: i64 = 0
                  while st == 0 {
                      if j >= n { st = 1 } else {
                          if buf[j] == (10 as u8) { st = 1 } else { j = j + 1 }
                      }
                  }
                  i = j
                  adv = 0
              }
          }
      }
1246
      if adv == 1 {
      if buf[i] == (34 as u8) {
          var j: i64 = i + 1
          var st: i64 = 0
          while st == 0 {
              if j >= n { st = 1 } else {
                  if buf[j] == (92 as u8) { j = j + 2 } else {
                      if buf[j] == (34 as u8) { j = j + 1; st = 1 } else { j = j + 1 }
                  }
              }
          }
          i = j
          adv = 0
      } }
1261
      if adv == 1 {
      if us_isidst(buf[i] as i64) == 1 {
          var j: i64 = i
          var st: i64 = 0
          while st == 0 {
              if j >= n { st = 1 } else {
                  if us_isidc(buf[j] as i64) == 1 { j = j + 1 } else { st = 1 }
              }
          }
          let L: i64 = j - i
          let p: *u8 = ((buf as i64) + i) as *u8
          if us_iskw(p, L) == 0 {
              if j < n {
                  if buf[j] == (40 as u8) {
                      let slot: i64 = us_index(defs, p, L)
                      if slot >= 0 {
                          let want: i64 = defar[slot]
                          if want >= 0 {
                              let got: i64 = us_commas(buf, n, j)
                              if got >= 0 {
                                  if got != want {
                                      us_puts("  ARITY-MISMATCH " as *u8)
                                      us_puts(fname)
                                      us_puts(": " as *u8)
                                      us_putn(p, L)
                                      us_puts(" called with " as *u8)
                                      us_puti(got)
                                      us_puts(" arg(s), declared with " as *u8)
                                      us_puti(want)
                                      us_puts("\n" as *u8)
                                      bad = bad + 1
                                  }
                              }
                          }
                      }
                  }
              }
          }
          i = j
          adv = 0
      } }
1303
      if adv == 1 { i = i + 1 }
  }
  return bad
1307}
1308
1309// PROVE THE COUNTER CAN FAIL BEFORE TRUSTING IT ON THE CORPUS. Every assertion here is a case that a
1310// previous implementation of this axis got WRONG on real source -- nesting, strings, comments, empty
1311// lists -- plus the unterminated case, which must refuse rather than answer. A tooth that only tests the
1312// cases the author already handled has tested nothing.
1313func us_arity_selftest() -> i64 {
  var fail: i64 = 0
  let a: *u8 = "(a, b, c)" as *u8
  if us_commas(a, us_alen(a), 0) != 3 { us_puts("  T1 FAIL plain\n" as *u8); fail = fail + 1 }
  let b: *u8 = "()" as *u8
  if us_commas(b, us_alen(b), 0) != 0 { us_puts("  T2 FAIL empty\n" as *u8); fail = fail + 1 }
  let c: *u8 = "(x)" as *u8
  if us_commas(c, us_alen(c), 0) != 1 { us_puts("  T3 FAIL single\n" as *u8); fail = fail + 1 }
  let d: *u8 = "(f(x, y), z)" as *u8
  if us_commas(d, us_alen(d), 0) != 2 { us_puts("  T4 FAIL nested\n" as *u8); fail = fail + 1 }
  // T5 STRING LITERAL -- built BYTE-WISE, not written as an escaped literal. An escaped literal would
  // also be testing whatever transport carried this source onto the NAS; bytes test only the counter.
  // Spells:  ("a,b",z)   -- two arguments, two commas, one of them inside the string.
  let e: *u8 = sys_mmap(32)
  e[0] = 40 as u8
  e[1] = 34 as u8
  e[2] = 97 as u8
  e[3] = 44 as u8
  e[4] = 98 as u8
  e[5] = 34 as u8
  e[6] = 44 as u8
  e[7] = 122 as u8
  e[8] = 41 as u8
  e[9] = 0 as u8
  if us_commas(e, 9, 0) != 2 { us_puts("  T5 FAIL string-literal comma counted\n" as *u8); fail = fail + 1 }
  let f: *u8 = "(   )" as *u8
  if us_commas(f, us_alen(f), 0) != 0 { us_puts("  T6 FAIL whitespace-only\n" as *u8); fail = fail + 1 }
  let g: *u8 = "(a, b" as *u8
  if us_commas(g, us_alen(g), 0) != 0 - 1 { us_puts("  T7 FAIL unterminated must refuse\n" as *u8); fail = fail + 1 }
  let h: *u8 = "(g(1, 2), h(3, 4), 5)" as *u8
  if us_commas(h, us_alen(h), 0) != 3 { us_puts("  T8 FAIL two nested\n" as *u8); fail = fail + 1 }
  // T9/T10 NON-VACUITY. The counter passing its own arithmetic teeth does NOT prove the REPORTING PATH
  // ever fires -- and 14 corpus targets in a row returned zero, which a broken checker and a clean
  // corpus produce identically. So drive collect AND check over a synthetic closure whose answer is
  // known, and REQUIRE the mismatch to be seen. Without this, "0 mismatches" is an unfalsifiable claim.
  let td: *u8 = sys_mmap(US_SLOTS * US_NAMELEN)
  let ta: *i64 = sys_mmap(US_SLOTS * 8) as *i64
  var zz: i64 = 0
  while zz < US_SLOTS { ta[zz] = US_ARUNK; zz = zz + 1 }
  let bad9: *u8 = "func zq_a(p: i64, q: i64) -> i64 { return p }\nfunc zq_b() -> i64 { return zq_a(1) }\n" as *u8
  let n9: i64 = us_alen(bad9)
  us_collect_arity(bad9, n9, td, ta)
  us_puts("  (T9 expects exactly ONE synthetic mismatch on the next line -- it IS the tooth)\n" as *u8)
  let m9: i64 = us_check_arity(bad9, n9, td, ta, "T9-SYNTHETIC" as *u8)
  if m9 != 1 { us_puts("  T9 FAIL -- the reporting path never fired; every corpus zero is VACUOUS\n" as *u8); fail = fail + 1 }
  let ok10: *u8 = "func zr_a(p: i64, q: i64) -> i64 { return p }\nfunc zr_b() -> i64 { return zr_a(1, 2) }\n" as *u8
  let n10: i64 = us_alen(ok10)
  us_collect_arity(ok10, n10, td, ta)
  let m10: i64 = us_check_arity(ok10, n10, td, ta, "T10-SYNTHETIC" as *u8)
  if m10 != 0 { us_puts("  T10 FAIL -- a CORRECT call was reported as a mismatch\n" as *u8); fail = fail + 1 }
  sys_munmap(td, US_SLOTS * US_NAMELEN)
  sys_munmap(ta, US_SLOTS * 8)
1365
  // NEGATIVE CONTROL: a counter that always returned 3 would pass T1 and T8 and nothing else. T2/T3/T7
  // are the ones that can only pass if it really counts, and T7 only if it really refuses.
  if fail == 0 { us_puts("  arity self-test OK (nesting + strings + empty + unterminated-refuses)\n" as *u8) }
  return fail
1370}
1371
1372// Walk ONE target's closure and check every call site in it. Returns the mismatch count, or 0-1 if the
1373// target resolves to no file. flag[0] = closure_complete.
1374// THREE passes, deliberately: the definition set must be COMPLETE before any call site is judged, or a
1375// call to a function defined in a not-yet-read import would be compared against nothing (silently clean)
1376// or against a stale entry. Reading each closure file twice more is cheap; judging early is not.
1377// RESOLVE THE WAY THE COMPILER BINDS, NOT IN A FIXED GLOBAL ORDER. Measured 2026-07-31: us_resolve takes
1378// only a NAME, so for a name that exists in BOTH runtime/ and _hdl_build/ it always returns the runtime/
1379// copy. nx_m2d_engine lives in _hdl_build/ and is written against _hdl_build/nx_input_abstract.nx
1380// (ia_init with 2 params, ia_bind with 4); the fixed order handed it runtime/nx_input_abstract.nx
1381// (ia_init with 1, ia_bind with 3) and manufactured EIGHTEEN arity mismatches that are not defects.
1382// nx_cc binds the IMPORTER'S OWN DIRECTORY FIRST, so the answer it gives is the only one that matters.
1383// This preference is applied to the ARITY path only; the existing scan path is deliberately left alone
1384// (rule 19) and carries the same latent flaw -- filed separately, with this reproducer.
1385func us_resolve_pref(path: *u8, nm: *u8, pref: *u8) -> i64 {
  if pref[0] != (0 as u8) {
      us_path(path, pref, nm)
      if us_exists(path) == 1 { return 1 }
  }
  return us_resolve(path, nm)
1391}
1392
1393// Which directory does this target itself live in? Probed in BUILD-TARGET rank order (_hdl_build first),
1394// because that is the copy /api/build compiles, and the closure must be read against the same tree the
1395// artifact was produced from.
1396func us_rootdir(nm: *u8, path: *u8) -> *u8 {
  us_path(path, US_HDDIR, nm)
  if us_exists(path) == 1 { return US_HDDIR }
  us_path(path, US_RTDIR, nm)
  if us_exists(path) == 1 { return US_RTDIR }
  us_path(path, US_HUBDIR, nm)
  if us_exists(path) == 1 { return US_HUBDIR }
  us_path(path, US_WIKIDIR, nm)
  if us_exists(path) == 1 { return US_WIKIDIR }
  return "" as *u8
1406}
1407
1408func us_arity_one(name: *u8, flag: *i64) -> i64 {
  let q: *u8 = sys_mmap(US_MAXF * US_NAMELEN)
  let defs: *u8 = sys_mmap(US_SLOTS * US_NAMELEN)
  let calls: *u8 = sys_mmap(US_SLOTS * US_NAMELEN)
  let refs: *u8 = sys_mmap(US_SLOTS * US_NAMELEN)
  let defar: *i64 = sys_mmap(US_SLOTS * 8) as *i64
  let path: *u8 = sys_mmap(US_PATHBUF)
  let lb: *i64 = sys_mmap(16) as *i64
1416
  // mmap gives ZEROED memory and zero is a LEGITIMATE arity, so the unknown state must be written
  // explicitly. Leaving it zeroed would silently claim every never-declared name takes no arguments.
  var z: i64 = 0
  while z < US_SLOTS { defar[z] = US_ARUNK; z = z + 1 }
1421
  flag[0] = 1
  // ONE resolution rule for the whole organ: per-importer, exactly as us_resolve_dir documents. The
  // root-directory approximation this path used first was closer than the fixed global order but still
  // wrong for a mixed closure (a runtime/ file importing runtime/hub/ importing a shadowed name).
  let qdir: *i64 = sys_mmap(US_MAXF * 8) as *i64
  var qd: i64 = 0
  while qd < US_MAXF { qdir[qd] = 0 - 1; qd = qd + 1 }
  var nl: i64 = 0
  while name[nl] != (0 as u8) { nl = nl + 1 }
  var qcnt: i64 = us_qpush(q, 0, name, nl)
  var head: i64 = 0
  var rc: i64 = 0
1434
  while head < qcnt {
      let nm: *u8 = us_slot(q, head)
      let did: i64 = us_resolve_dir(path, nm, qdir[head])
      if did < 0 {
          if head == 0 { rc = 0 - 1 }
          flag[0] = 0
      } else {
          lb[0] = 0
          let buf: *u8 = sys_read_file(path, lb)
          if lb[0] <= 0 { flag[0] = 0 } else {
              let before: i64 = qcnt
              qcnt = us_scan(buf, lb[0], defs, calls, refs, q, qcnt)
              var kid: i64 = before
              while kid < qcnt { qdir[kid] = did; kid = kid + 1 }
              sys_munmap(buf, lb[0])
          }
      }
      head = head + 1
      if qcnt >= US_MAXF { flag[0] = 0 }
  }
1455
  var decls: i64 = 0
  var bad: i64 = 0
  if rc == 0 {
      var h2: i64 = 0
      while h2 < qcnt {
          let nm2: *u8 = us_slot(q, h2)
          if us_resolve_dir(path, nm2, qdir[h2]) >= 0 {
              lb[0] = 0
              let b2: *u8 = sys_read_file(path, lb)
              if lb[0] > 0 {
                  decls = decls + us_collect_arity(b2, lb[0], defs, defar)
                  sys_munmap(b2, lb[0])
              }
          }
          h2 = h2 + 1
      }
      var h3: i64 = 0
      while h3 < qcnt {
          let nm3: *u8 = us_slot(q, h3)
          if us_resolve_dir(path, nm3, qdir[h3]) >= 0 {
              lb[0] = 0
              let b3: *u8 = sys_read_file(path, lb)
              if lb[0] > 0 {
                  bad = bad + us_check_arity(b3, lb[0], defs, defar, nm3)
                  sys_munmap(b3, lb[0])
              }
          }
          h3 = h3 + 1
      }
  }
1486
  flag[1] = decls
  flag[2] = qcnt
  sys_munmap(q, US_MAXF * US_NAMELEN)
  sys_munmap(defs, US_SLOTS * US_NAMELEN)
  sys_munmap(calls, US_SLOTS * US_NAMELEN)
  sys_munmap(refs, US_SLOTS * US_NAMELEN)
  sys_munmap(defar, US_SLOTS * 8)
  sys_munmap(qdir, US_MAXF * 8)
  if rc < 0 { return 0 - 1 }
  return bad
1497}
1498
1499
1500func main(argc: i64, argv: *i64) -> i64 {
  if argc < 3 {
      us_puts("usage: nx_undefscan scan <target>   (basename WITHOUT .nx)\n" as *u8)
      us_puts("  Walks the import closure and prints every called-but-undefined function.\n" as *u8)
      us_puts("  exit 0 CLEAN+COMPLETE | 1 UNDEFINED | 3 not found | 5 PARTIAL (cannot certify)\n" as *u8)
      return US_EXIT_USAGE
  }
  let verb: *u8 = argv[1] as *u8
  var vn: i64 = 0
  while verb[vn] != (0 as u8) { vn = vn + 1 }
  if us_eqlit(verb, vn, "sweep" as *u8, 5) == 1 {
      if argc < 5 {
          us_puts("usage: nx_undefscan sweep <dir> <offset> <limit>\n" as *u8)
          return US_EXIT_USAGE
      }
      let sbi: *u8 = sys_mmap(US_SLOTS * US_NAMELEN)
      us_load_builtins(sbi)
      var o0: i64 = 0
      let os: *u8 = argv[3] as *u8
      var oi: i64 = 0
      while os[oi] != (0 as u8) { o0 = o0 * 10 + ((os[oi] as i64) - 48); oi = oi + 1 }
      var lm: i64 = 0
      let ls: *u8 = argv[4] as *u8
      var li: i64 = 0
      while ls[li] != (0 as u8) { lm = lm * 10 + ((ls[li] as i64) - 48); li = li + 1 }
      us_sweep(argv[2] as *u8, o0, lm, sbi)
      return 0
  }
1528
  if us_eqlit(verb, vn, "arity" as *u8, 5) == 1 {
      us_puts("nx_undefscan arity -- CALL-SITE ARITY, SCOPED TO THE IMPORT CLOSURE\n" as *u8)
      let sf: i64 = us_arity_selftest()
      if sf > 0 {
          us_puts("REFUSED: the counter failed its own self-test -- a corpus number from it would be noise\n" as *u8)
          return US_EXIT_SELFTEST
      }
      let aflag: *i64 = sys_mmap(32) as *i64
      let bad: i64 = us_arity_one(argv[2] as *u8, aflag)
      if bad < 0 {
          us_puts("NOT-FOUND: no such target in runtime/ or _hdl_build/: " as *u8)
          us_puts(argv[2] as *u8)
          us_puts("\n" as *u8)
          return US_EXIT_NOTFOUND
      }
      us_puts("target=" as *u8)
      us_puts(argv[2] as *u8)
      us_puts(" closure_files=" as *u8)
      us_puti(aflag[2])
      us_puts(" funcs_with_arity=" as *u8)
      us_puti(aflag[1])
      us_puts(" arity_mismatches=" as *u8)
      us_puti(bad)
      us_puts("\n" as *u8)
      if aflag[0] == 0 {
          us_puts("PARTIAL: an import in the closure could not be read, so the declaration set is INCOMPLETE.\n" as *u8)
          us_puts("  A zero here would be a claim this scan cannot support. Fix the closure, then re-run.\n" as *u8)
          return US_EXIT_PARTIAL
      }
      if bad > 0 { return US_EXIT_UNDEF }
      return 0
  }
1561
  if us_eqlit(verb, vn, "dupescan" as *u8, 8) == 1 {
      let n: i64 = us_dupescan(argv[2] as *u8)
      us_puts("dupescan_artifacts=" as *u8)
      us_puti(n)
      us_puts("\n" as *u8)
      return 0
  }
1569
  let target: *u8 = argv[2] as *u8
  var corpus: i64 = 0
  if argc > 3 {
      let a3: *u8 = argv[3] as *u8
      var a3n: i64 = 0
      while a3[a3n] != (0 as u8) { a3n = a3n + 1 }
      if us_eqlit(a3, a3n, "corpus" as *u8, 6) == 1 { corpus = 1 }
  }
1578
  let q: *u8 = sys_mmap(US_MAXF * US_NAMELEN)
  let defs: *u8 = sys_mmap(US_SLOTS * US_NAMELEN)
  let calls: *u8 = sys_mmap(US_SLOTS * US_NAMELEN)
  let refs: *u8 = sys_mmap(US_SLOTS * US_NAMELEN)
  let und: *u8 = sys_mmap(US_MAXF * US_NAMELEN)
  let usrc: *u8 = sys_mmap(US_MAXF * US_NAMELEN)
  let path: *u8 = sys_mmap(US_PATHBUF)
  let lenbox: *i64 = sys_mmap(16) as *i64
  let bi: *u8 = sys_mmap(US_SLOTS * US_NAMELEN)
  let nbi: i64 = us_load_builtins(bi)
1589
  var tn: i64 = 0
  while target[tn] != (0 as u8) { tn = tn + 1 }
  var qcnt: i64 = us_qpush(q, 0, target, tn)
  if qcnt == 0 {
      us_puts("REFUSED: target name empty or longer than the name buffer\n" as *u8)
      return US_EXIT_USAGE
  }
1597
  var missing: i64 = 0
  var overflow: i64 = 0
  var hasmain: i64 = 0
  var head: i64 = 0
  var files: i64 = 0
  let qdir: *i64 = sys_mmap(US_MAXF * 8) as *i64
  var qd: i64 = 0
  while qd < US_MAXF { qdir[qd] = 0 - 1; qd = qd + 1 }
1606
  while head < qcnt {
      let nm: *u8 = us_slot(q, head)
      let did: i64 = us_resolve_dir(path, nm, qdir[head])
      if did < 0 {
          if head == 0 {
              us_puts("NOT-FOUND: no such target in runtime/ or _hdl_build/: " as *u8)
              us_puts(nm)
              us_puts("\n" as *u8)
              return US_EXIT_NOTFOUND
          }
          us_puts("MISSING-IMPORT " as *u8)
          us_puts(nm)
          us_puts("\n" as *u8)
          missing = missing + 1
      } else {
          lenbox[0] = 0
          let buf: *u8 = sys_read_file(path, lenbox)
          if lenbox[0] <= 0 {
              us_puts("UNREADABLE " as *u8)
              us_puts(nm)
              us_puts("\n" as *u8)
              missing = missing + 1
          } else {
              let before: i64 = qcnt
              qcnt = us_scan(buf, lenbox[0], defs, calls, refs, q, qcnt)
              // Children inherit THIS file's directory as their binding preference (see us_resolve_dir).
              var kid: i64 = before
              while kid < qcnt { qdir[kid] = did; kid = kid + 1 }
              files = files + 1
              // Checked right after the ROOT file and before any import is scanned, so defs holds only
              // this file's declarations and the answer is exact. CLEAN means every symbol resolves --
              // NOT that the target builds. A no-main LIBRARY is legitimately CLEAN and still fails to
              // compile standalone with 'UNDEFINED label: main'. Measured on nx_denoise_spectral, where
              // reading CLEAN as should-build would have sent the next reader hunting a phantom defect.
              if head == 0 { hasmain = us_has(defs, "main" as *u8, 4) }
          }
      }
      head = head + 1
      if qcnt >= US_MAXF { overflow = 1 }
  }
1647
  var undef: i64 = 0
  var bicount: i64 = 0
  var undcnt: i64 = 0
  var intrin: i64 = 0
  var s: i64 = 0
  while s < US_SLOTS {
      let p: *u8 = us_slot(calls, s)
      if p[0] != (0 as u8) {
          var L: i64 = 0
          while p[L] != (0 as u8) { L = L + 1 }
          if us_has(defs, p, L) == 0 {
              if us_has(bi, p, L) == 1 { bicount = bicount + 1 } else {
              if us_is_dunder(p) == 1 { intrin = intrin + 1 } else {
                  undcnt = us_qpush(und, undcnt, p, L)
                  undef = undef + 1
              } }
          }
      }
      s = s + 1
  }
1668
  // SECOND CLASS: an identifier that is never called, never declared, and provided by nothing. This is
  // the class that made an earlier build of this organ report CLEAN on nx_fnet_mix while nx_cc failed
  // with UNRESOLVED identifier NX_FFT_Q -- a false clean, the exact lie this instrument exists to stop.
  var undefid: i64 = 0
  var r: i64 = 0
  while r < US_SLOTS {
      let p: *u8 = us_slot(refs, r)
      if p[0] != (0 as u8) {
          var L: i64 = 0
          while p[L] != (0 as u8) { L = L + 1 }
          if us_has(defs, p, L) == 0 {
              if us_has(bi, p, L) == 1 { bicount = bicount + 1 } else {
              if us_is_dunder(p) == 1 { intrin = intrin + 1 } else {
                  undcnt = us_qpush(und, undcnt, p, L)
                  undefid = undefid + 1
              } }
          }
      }
      r = r + 1
  }
1689
  // CLASSIFY, then print. A bare list of names invites the exact misreading that produced a wrong sev-8
  // filing today: 6 of 7 names were already importable and only 1 was unwritten.
  var cfiles: i64 = 0
  if corpus == 1 { if undcnt > 0 {
      cfiles = us_corpus_dir(US_RTDIR, und, undcnt, usrc)
      cfiles = cfiles + us_corpus_dir(US_HDDIR, und, undcnt, usrc)
      cfiles = cfiles + us_corpus_dir(US_HUBDIR, und, undcnt, usrc)
      cfiles = cfiles + us_corpus_dir(US_WIKIDIR, und, undcnt, usrc)
  } }
  var wiring: i64 = 0
  var unwritten: i64 = 0
  var u: i64 = 0
  while u < undcnt {
      let p: *u8 = us_slot(und, u)
      var L: i64 = 0
      while p[L] != (0 as u8) { L = L + 1 }
      if us_has(calls, p, L) == 1 { us_puts("UNDEFINED " as *u8) } else { us_puts("UNDEFINED-IDENT " as *u8) }
      us_putn(p, L)
      if corpus == 1 {
          let sp: *u8 = us_slot(usrc, u)
          if sp[0] == (0 as u8) {
              us_puts("  NOWHERE -- unwritten code\n" as *u8)
              unwritten = unwritten + 1
          } else {
              us_puts("  ELSEWHERE-IN " as *u8)
              us_puts(sp)
              us_puts(" -- MISSING IMPORT, not missing code\n" as *u8)
              wiring = wiring + 1
          }
      } else { us_puts("\n" as *u8) }
      u = u + 1
  }
  if corpus == 1 {
      us_puts("corpus_files=" as *u8)
      us_puti(cfiles)
      us_puts(" wiring_fixable=" as *u8)
      us_puti(wiring)
      us_puts(" unwritten=" as *u8)
      us_puti(unwritten)
      us_puts("\n" as *u8)
  }
  if undef + undefid > undcnt {
      us_puts("WARN undefined-list overflowed US_MAXF; listing is TRUNCATED\n" as *u8)
  }
1734
  us_puts("target=" as *u8)
  us_puts(target)
  us_puts(" closure_files=" as *u8)
  us_puti(files)
  us_puts(" missing_imports=" as *u8)
  us_puti(missing)
  us_puts(" undefined_funcs=" as *u8)
  us_puti(undef)
  us_puts(" undefined_idents=" as *u8)
  us_puti(undefid)
  us_puts(" intrinsic_presumed=" as *u8)
  us_puti(intrin)
  us_puts(" has_main=" as *u8)
  us_puti(hasmain)
  us_puts(" builtin_excluded=" as *u8)
  us_puti(bicount)
  us_puts(" builtins_loaded=" as *u8)
  us_puti(nbi)
  us_puts("\n" as *u8)
1754
  // THE TOOTH: a zero from an incomplete closure is not a clean bill. Report PARTIAL and exit nonzero
  // even when undefined==0, because the definitions that would have resolved these calls may live in
  // exactly the file that could not be read.
  if missing > 0 {
      us_puts("VERDICT=PARTIAL closure_complete=0 -- count is a FLOOR, not an answer\n" as *u8)
      if undef + undefid > 0 { return US_EXIT_UNDEF }
      return US_EXIT_PARTIAL
  }
  if overflow == 1 {
      us_puts("VERDICT=PARTIAL closure_complete=0 -- queue hit US_MAXF, closure truncated\n" as *u8)
      if undef + undefid > 0 { return US_EXIT_UNDEF }
      return US_EXIT_PARTIAL
  }
  if undef + undefid > 0 {
      us_puts("VERDICT=UNDEFINED-SYMBOLS closure_complete=1\n" as *u8)
      return US_EXIT_UNDEF
  }
  us_puts("VERDICT=CLEAN closure_complete=1\n" as *u8)
  return 0
1774}
nx_undefscan.nx source

`nx_undefscan.nx` source
