`nx_unwired.nx` source

↩ module page · 540 lines · 28000 B
1// nx_unwired.nx -- FIND EVERY FUNCTION THAT IS DEFINED AND NEVER CALLED, ACROSS THE WHOLE TREE.
2//
3// WHY THIS IS AN ORGAN AND NOT A NOTE
4// -----------------------------------
5// On 2026-08-07 I fixed a measurement leak in nx_memroot, wrote the fix, built it, deployed it,
6// measured the "result", and recorded it in memory. `mr_body` was DEFINED AND NEVER CALLED. Two
7// string-replacements had matched nothing and reported success. The gate was green because the gate
8// had gone green before the tooth existed.
9//
10// ★★★★★★ A FUNCTION DEFINED AND NEVER CALLED IS A COMMENT.
11// ★★★★★ A STRING REPLACE THAT MATCHES NOTHING IS A NO-OP THAT REPORTS SUCCESS -- VERIFY THE CALL
12//        SITE, NOT THE DEFINITION.
13//
14// The estate already had vocabulary for this failure -- BUILT+UNWIRED, "comments not code", the
15// adoption gap -- written down in several memory files. It was written down and it still happened,
16// three times in one session, because a law in a file is consulted at the rate advice is consulted.
17// ★★★★★★ A LAW THAT IS ONLY WRITTEN DOWN IS ENFORCED AT THE RATE PEOPLE REMEMBER TO READ IT; THE SAME
18// LAW COMPILED INTO A GATE IS ENFORCED EVERY TIME.
19//
20// FULL ECOSYSTEM SCOPE, NOT A SAMPLE: every `.nx` in the tree is both a definition source and a call
21// source, so a helper used only by a sibling organ is correctly seen as WIRED. Reporting on one file
22// would manufacture false positives for every library function.
23// ★★★★★ A REACHABILITY QUESTION ASKED OF ONE FILE IS ANSWERED WRONG BY CONSTRUCTION.
24//
25// usage: nx_unwired [--dir D] [--quiet]
26// exit:  0 = nothing unwired; 1 = unwired definitions exist
27// license_tier: ORIGINAL
28import "nx_memplane_lib.nx"
29import "nx_gatekit_lib.nx"
30const UW_MAGIC_2166136261: i64 = 2166136261
31const UW_MAGIC_16777619: i64 = 16777619
32const UW_MAGIC_1073741823: i64 = 1073741823
33const UW_MAGIC_8192: i64 = 8192
34const UW_MAGIC_4096: i64 = 4096
35const UW_MAGIC_262144: i64 = 262144
36const UW_MAGIC_262000: i64 = 262000
37
38// ⚠ UW_DIR IS NO LONGER THE CORPUS. It scanned _hdl_build ONLY -- 7,159 of 18,559 files, 38.6% --
39// while the header above claimed "every .nx in the tree". Because the unscanned files are BOTH
40// definition sources AND call sources, that truncation was wrong in both directions at once:
41// 30 names were reported UNWIRED that ARE called in files it never opened, and 3,379 definitions
42// in those files were never examined. The corpus now comes from gk_corpus_scan, the estate's one
43// definition of "the tree" (see nx_gatekit_lib), so this organ and gk_srcpath cannot disagree.
44// ★★★★★★ A CENSUS IS ONLY AS HONEST AS ITS DENOMINATOR, AND THE DENOMINATOR BELONGS IN ONE PLACE.
45const UW_DIR:   *u8 = "/mnt/c/Users/elder/nishi-core/nxc2/runtime/_hdl_build/"
46const UW_MAXF:  i64 = 32768       // corpus is 18,560 today; 16,384 would REFUSE, which is why it rose
47const UW_HASH:  i64 = 262144      // identifier -> slot (power of two)
48const UW_FBUF:  i64 = 4194304
49const UW_NAMEB: i64 = 1048576     // packed definition names
50
51import "nx_headmark_lib.nx"
52func uw_h(s: *u8, n: i64) -> i64 {
  var h: i64 = UW_MAGIC_2166136261
  var i: i64 = 0
  while i < n {
      h = h ^ (s[i] as i64)
      h = (h * UW_MAGIC_16777619) & UW_MAGIC_1073741823
      i = i + 1
  }
  if h == 0 { h = 1 }
  return h
62}
63
64func uw_slot(keys: *i64, h: i64) -> i64 {
  var p: i64 = h & (UW_HASH - 1)
  var tries: i64 = 0
  var res: i64 = 0 - 1
  var go: i64 = 1
  while go == 1 {
      if tries >= 64 { go = 0 }
      if go == 1 {
          if keys[p] == 0 { keys[p] = h; res = p; go = 0 }
          if go == 1 {
              if keys[p] == h { res = p; go = 0 }
              if go == 1 { p = (p + 1) & (UW_HASH - 1); tries = tries + 1 }
          }
      }
  }
  return res
80}
81
82// Does the file DECLARE ITSELF a generated artifact? Checked in the head only, where such banners
83// live, so the word appearing later in ordinary prose cannot misclassify a hand-written organ.
84//
85// WHY THIS IS ITS OWN BUCKET: nx_shapeprobe_cand.nx is a codegen-shape reproducer holding 1,002
86// machine-emitted `sp2_N` functions, 265 of which the census counted as UNWIRED -- 17% of the entire
87// backlog. They are not an adoption gap: the file exists precisely to compile shapes nothing calls.
88// Counting them inflates the worklist; silently dropping them would hide real defects in generated
89// code. ★★★★★★ TWO CAUSES WITH OPPOSITE REMEDIES MUST NEVER SHARE A COUNTER -- REPORT BOTH, RATCHET
90//        ONLY THE ONE A HUMAN CAN ACT ON.
91// The artifact declares itself, which is the estate's own rule for generated output.
92
93
94// A DEFINITION-COMPLETE library is one whose uncalled state is CORRECT: an ISA encoder with one
95// function per instruction, an opcode/codec table, a protocol constant set. `nxasm_arm64_enc.nx`
96// holds 45 A64 encoders of which 24 are uncalled because the aarch64 backend is still being built --
97// deleting them would strip the capability under construction (rule 25).
98// ★★★★★★ AN ISA ENCODER OR TABLE LIBRARY IS DEFINITION-COMPLETE BY DESIGN, NOT CALL-COMPLETE, AND A
99//        REACHABILITY RATCHET READS ITS CORRECT STEADY STATE AS DEBT.
100//
101// THIS IS A DECLARATION, NOT A DETECTOR, AND THAT IS THE WHOLE POINT. A heuristic that guessed at
102// "looks like a table" would gate a DESTRUCTIVE remedy, and a heuristic gating deletion must be wrong
103// in the direction of doing nothing -- so there is no heuristic. The file says so itself, exactly as
104// generated artifacts do. ★★★★★ THE ARTEFACT MUST DECLARE ITSELF; A CENTRAL LIST ALWAYS LAGS THE TREE.
105func uw_defcomplete(buf: *u8, n: i64) -> i64 {
  return uw_headmark(buf, n, "DEFINITION-COMPLETE" as *u8, 19)
107}
108
109// An EXPORTED-ENTRYPOINTS file's functions are called from OUTSIDE the .nx corpus -- wasm exports
110// invoked by the browser, handlers dispatched by name, ABI shims called by the loader. The census
111// only ever sees .nx call sites, so their caller is structurally invisible to it and "uncalled" is
112// their correct steady state.
113// ★★★★★★ A REACHABILITY CENSUS CAN ONLY SEE THE CALLERS INSIDE ITS OWN CORPUS; A FUNCTION CALLED FROM
114//        OUTSIDE IT IS INVISIBLY WIRED, AND COUNTING IT AS DEBT INVITES DELETING A LIVE ENTRY POINT.
115// A separate marker from DEFINITION-COMPLETE on purpose: those are "not called YET" (a backend under
116// construction), these are "called, but not from here". Same symptom, different truth, different
117// remedy. ★★★★★ A BUCKET NAMED FOR HOW THE READER FAILED MERGES A REAL FAILURE WITH A HEALTHY PASS.
118func uw_exported(buf: *u8, n: i64) -> i64 {
  return uw_headmark(buf, n, "EXPORTED-ENTRYPOINTS" as *u8, 20)
120}
121
122func uw_isid(c: i64) -> i64 {
  if c >= 97 { if c <= 122 { return 1 } }
  if c >= 65 { if c <= 90 { return 1 } }
  if c >= 48 { if c <= 57 { return 1 } }
  if c == 95 { return 1 }
  return 0
128}
129
130// is the file a .nx source?
131func uw_isnx(name: *u8) -> i64 {
  let l: i64 = mp_len(name)
  if l < 4 { return 0 }
  if name[l - 3] != (46 as u8) { return 0 }
  if name[l - 2] != (110 as u8) { return 0 }
  if name[l - 1] != (120 as u8) { return 0 }
  return 1
138}
139
140// mp_scan hard-filters to .md (it is the memory-plane scanner), so a source tree needs its own walk.
141// ★ A SCANNER NAMED FOR A GENERAL ACTION MAY CARRY A SPECIFIC FILTER -- READ IT BEFORE REUSING IT.
142
143
144func main(argc: i64, argv: *i64) -> i64 {
  var dir: *u8 = UW_DIR
  var dirset: i64 = 0
  var trace: i64 = 0
  var quiet: i64 = 0
  var accept: i64 = 0
  var a: i64 = 1
  while a < argc {
      let s: *u8 = argv[a] as *u8
      if mp_streq(s, "--dir" as *u8) == 1 { if a + 1 < argc { dir = argv[a + 1] as *u8; dirset = 1; a = a + 1 } }
      if mp_streq(s, "--quiet" as *u8) == 1 { quiet = 1 }
      if mp_streq(s, "--trace" as *u8) == 1 { trace = 1 }
      if mp_streq(s, "--accept" as *u8) == 1 { accept = 1 }
      a = a + 1
  }
159
  let msg: *u8 = sys_mmap(UW_MAGIC_8192)
  let names: *u8 = sys_mmap(UW_MAXF * 128)
  let ntbl:  *i64 = sys_mmap(8 * UW_MAGIC_8192) as *i64
  let fbuf:  *u8 = sys_mmap(UW_FBUF)
  let path:  *u8 = sys_mmap(UW_MAGIC_4096)
165
  let keys:  *i64 = sys_mmap(8 * UW_HASH) as *i64
  let uses:  *i64 = sys_mmap(8 * UW_HASH) as *i64
  let defat: *i64 = sys_mmap(8 * UW_HASH) as *i64   // slot -> offset into nameb, +1 (0 = not a def)
  let deffl: *i64 = sys_mmap(8 * UW_HASH) as *i64   // slot -> file index
  let genf:  *i64 = sys_mmap(8 * UW_MAXF) as *i64   // file index -> 1 if self-declared generated
  let dcf:   *i64 = sys_mmap(8 * UW_MAXF) as *i64   // file index -> 1 if self-declared DEFINITION-COMPLETE
  let expf:  *i64 = sys_mmap(8 * UW_MAXF) as *i64   // file index -> 1 if self-declared EXPORTED-ENTRYPOINTS
  let nameb: *u8 = sys_mmap(UW_NAMEB)
  var nbo: i64 = 1
175
  // THE CORPUS. Default is the whole compile corpus (both source directories, _hdl_build
  // overlaying runtime, exactly as gk_srcpath resolves a target). --dir narrows it deliberately;
  // the narrowing is then VISIBLE in the output rather than baked into a constant nobody reads.
  var cnt: i64 = 0
  if dirset == 0 { cnt = gk_corpus_scan(names, MP_SLOT, UW_MAXF) }
  if dirset == 1 { cnt = gk_dirscan(dir, 0 as *u8, names, MP_SLOT, UW_MAXF, 0) }
182
  if cnt == (0 - 2) {
      var m2: i64 = mp_cat(msg, 0, "*** nx_unwired: REFUSED -- the corpus exceeds UW_MAXF (" as *u8)
      m2 = mp_catn(msg, m2, UW_MAXF)
      m2 = mp_cat(msg, m2, "). Raise it. A truncated census under-reports unwired functions AND invents them. ***\n" as *u8)
      mp_say(msg, m2)
      return 1
  }
  if cnt == (0 - 3) {
      var m3: i64 = mp_cat(msg, 0, "*** nx_unwired: REFUSED -- a source path is longer than the name slot. ***\n" as *u8)
      mp_say(msg, m3)
      return 1
  }
  if cnt <= 0 {
      var me: i64 = mp_cat(msg, 0, "*** nx_unwired: REFUSED -- could not scan the source tree. ***\n" as *u8)
      mp_say(msg, me)
      return 1
  }
  // A CENSUS THAT HIT ITS CAP IS NOT A CENSUS. The first run reported "4096 sources" against a tree
  // of 7,113 -- 58% coverage presented as a complete answer, with no indication anything was
  // dropped. A partial count is more dangerous than no count, because it reads as authoritative.
  // ★★★★★★ A CAP REACHED IN SILENCE BECOMES A MEASUREMENT NOBODY KNOWS IS PARTIAL -- REFUSE, OR SAY
  // WHAT YOU DROPPED, BUT NEVER RETURN A TRUNCATED TOTAL WEARING A COMPLETE ONE'S CLOTHES.
  // (The cap check that used to live here now lives INSIDE gk_corpus_scan and returns -2, handled
  // above. It moved because the refusal must belong to the enumerator, not to each of its callers:
  // ★★★★★ A SAFETY CHECK RE-IMPLEMENTED BY EVERY CALLER IS A SAFETY CHECK SOME CALLER WILL OMIT.)
  var mcorp: i64 = mp_cat(msg, 0, "  corpus=" as *u8)
  mcorp = mp_catn(msg, mcorp, cnt)
  if dirset == 0 { mcorp = mp_cat(msg, mcorp, " files (WHOLE compile corpus: runtime/_hdl_build + runtime)\n" as *u8) }
  if dirset == 1 { mcorp = mp_cat(msg, mcorp, " files (NARROWED by --dir; this is NOT the whole tree)\n" as *u8) }
  mp_say(msg, mcorp)
213
  var nfiles: i64 = 0
  var ndefs: i64 = 0
216
  // ---- one pass: record every `func NAME(` definition AND count every identifier occurrence ----
  var fi: i64 = 0
  while fi < cnt {
      // The corpus scanner returns ABSOLUTE paths, so there is no dir to re-join here. That join
      // was the seam where a second directory could not be represented at all.
      let nm: *u8 = mp_nameptr(names, fi)
      if trace == 1 {
          var mt: i64 = mp_cat(msg, 0, "TRACE " as *u8)
          mt = mp_catn(msg, mt, fi)
          mt = mp_cat(msg, mt, " " as *u8)
          mt = mp_cat(msg, mt, nm)
          mt = mp_cat(msg, mt, "\n" as *u8)
          mp_say(msg, mt)
      }
      if uw_isnx(nm) == 1 {
          let n: i64 = mp_readf(nm, fbuf, UW_FBUF)
          if n > 0 {
              nfiles = nfiles + 1
              genf[fi] = uw_generated(fbuf, n)
              dcf[fi]  = uw_defcomplete(fbuf, n)
              expf[fi] = uw_exported(fbuf, n)
              var i: i64 = 0
              while i < n {
                  if uw_isid(fbuf[i] as i64) == 1 {
                      // FLAG-TERMINATED. The sentinel form (`e = n + 9`) writes the exit marker into
                      // the cursor and the restore lands on `n`, so every identifier "extends to end
                      // of file" -- one token per file, zero definitions found. This is the FOURTH
                      // time that idiom has cost a defect in one session, and it happened here while
                      // writing the organ whose whole purpose is catching unverified changes.
                      // ★★★★★★ THE IDIOM YOU KEEP FIXING BY HAND IS THE ONE THAT WILL BITE YOU INSIDE
                      // THE TOOL YOU BUILT TO CATCH IT.
                      var e: i64 = i
                      var fin: i64 = 0
                      while fin == 0 {
                          if e >= n { fin = 1 }
                          if fin == 0 {
                              if uw_isid(fbuf[e] as i64) == 1 { e = e + 1 }
                              if uw_isid(fbuf[e] as i64) == 0 { fin = 1 }
                          }
                      }
                      let idl: i64 = e - i
                      // must start with a letter or underscore, not a digit
                      var okstart: i64 = 0
                      let c0: i64 = fbuf[i] as i64
                      if c0 == 95 { okstart = 1 }
                      if c0 >= 97 { if c0 <= 122 { okstart = 1 } }
                      if c0 >= 65 { if c0 <= 90 { okstart = 1 } }
                      if okstart == 1 {
                          if idl > 1 {
                              let h: i64 = uw_h(((fbuf as i64) + i) as *u8, idl)
                              let sl: i64 = uw_slot(keys, h)
                              if sl >= 0 {
                                  uses[sl] = uses[sl] + 1
                                  // a DEFINITION is `func` + space + this identifier
                                  var isdef: i64 = 0
                                  if i >= 5 {
                                      if fbuf[i - 1] == (32 as u8) {
                                          if fbuf[i - 2] == (99 as u8) {
                                              if fbuf[i - 3] == (110 as u8) {
                                                  if fbuf[i - 4] == (117 as u8) {
                                                      if fbuf[i - 5] == (102 as u8) { isdef = 1 }
                                                  }
                                              }
                                          }
                                      }
                                  }
                                  if isdef == 1 {
                                      if defat[sl] == 0 {
                                          if nbo + idl + 2 < UW_NAMEB {
                                              var q: i64 = 0
                                              while q < idl { nameb[nbo + q] = fbuf[i + q]; q = q + 1 }
                                              nameb[nbo + idl] = 0 as u8
                                              defat[sl] = nbo
                                              deffl[sl] = fi
                                              nbo = nbo + idl + 1
                                              ndefs = ndefs + 1
                                          }
                                      }
                                  }
                              }
                          }
                      }
                      i = e
                  }
                  if uw_isid(fbuf[i] as i64) == 0 { i = i + 1 }
              }
          }
      }
      fi = fi + 1
  }
307
  // ---- report: a definition whose identifier occurs exactly once is never called ----
  var nunwired: i64 = 0
  var ngen: i64 = 0
  var ndc: i64 = 0         // unwired inside SELF-DECLARED DEFINITION-COMPLETE libraries
  var nexp: i64 = 0        // unwired inside SELF-DECLARED EXPORTED-ENTRYPOINTS files        // unwired inside SELF-DECLARED GENERATED files -- reported, never ratcheted
  var m: i64 = 0
  var sl2: i64 = 0
  while sl2 < UW_HASH {
      if defat[sl2] != 0 {
          // `main` is called by the runtime, not by source
          let dn: *u8 = ((nameb as i64) + defat[sl2]) as *u8
          var skip: i64 = 0
          if mp_streq(dn, "main" as *u8) == 1 { skip = 1 }
          if skip == 0 { if uses[sl2] <= 1 { if genf[deffl[sl2]] == 1 { ngen = ngen + 1; skip = 1 } } }
          if skip == 0 { if uses[sl2] <= 1 { if dcf[deffl[sl2]] == 1 { ndc = ndc + 1; skip = 1 } } }
          if skip == 0 { if uses[sl2] <= 1 { if expf[deffl[sl2]] == 1 { nexp = nexp + 1; skip = 1 } } }
          if skip == 0 {
              if uses[sl2] <= 1 {
                  nunwired = nunwired + 1
                  if quiet == 0 {
                      m = mp_cat(msg, 0, "  UNWIRED  " as *u8)
                      m = mp_cat(msg, m, dn)
                      m = mp_cat(msg, m, "   defined in " as *u8)
                      m = mp_cat(msg, m, mp_nameptr(names, deffl[sl2]))
                      m = mp_cat(msg, m, "  -- never called anywhere in the tree\n" as *u8)
                      mp_say(msg, m)
                  }
              }
          }
      }
      sl2 = sl2 + 1
  }
340
  m = mp_cat(msg, 0, "nx_unwired: " as *u8)
  m = mp_catn(msg, m, nfiles)
  m = mp_cat(msg, m, " sources, " as *u8)
  m = mp_catn(msg, m, ndefs)
  m = mp_cat(msg, m, " functions, " as *u8)
  m = mp_catn(msg, m, nunwired)
  m = mp_cat(msg, m, " UNWIRED (authored)" as *u8)
  m = mp_cat(msg, m, ", " as *u8)
  m = mp_catn(msg, m, ngen)
  m = mp_cat(msg, m, " more in self-declared GENERATED files (reported, not ratcheted -- a codegen reproducer is meant to hold uncalled shapes)" as *u8)
  m = mp_cat(msg, m, ", " as *u8)
  m = mp_catn(msg, m, ndc)
  m = mp_cat(msg, m, " in self-declared DEFINITION-COMPLETE libraries (an ISA/table library is correct while uncalled)" as *u8)
  m = mp_cat(msg, m, ", " as *u8)
  m = mp_catn(msg, m, nexp)
  m = mp_cat(msg, m, " in self-declared EXPORTED-ENTRYPOINTS files (called from outside the .nx corpus, so invisibly wired)" as *u8)
357
  // ---- RATCHET, not a threshold ----
  // 396 pre-existing unwired functions cannot be a pass/fail gate: it would sit RED forever and be
  // ignored within a day. What IS enforceable is the DIRECTION -- the count may never rise, and when
  // it falls the ceiling follows it down so the gain can never be given back.
  // ★★★★★ A DETECTOR THAT IS PERMANENTLY RED IS A DETECTOR EVERYONE LEARNS TO IGNORE; RATCHET THE
  // DIRECTION INSTEAD OF DEMANDING PERFECTION ON DAY ONE.
  // ★★★★★ A RATCHET THAT DOES NOT TIGHTEN WHEN YOU IMPROVE IS JUST A THRESHOLD -- IT MUST FOLLOW THE
  // BEST RESULT DOWN, AUTOMATICALLY, OR THE NEXT REGRESSION HIDES INSIDE THE SLACK YOU EARNED.
  // THE BASELINE IS A SET OF NAMES, NOT A COUNT. This tree is shared and written concurrently:
  // mid-measurement, 9 organs from another seat appeared at once and the count rose by 2 through no
  // action of mine. A count-only ratchet would have reported MY run as the regression.
  // ★★★★★★ A COUNT-ONLY RATCHET ON A SHARED TREE REPORTS A REGRESSION WITHOUT SAYING WHOSE -- AND AN
  // ALARM YOU CANNOT ATTRIBUTE IS AN ALARM YOU WILL LEARN TO CLEAR WITHOUT READING.
  // Flush the summary before the diff so the per-line emitter below cannot interleave with a
  // half-built buffer, and so a crash after this point still leaves the totals on the record.
  mp_say(msg, m)
  m = 0
  let nbuf: *u8 = sys_mmap(UW_MAGIC_4096)
  // HOST-RESOLVED, not hardcoded: the baseline must live beside the tree it describes, or an
  // organ shipped to a second host silently ratchets against another machine's record.
  let bl: *u8 = sys_mmap(UW_MAGIC_4096)
  if gk_ops_path(bl, "unwired.baseline" as *u8) == 0 {
      var mb: i64 = mp_cat(msg, 0, "*** nx_unwired: REFUSED -- cannot resolve the baseline dir on this host. ***\n" as *u8)
      mp_say(msg, mb)
      return 1
  }
  let bb: *u8 = sys_mmap(UW_MAGIC_262144)
  let bn: i64 = mp_readf(bl, bb, UW_MAGIC_262000)
386
  // THE BASELINE RECORDS ITS OWN POPULATION, as a "# corpus=N" first line.
  // A ratchet compared across two different corpora is not a ratchet: it reports the RULER
  // changing as though the TREE had regressed. That is exactly how the single-directory census
  // stayed hidden for so long -- nothing anywhere declared what had actually been counted, so
  // 403-of-7,159 and 1,559-of-18,561 were silently comparable numbers.
  // ★★★★★★ A BASELINE THAT DOES NOT RECORD ITS DENOMINATOR CANNOT TELL A REGRESSION FROM A
  //        RE-MEASUREMENT, AND WILL CONFIDENTLY REPORT THE SECOND AS THE FIRST.
  var bcorp: i64 = 0
  if bn > 9 {
      if bb[0] == (35 as u8) {
          var ci: i64 = 9
          var cgo: i64 = 1
          while cgo == 1 {
              let d: i64 = bb[ci] as i64
              if d < 48 { cgo = 0 }
              if d > 57 { cgo = 0 }
              if cgo == 1 { bcorp = bcorp * 10 + (d - 48); ci = ci + 1 }
              if ci >= bn { cgo = 0 }
          }
      }
  }
  var popchanged: i64 = 0
  if bcorp > 0 { if bcorp != cnt { popchanged = 1 } }
410
  var rc: i64 = 0
  var nadd: i64 = 0
  var ngone: i64 = 0
414
  // mark every baseline name in a lookup so the diff is O(n)
  let bkeys: *i64 = sys_mmap(8 * UW_HASH) as *i64
  if bn > 0 {
      var p: i64 = 0
      while p < bn {
          var e2: i64 = p
          var f2: i64 = 0
          while f2 == 0 {
              if e2 >= bn { f2 = 1 }
              if f2 == 0 {
                  if bb[e2] == (10 as u8) { f2 = 1 }
                  if f2 == 0 { e2 = e2 + 1 }
              }
          }
          if e2 > p {
              let hh: i64 = uw_h(((bb as i64) + p) as *u8, e2 - p)
              let ss: i64 = uw_slot(bkeys, hh)
              if ss >= 0 { bkeys[ss] = hh }
          }
          p = e2 + 1
      }
  }
437
  // ADDED = unwired now, absent from the baseline. Those are the actionable ones.
  let outb: *u8 = sys_mmap(UW_MAGIC_262144)
  var oo: i64 = mp_cat(outb, 0, "# corpus=" as *u8)
  oo = mp_catn(outb, oo, cnt)
  oo = mp_cat(outb, oo, "\n" as *u8)
  var s3: i64 = 0
  while s3 < UW_HASH {
      if defat[s3] != 0 {
          let dn2: *u8 = ((nameb as i64) + defat[s3]) as *u8
          var sk: i64 = 0
          if mp_streq(dn2, "main" as *u8) == 1 { sk = 1 }
          // Generated files are reported but NEVER ratcheted: their contents churn wholesale every
          // time the generator runs, so a baseline over them is noise that buries real regressions.
          if sk == 0 { if genf[deffl[s3]] == 1 { sk = 1 } }
          if sk == 0 { if dcf[deffl[s3]] == 1 { sk = 1 } }
          if sk == 0 { if expf[deffl[s3]] == 1 { sk = 1 } }
          if sk == 0 {
              if uses[s3] <= 1 {
                  oo = mp_cat(outb, oo, dn2)
                  outb[oo] = 10 as u8
                  oo = oo + 1
                  if bn > 0 {
                      let h3: i64 = uw_h(dn2, mp_len(dn2))
                      var found: i64 = 0
                      var pp: i64 = h3 & (UW_HASH - 1)
                      var tr: i64 = 0
                      var go3: i64 = 1
                      while go3 == 1 {
                          if tr >= 64 { go3 = 0 }
                          if go3 == 1 {
                              if bkeys[pp] == 0 { go3 = 0 }
                              if go3 == 1 {
                                  if bkeys[pp] == h3 { found = 1; go3 = 0 }
                                  if go3 == 1 { pp = (pp + 1) & (UW_HASH - 1); tr = tr + 1 }
                              }
                          }
                      }
                      if found == 0 {
                          nadd = nadd + 1
                          // EMIT PER LINE, NEVER ACCUMULATE. This previously appended every entry
                          // into the 8 KB `msg` and flushed once at the end: ~150 B per entry, so
                          // it overflowed and SIGSEGV'd past ~54 additions. The organ therefore
                          // crashed precisely when a large regression appeared -- the one occasion
                          // its output mattered -- and looked perfectly healthy on small diffs.
                          // ★★★★★★ AN UNBOUNDED ACCUMULATOR SIZED BY THE HAPPY PATH FAILS ONLY ON
                          //        THE BAD NEWS IT EXISTS TO DELIVER.
                          var mn: i64 = mp_cat(nbuf, 0, "  *** NEWLY UNWIRED: " as *u8)
                          mn = mp_cat(nbuf, mn, dn2)
                          mn = mp_cat(nbuf, mn, "   in " as *u8)
                          mn = mp_cat(nbuf, mn, mp_nameptr(names, deffl[s3]))
                          mn = mp_cat(nbuf, mn, " ***\n" as *u8)
                          mp_say(nbuf, mn)
                      }
                  }
              }
          }
      }
      s3 = s3 + 1
  }
497
  if bn <= 0 { m = mp_cat(msg, m, "  (no baseline yet -- recording the current set)\n" as *u8) }
  if bn > 0 {
      if popchanged == 1 {
          m = mp_cat(msg, m, "\n  *** POPULATION CHANGED: baseline was taken over " as *u8)
          m = mp_catn(msg, m, bcorp)
          m = mp_cat(msg, m, " files, this run measured " as *u8)
          m = mp_catn(msg, m, cnt)
          m = mp_cat(msg, m, ". The names above are NOT attributable regressions -- they are what a different corpus makes visible. Re-baseline deliberately with --accept. ***\n" as *u8)
      }
      if nadd > 0 { if popchanged == 0 {
          m = mp_cat(msg, m, "\n  *** RED: " as *u8)
          m = mp_catn(msg, m, nadd)
          m = mp_cat(msg, m, " function(s) newly defined and never called -- named above, so the regression can be attributed. ***\n" as *u8)
          rc = 1
      } }
      if nadd == 0 { m = mp_cat(msg, m, "  GREEN: no NEW unwired function since the baseline.\n" as *u8) }
  }
  mp_say(msg, m)
516
  // The baseline only ever tightens on its own: it is rewritten when nothing new appeared, so a fixed
  // function can never be re-broken for free.
  //
  // --accept is the DELIBERATE act for adopting a regression you are not going to fix -- in a shared
  // tree most reds belong to another seat, and there has to be a way to acknowledge one without
  // either editing their code or leaving the roster permanently red.
  // ★★★★★ AN ALARM WITH NO ACKNOWLEDGE PATH IS CLEARED BY IGNORING IT, WHICH CLEARS EVERY OTHER ALARM
  // TOO. Make acknowledgement explicit, deliberate, and recorded -- never automatic.
  var writeit: i64 = 0
  if nadd == 0 { writeit = 1 }
  if accept == 1 { writeit = 1 }
  if writeit == 1 {
      let wf: i64 = sys_openat_wr(bl, 420)
      if wf >= 0 { mp_write_all(wf, outb, oo); sys_close(wf) }
      if accept == 1 { if nadd > 0 {
          var ma: i64 = mp_cat(msg, 0, "  ACCEPTED " as *u8)
          ma = mp_catn(msg, ma, nadd)
          ma = mp_cat(msg, ma, " into the baseline by explicit --accept (named above, so the record says what was adopted and by whom).\n" as *u8)
          mp_say(msg, ma)
          rc = 0
      } }
  }
  return rc
540}
nx_unwired.nx source

`nx_unwired.nx` source
