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

↩ module page · 172 lines · 6936 B
1// nx_vsroll_lib.nx -- roll per-SCOPE comparative claims into a DOMAIN verdict by MIN.
2//
3// Everything here works on BUFFERS, not files, so the gate can feed it the ugly cases directly:
4// an empty roster, a roster whose domain has no rows, a claim for the RIGHT scope under the WRONG
5// domain, an unknown earns= label. A ruler that has only ever seen well-formed input is not a
6// ruler -- that lesson cost this lane a 14/14 gate sitting on a lib that fabricated retirements.
7//
8// â˜…â˜…â˜…â˜…â˜…MIN OVER A HAND-PICKED SUBSET IS A MAX. The roster is declared independently of the claims
9// so a missing axis reads UNMEASURED (refuses) rather than absent (rounds up).
10// license_tier: ORIGINAL   No hw writes (Rule 26).
11import "nx_vsbest_lib.nx"
12
13const VR_SCOPE_CAP: i64 = 128
14const VR_OK: i64 = 0
15const VR_NO_ROSTER: i64 = 0 - 1
16const VR_INCOMPLETE: i64 = 0 - 2
17
18// out slots for vr_roll_buf
19const VRO_NREQ: i64 = 0
20const VRO_NHAVE: i64 = 1
21const VRO_MINLV: i64 = 2
22
23func vr_line_end(buf: *u8, p: i64, n: i64) -> i64 {
  var e: i64 = p
  var go: i64 = 1
  while go == 1 { if e >= n { go = 0 } else { if (buf[e] as i64) == 10 { go = 0 } else { e = e + 1 } } }
  return e
28}
29
30// Copy field `n` (0-based, '|'-separated) of line [p,e) into out. Returns length.
31func vr_field(buf: *u8, p: i64, e: i64, n: i64, out: *u8, cap: i64) -> i64 {
  var f: i64 = 0
  var i: i64 = p
  var o: i64 = 0
  while i < e {
      let c: i64 = buf[i] as i64
      if c == 124 { f = f + 1; if f > n { out[o] = 0 as u8; return o } } else {
          if f == n { if o < cap - 1 { out[o] = buf[i]; o = o + 1 } }
      }
      i = i + 1
  }
  out[o] = 0 as u8
  return o
44}
45
46// earns=<LABEL> on a claim line -> maturity level, or -1 when the label is unknown.
47// An unknown label must NOT silently read as 0/ABSENT: that would let a corrupt or
48// future-versioned ledger line quietly become the MIN and pin a domain at the floor.
49func vr_level_of(buf: *u8, p: i64, e: i64) -> i64 {
  let tag: *u8 = " earns=" as *u8
  let tl: i64 = el_len(tag)
  var i: i64 = p
  while i + tl <= e {
      if el_match(buf, i, tag, tl) == 1 {
          var lv: i64 = 0
          while lv <= MAT_EXCEED {
              let lab: *u8 = mat_label(lv)
              let ll: i64 = el_len(lab)
              if i + tl + ll <= e { if el_match(buf, i + tl, lab, ll) == 1 { return lv } }
              lv = lv + 1
          }
          return 0 - 1
      }
      i = i + 1
  }
  return 0 - 1
67}
68
69// Best admitted level for (domain, scope); -1 when no claim exists.
70// BOTH tokens must match on the SAME line -- a claim for scope X under a different domain must not
71// count toward this domain, or every domain sharing an axis name would inherit its neighbour's work.
72func vr_claim_level(cb: *u8, cn: i64, domain: *u8, scope: *u8) -> i64 {
  let dt: *u8 = sys_mmap(VR_SCOPE_CAP + 32)
  var o: i64 = ss_cat(dt, 0, " domain=" as *u8)
  o = ss_cat(dt, o, domain); dt[o] = 32 as u8; dt[o+1] = 0 as u8
  let st: *u8 = sys_mmap(VR_SCOPE_CAP + 32)
  o = ss_cat(st, 0, " scope=" as *u8)
  o = ss_cat(st, o, scope); st[o] = 32 as u8; st[o+1] = 0 as u8
  let dl: i64 = el_len(dt)
  let sl: i64 = el_len(st)
  // RETRACTION IS PART OF THE READ, NOT A SEPARATE PASS (2026-07-31).
  // The ledger is append-only, so the log is a TIMELINE and the answer is the LATEST state for
  // this (domain, scope): a VSBEST line sets the level, a VSRETRACT line clears it back to
  // UNMEASURED, and a later VSBEST can legitimately claim it again after a clean re-run.
  // WHY THIS EXISTS: I admitted search|latency=behind off a benchmark that had starved our own
  // engine, and then could not take it back -- nx_vsbest only appends. Five routes to a fabricated
  // WIN were closed by construction and there was no route to correct an honest MISTAKE.
  // â˜…â˜…â˜…â˜…â˜…AN AXIS THAT CANNOT BE UN-CLAIMED CAN BE POISONED BY EXACTLY ONE BAD MEASUREMENT.
  // Order matters, so this walks the file forward and lets the last word win rather than taking a
  // max over everything ever written.
  let rt: *u8 = sys_mmap(64)
  var ro: i64 = ss_cat(rt, 0, "VSRETRACT " as *u8)
  rt[ro] = 0 as u8
  let rl: i64 = el_len(rt)
  var best: i64 = 0 - 1
  var p: i64 = 0
  while p < cn {
      let e: i64 = vr_line_end(cb, p, cn)
      if e > p {
          var hd: i64 = 0
          var hs: i64 = 0
          var i: i64 = p
          while i < e {
              if i + dl <= e { if el_match(cb, i, dt, dl) == 1 { hd = 1 } }
              if i + sl <= e { if el_match(cb, i, st, sl) == 1 { hs = 1 } }
              i = i + 1
          }
          if hd == 1 { if hs == 1 {
              var isret: i64 = 0
              if p + rl <= e { if el_match(cb, p, rt, rl) == 1 { isret = 1 } }
              if isret == 1 { best = 0 - 1 } else {
                  let lv: i64 = vr_level_of(cb, p, e)
                  if lv > best { best = lv }
              }
          } }
      }
      p = e + 1
  }
  return best
120}
121
122// idx-th required scope for `domain` in the roster buffer. Returns length, 0 when absent.
123func vr_scope_at(rb: *u8, rn: i64, domain: *u8, idx: i64, out: *u8, cap: i64) -> i64 {
  let dom: *u8 = sys_mmap(VR_SCOPE_CAP)
  var seen: i64 = 0
  var p: i64 = 0
  while p < rn {
      let e: i64 = vr_line_end(rb, p, rn)
      if e > p { if (rb[p] as i64) != 35 {
          vr_field(rb, p, e, 0, dom, VR_SCOPE_CAP)
          if el_streq(dom, domain) == 1 {
              let l: i64 = vr_field(rb, p, e, 1, out, cap)
              if l > 0 {
                  if seen == idx { return l }
                  seen = seen + 1
              }
          }
      } }
      p = e + 1
  }
  out[0] = 0 as u8
  return 0
143}
144
145// THE ROLL. out[NREQ]/out[NHAVE]/out[MINLV]. Returns VR_OK, VR_NO_ROSTER or VR_INCOMPLETE.
146// MINLV is only meaningful on VR_OK -- on a refusal there is no domain level, by design.
147func vr_roll_buf(domain: *u8, rb: *u8, rn: i64, cb: *u8, cn: i64, out: *i64) -> i64 {
  out[VRO_NREQ] = 0
  out[VRO_NHAVE] = 0
  out[VRO_MINLV] = 0 - 1
  let scope: *u8 = sys_mmap(VR_SCOPE_CAP)
  var minlv: i64 = MAT_EXCEED
  var idx: i64 = 0
  var go: i64 = 1
  while go == 1 {
      let l: i64 = vr_scope_at(rb, rn, domain, idx, scope, VR_SCOPE_CAP)
      if l <= 0 { go = 0 } else {
          out[VRO_NREQ] = out[VRO_NREQ] + 1
          var lv: i64 = 0 - 1
          if cn > 0 { lv = vr_claim_level(cb, cn, domain, scope) }
          if lv >= 0 {
              out[VRO_NHAVE] = out[VRO_NHAVE] + 1
              if lv < minlv { minlv = lv }
          }
          idx = idx + 1
      }
  }
  if out[VRO_NREQ] == 0 { return VR_NO_ROSTER }
  if out[VRO_NHAVE] < out[VRO_NREQ] { return VR_INCOMPLETE }
  out[VRO_MINLV] = minlv
  return VR_OK
172}
nx_vsroll_lib.nx source

`nx_vsroll_lib.nx` source
