`nx_wpt_spine.nx` source

↩ module page · 243 lines · 9710 B
1// nx_wpt_spine.nx -- LIB: the shared TEST-TELEMETRY SPINE (2026-08-19). Extracted from
2// nx_wpt_runner v3 the day nx_wpt_reftest became its second consumer (the DRY law: the second
3// copy is where drift starts). One implementation of:
4//   - engine identity (sha256 of the calling binary itself, via /proc/self/exe),
5//   - deterministic corpus enumeration (sorted names) + content hash (name+NUL+bytes, sorted order),
6//   - the TSV history scan (newest row matching dir[/engine][/corpus]) + column reads,
7//   - the 16-hex truncated digest form (64 bits, DECLARED truncation),
8//   - history append.
9// Row schema (documented once, here, OTel CI/CD mapped): epoch_s(cicd.pipeline.run start)
10// col1=suite(test.suite name) col2=engine_sha16(service.version) col3=corpus_sha16(vcs.ref analog)
11// then consumer-declared counter columns, dur_ms, verdict LAST.
12// license_tier: ORIGINAL
13
14import "nx_syscalls.nx"
15import "nx_sha256.nx"
16
17// ---- THE FIELD SEPARATOR, ONE OWNER (2026-08-27) ------------------------------------------------
18// Operator standing rule: no TSV in the estate's data plane. Every other row file here -- .matrix,
19// .refs, .registry, .gates, .plan, .sow -- is PIPE delimited, and this spine was the one place still
20// emitting tabs, so its history was the odd artifact out for no reason anyone had chosen.
21// WSP_FS is what new rows are WRITTEN with. wsp_is_fs accepts EITHER separator on READ, deliberately:
22// the history already holds rows in the old shape and the regression detector reads them to find a
23// prior baseline. A reader that only accepted the new separator would silently lose that baseline and
24// report every run as a first run -- a format change that destroys the time spine it was meant to
25// tidy. Accepting both keeps every existing row readable while nothing new is ever written as TSV.
26// It lives HERE because this spine is the single reader shared by nx_wpt_runner and nx_wpt_reftest;
27// a separator defined in each writer would be two owners of one wire format, which is where drift
28// starts -- the same reason this file was extracted in the first place.
29// ALSO DEFINED ABOVE BOTH READERS ON PURPOSE: nx is single-pass, and wsp_hist_find splits fields too.
30const WSP_FS: i64 = 124
31const WSP_FS_LEGACY: i64 = 9
32func wsp_is_fs(c: i64) -> i64 {
  if c == WSP_FS { return 1 }
  if c == WSP_FS_LEGACY { return 1 }
  return 0
36}
37
38func wsp_scat(dst: *u8, off: i64, src: *u8) -> i64 { var i: i64 = 0; while src[i] != (0 as u8) { dst[off+i] = src[i]; i = i + 1 } return off + i }
39func wsp_scatn(dst: *u8, off: i64, src: *u8, n: i64) -> i64 { var i: i64 = 0; while i < n { dst[off+i] = src[i]; i = i + 1 } return off + n }
40func wsp_ends_with(s: *u8, n: i64, suf: *u8, sn: i64) -> i64 {
  if n < sn { return 0 }
  var i: i64 = 0
  while i < sn { if s[n-sn+i] != suf[i] { return 0 } i = i + 1 }
  return 1
45}
46func wsp_hex16(dig: *u8, out: *u8) -> i64 {
  let hx: *u8 = "0123456789abcdef" as *u8
  var i: i64 = 0
  while i < 8 {
      let b: i64 = dig[i] as i64
      out[i*2] = hx[b / 16]
      out[i*2+1] = hx[b % 16]
      i = i + 1
  }
  out[16] = 0 as u8
  return 16
57}
58// sha256(this very binary) as 16 hex chars. 0 ok / 1 cannot read self (caller must REFUSE an unkeyed run).
59func wsp_engine_sha(out: *u8) -> i64 {
  let lp: *i64 = sys_mmap(16) as *i64
  let b: *u8 = sys_read_file("/proc/self/exe" as *u8, lp)
  if (b as i64) == 0 { return 1 }
  let c: *Sha256 = sys_mmap(512) as *Sha256
  sha256_init(c)
  sha256_update(c, b, lp[0])
  let dig: *u8 = sys_mmap(40)
  sha256_final(c, dig)
  wsp_hex16(dig, out)
  sys_free_file(b, lp[0])
  return 0
71}
72func wsp_name_lt(a: *u8, b: *u8) -> i64 {
  var i: i64 = 0
  var going: i64 = 1
  var r: i64 = 0
  while going == 1 {
      let ca: i64 = a[i] as i64
      let cb: i64 = b[i] as i64
      if ca < cb { r = 1; going = 0 }
      if going == 1 { if ca > cb { r = 0; going = 0 } }
      if going == 1 { if ca == 0 { r = 0; going = 0 } }
      i = i + 1
  }
  return r
85}
86// every *.<suf> name in dir into namebuf (NUL-joined) + offs[], SORTED byte-wise. -1 = unreadable dir.
87func wsp_collect_names(dir: *u8, suf: *u8, namebuf: *u8, nbcap: i64, offs: *i64, maxn: i64) -> i64 {
  let fd: i64 = sys_openat_rd(dir)
  if fd < 0 { return 0 - 1 }
  var sn: i64 = 0
  while suf[sn] != (0 as u8) { sn = sn + 1 }
  let dbuf: *u8 = sys_mmap(1048576)
  var cnt: i64 = 0
  var nb: i64 = 0
  var going: i64 = 1
  while going == 1 {
      let nread: i64 = sys_getdents64(fd, dbuf, 1048576)
      if nread <= 0 { going = 0 } else {
          var off: i64 = 0
          while off < nread {
              let rec: *u8 = ((dbuf as i64) + off) as *u8
              let rl: i64 = dirent_reclen(rec)
              let nm: *u8 = dirent_name(rec)
              var nl: i64 = 0
              while nm[nl] != (0 as u8) { nl = nl + 1 }
              if wsp_ends_with(nm, nl, suf, sn) == 1 { if cnt < maxn { if (nb + nl + 1) < nbcap {
                  offs[cnt] = nb
                  nb = wsp_scatn(namebuf, nb, nm, nl)
                  namebuf[nb] = 0 as u8; nb = nb + 1
                  cnt = cnt + 1
              } } }
              off = off + rl
          }
      }
  }
  sys_close(fd)
  var i: i64 = 1
  while i < cnt {
      let key: i64 = offs[i]
      var j: i64 = i - 1
      var moving: i64 = 1
      while moving == 1 {
          if j < 0 { moving = 0 } else {
              if wsp_name_lt(((namebuf as i64) + key) as *u8, ((namebuf as i64) + offs[j]) as *u8) == 1 {
                  offs[j+1] = offs[j]
                  j = j - 1
              } else { moving = 0 }
          }
      }
      offs[j+1] = key
      i = i + 1
  }
  return cnt
134}
135// content hash over the SORTED corpus: name+NUL then bytes per file; READFAIL sentinel keeps a
136// vanished file visible in the key. out = 16 hex chars.
137func wsp_corpus_sha(dir: *u8, namebuf: *u8, offs: *i64, n: i64, out: *u8) -> i64 {
  let c: *Sha256 = sys_mmap(512) as *Sha256
  sha256_init(c)
  let path: *u8 = sys_mmap(4096)
  var i: i64 = 0
  while i < n {
      let nm: *u8 = ((namebuf as i64) + offs[i]) as *u8
      var pp: i64 = wsp_scat(path, 0, dir)
      pp = wsp_scat(path, pp, "/" as *u8)
      pp = wsp_scat(path, pp, nm)
      path[pp] = 0 as u8
      var nl: i64 = 0
      while nm[nl] != (0 as u8) { nl = nl + 1 }
      sha256_update(c, nm, nl + 1)
      let lp: *i64 = sys_mmap(16) as *i64
      let b: *u8 = sys_read_file(path, lp)
      if (b as i64) == 0 { sha256_update(c, "READFAIL" as *u8, 8) } else {
          sha256_update(c, b, lp[0])
          sys_free_file(b, lp[0])
      }
      i = i + 1
  }
  let dig: *u8 = sys_mmap(40)
  sha256_final(c, dig)
  wsp_hex16(dig, out)
  return 0
163}
164func wsp_field_eq(h: *u8, p: i64, q: i64, v: *u8) -> i64 {
  var k: i64 = 0
  while (p + k) < q {
      if v[k] == (0 as u8) { return 0 }
      if v[k] != h[p+k] { return 0 }
      k = k + 1
  }
  if v[k] != (0 as u8) { return 0 }
  return 1
173}
174// newest TSV row whose col1 == c1v and (when non-0) col2 == c2v, col3 == c3v. rowout[0] = row length.
175func wsp_hist_find(h: *u8, hn: i64, c1v: *u8, c2v: *u8, c3v: *u8, rowout: *i64) -> i64 {
  var best: i64 = 0 - 1
  var i: i64 = 0
  while i < hn {
      var e: i64 = i
      while e < hn { if h[e] == (10 as u8) { break } e = e + 1 }
      if e > i {
          var col: i64 = 0
          var p: i64 = i
          var m1: i64 = 0
          var m2: i64 = 1
          var m3: i64 = 1
          if (c2v as i64) != 0 { m2 = 0 }
          if (c3v as i64) != 0 { m3 = 0 }
          while p < e {
              var q: i64 = p
              while q < e { if wsp_is_fs(h[q] as i64) == 1 { break } q = q + 1 }
              if col == 1 { m1 = wsp_field_eq(h, p, q, c1v) }
              if col == 2 { if (c2v as i64) != 0 { m2 = wsp_field_eq(h, p, q, c2v) } }
              if col == 3 { if (c3v as i64) != 0 { m3 = wsp_field_eq(h, p, q, c3v) } }
              col = col + 1
              p = q + 1
          }
          if m1 == 1 { if m2 == 1 { if m3 == 1 { best = i; rowout[0] = e - i } } }
      }
      i = e + 1
  }
  return best
203}
204func wsp_hist_col_int(h: *u8, ro: i64, rl: i64, c: i64) -> i64 {
  var col: i64 = 0
  var p: i64 = ro
  let e: i64 = ro + rl
  while p < e {
      var q: i64 = p
      while q < e { if wsp_is_fs(h[q] as i64) == 1 { break } q = q + 1 }
      if col == c {
          var v: i64 = 0
          var k: i64 = p
          while k < q { let ch: i64 = h[k] as i64; if ch >= 48 { if ch <= 57 { v = v * 10 + (ch - 48) } } k = k + 1 }
          return v
      }
      col = col + 1
      p = q + 1
  }
  return 0 - 1
221}
222func wsp_base_of(dir: *u8, out: *u8) -> i64 {
  var n: i64 = 0
  while dir[n] != (0 as u8) { n = n + 1 }
  var stripping: i64 = 1
  while stripping == 1 { if n > 0 { if dir[n-1] == (47 as u8) { n = n - 1 } else { stripping = 0 } } else { stripping = 0 } }
  var s: i64 = n
  var seeking: i64 = 1
  while seeking == 1 { if s > 0 { if dir[s-1] == (47 as u8) { seeking = 0 } else { s = s - 1 } } else { seeking = 0 } }
  var o: i64 = 0
  var i: i64 = s
  while i < n { out[o] = dir[i]; o = o + 1; i = i + 1 }
  out[o] = 0 as u8
  return o
235}
236// append row bytes to the history file; 0 ok / 1 open failed (caller must SAY the row was not durably kept)
237func wsp_append(histpath: *u8, row: *u8, ro: i64) -> i64 {
  let fd: i64 = sys_openat_append(histpath, 0x1a4)
  if fd < 0 { return 1 }
  sys_write(fd, row, ro)
  sys_close(fd)
  return 0
243}
nx_wpt_spine.nx source

`nx_wpt_spine.nx` source
