`nx_libdata.nx` source

↩ module page · 1476 lines · 67181 B
1// nx_libdata.nx -- THE SELF-SUFFICIENCY DATA LIBRARY ENGINE (ws=library-datasets, 2026-07-31).
2// Operator goal: collect the datasets that were NOT coming in, ranked MOST VALUABLE to LEAST for
3// household self-sufficiency against the cost-of-living crisis (gardening, NSF, manufacturing, ...).
4//
5// WHY: the library answered 'gardening' with garden-centre shop pages, and knowledge/fetched/ held
6// 44 Wikipedia pages. Root cause (debt 1785516741/1785516905) was TRANSPORT, not a missing list:
7// every ingester called the TLS-1.3-only fetch entry point, so TLS-1.2-only hosts -- exactly where
8// US federal open data lives -- were unreachable. This organ deliberately calls the WIDE-REACH
9// nx_https_fetch_follow_best so it can never regress to the narrow path.
10//
11// DATA-DRIVEN BY CONSTRUCTION (rule 11): the source list is knowledge/registry/selfsuff_datasets.tsv
12// and the ranking weights are knowledge/status/selfsuff_axes.conf. Adding a dataset is ONE ROW and
13// zero code; re-prioritising the whole library is editing four weights. Contrast nx_supply_research_fetch,
14// which hardcodes 44 URLs in its body.
15//
16// verbs: rank | gaps | fetch [maxn] | status | selftest
17// expect_exit: 0  license_tier: ORIGINAL
18import "nx_syscalls.nx"
19import "nx_x509_trust_store.nx"
20import "nx_trust_store_load_from_certdata.nx"
21import "nx_https_fetch_follow.nx"
22import "nx_sha256.nx"
23import "nx_store_seed_lib.nx"
24import "nx_lib_openalex.nx"
25import "nx_lib_search.nx"
26import "nx_gzip_wrap.nx"
27const LD_MAGIC_2048: i64 = 2048
28const LD_MAGIC_65558: i64 = 65558
29const LD_MAGIC_4096: i64 = 4096
30
31const LD_BUF: i64 = 262144
32const LD_AXBUF: i64 = 16384
33const LD_ROWS: i64 = 256
34// 15 columns: the original 13 plus two SOTA gates carried as DATA, not code --
35//   col 13 min_bytes    semantic floor; a payload under it is an error envelope, not a dataset
36//   col 14 max_age_days freshness; 0 = never stale. have-skip alone means a file is NEVER refreshed.
37// Rows with only 13 fields still parse: missing fields get length 0 and read as 0 (rule 19).
38const LD_NF: i64 = 15
39const LD_FETCH: i64 = 134217728
40const LD_PATH: i64 = 1024
41const LD_CERT: i64 = 4194304
42const LD_MODE_644: i64 = 420
43const LD_PERMIL: i64 = 1000
44const LD_TAB: i64 = 9
45const LD_NL: i64 = 10
46const LD_HASH: i64 = 35
47const LD_ACCESS_FULL: i64 = 10
48const LD_HOPS: i64 = 6
49// Range window. EIA truncates a single response near 258KB, so stay well under it.
50const LD_CHUNK: i64 = 131072
51const LD_MAXCHUNKS: i64 = 1100
52const LD_WINDOW_TRIES: i64 = 4
53// Backoff multiplies by attempt number: 429 is explicit rate limiting, not an error.
54const LD_BACKOFF_MS: i64 = 1500
55const LD_REFETCH_MS: i64 = 8000
56
57// field indexes into a registry row
58const F_ID: i64 = 0
59const F_DOMAIN: i64 = 1
60const F_URL: i64 = 3
61const F_SAVE: i64 = 6
62const F_BREADTH: i64 = 7
63const F_DUR: i64 = 8
64const F_UNSUB: i64 = 9
65const F_ACCESS: i64 = 10
66const F_STATUS: i64 = 11
67const F_MINBYTES: i64 = 13
68const F_MAXAGE: i64 = 14
69const LD_SECS_DAY: i64 = 86400
70// Error envelopes announce themselves in the first bytes. Scanning only the HEAD keeps a real
71// dataset that happens to contain the words "Not Found" in its body from being rejected.
72const LD_SCANHEAD: i64 = 2048
73const LD_CATALOG: *u8 = "knowledge/store/libdata-" as *u8
74const LD_REJCONF: *u8 = "knowledge/status/selfsuff_reject.conf" as *u8
75const LD_PROV: *u8 = "knowledge/status/selfsuff_provenance.tsv" as *u8
76
77// Local string helpers. nx_sovjson_lib.nx lives in runtime/_hdl_build/ and this organ lives in
78// runtime/ -- runtime CANNOT import _hdl_build (layering law), so sj_vlen/sj_puts/sj_lit_eq are
79// reimplemented here rather than reaching across the layer.
80func ld_vlen(s: *u8) -> i64 { var n: i64 = 0; while s[n] != (0 as u8) { n = n + 1 } return n }
81func ld_emit(s: *u8) -> i64 { let n: i64 = ld_vlen(s); sys_write(1, s, n); return 0 }
82func ld_lit_eq(s: *u8, off: i64, len: i64, lit: *u8) -> i64 {
  let ll: i64 = ld_vlen(lit)
  if ll != len { return 0 }
  var i: i64 = 0
  while i < ll { if s[off+i] != lit[i] { return 0 } i = i + 1 }
  return 1
88}
89
90func ld_puts(s: *u8) -> i64 { ld_emit(s); return 0 }
91
92// CORRECT integer emit. The sibling fetcher nx_supply_research_fetch has this same helper WITHOUT
93// the reverse-and-write loop below, so every byte count and status code it prints comes out EMPTY
94// (debt 1785516650). A fetcher that cannot report a byte count cannot tell success from failure.
95func ld_putn(v: i64) -> i64 {
  if v == 0 { sys_write(1, "0" as *u8, 1); return 0 }
  var m: i64 = v
  if m < 0 { sys_write(1, "-" as *u8, 1); m = 0 - m }
  let d: *u8 = sys_mmap(24)
  var k: i64 = 0
  while m > 0 { d[k] = (48 + (m % 10)) as u8; m = m / 10; k = k + 1 }
  var j: i64 = k - 1
  while j >= 0 { sys_write(1, ((d as i64)+j) as *u8, 1); j = j - 1 }
  return 0
105}
106
107func ld_write_n(s: *u8, n: i64) -> i64 { sys_write(1, s, n); return 0 }
108
109func ld_read(path: *u8, buf: *u8, cap: i64) -> i64 {
  let fd: i64 = sys_openat_rd(path)
  if fd < 0 { return -1 }
  var n: i64 = 0
  var go: i64 = 1
  while go == 1 { let r: i64 = sys_read(fd, ((buf as i64)+n) as *u8, cap-n); if r <= 0 { go = 0 } else { n = n + r } if n >= cap { go = 0 } }
  sys_close(fd)
  return n
117}
118
119func ld_have(path: *u8) -> i64 {
  let fd: i64 = sys_openat_rd(path)
  if fd < 0 { return 0 }
  sys_close(fd)
  return 1
124}
125
126// parse a non-negative int out of buf[o..o+len)
127func ld_atoi(buf: *u8, o: i64, len: i64) -> i64 {
  var v: i64 = 0
  var i: i64 = 0
  while i < len {
      let c: i64 = buf[o+i] as i64
      if c >= 48 { if c <= 57 { v = v * 10 + (c - 48) } }
      i = i + 1
  }
  return v
136}
137
138// look up an integer config value: a line "<key>\t<int>\t..."
139// End-of-line index (exclusive) for the line starting at `from`, or n if the last line is unterminated.
140// Written as an explicit scan-then-stop because terminating the loop by driving the cursor past n
141// DESTROYS the position we are trying to return -- the bug this function exists to prevent.
142func ld_eol(buf: *u8, from: i64, n: i64) -> i64 {
  var p: i64 = from
  var eol: i64 = -1
  while p < n {
      if eol < 0 {
          if buf[p] == (LD_NL as u8) { eol = p }
          p = p + 1
      } else { p = n }
  }
  if eol < 0 { return n }
  return eol
153}
154
155func ld_conf_int(buf: *u8, n: i64, key: *u8, dflt: i64) -> i64 {
  let kl: i64 = ld_vlen(key)
  var i: i64 = 0
  while i < n {
      let ls: i64 = i
      let lend: i64 = ld_eol(buf, i, n)
      // does this line start with key followed by TAB?
      var ok: i64 = 0
      if ls + kl + 1 <= lend {
          var k: i64 = 0
          ok = 1
          while k < kl { if buf[ls+k] != key[k] { ok = 0; k = kl } else { k = k + 1 } }
          if ok == 1 { if buf[ls+kl] != (LD_TAB as u8) { ok = 0 } }
      }
      if ok == 1 {
          let vs: i64 = ls + kl + 1
          var ve: i64 = vs
          while ve < lend { if buf[ve] == (LD_TAB as u8) { ve = lend } else { ve = ve + 1 } }
          return ld_atoi(buf, vs, ve - vs)
      }
      i = lend + 1
  }
  return dflt
178}
179
180// Parse the registry into parallel offset/length arrays. Returns the row count.
181func ld_parse(buf: *u8, n: i64, fo: *i64, fl: *i64) -> i64 {
  var rows: i64 = 0
  var i: i64 = 0
  while i < n {
      if rows >= LD_ROWS { i = n }
      if i < n {
          let e: i64 = ld_eol(buf, i, n)
          var keep: i64 = 1
          if e <= i { keep = 0 }
          if keep == 1 { if buf[i] == (LD_HASH as u8) { keep = 0 } }
          if keep == 1 {
              // Zero every slot first so a 13-column legacy row leaves min_bytes//max_age at 0
              // instead of inheriting whatever the previous row left in the array.
              var z: i64 = 0
              while z < LD_NF { fo[rows*LD_NF + z] = 0; fl[rows*LD_NF + z] = 0; z = z + 1 }
              var c: i64 = 0
              var fs: i64 = i
              var p: i64 = i
              while p <= e {
                  var cut: i64 = 0
                  if p == e { cut = 1 }
                  if cut == 0 { if buf[p] == (LD_TAB as u8) { cut = 1 } }
                  if cut == 1 {
                      if c < LD_NF {
                          fo[rows*LD_NF + c] = fs
                          fl[rows*LD_NF + c] = p - fs
                          c = c + 1
                      }
                      fs = p + 1
                  }
                  p = p + 1
              }
              if c >= 12 { rows = rows + 1 }
          }
          i = e + 1
      }
  }
  return rows
219}
220
221func ld_field_i(buf: *u8, fo: *i64, fl: *i64, r: i64, f: i64) -> i64 {
  return ld_atoi(buf, fo[r*LD_NF + f], fl[r*LD_NF + f])
223}
224
225// delivered = (w_save*save + w_breadth*breadth + w_unsub*unsub + w_dur*dur) * access / 10
226// access MULTIPLIES: a dataset we cannot retrieve delivers ZERO, however precious it is.
227func ld_score(buf: *u8, fo: *i64, fl: *i64, r: i64, ws: i64, wb: i64, wu: i64, wd: i64) -> i64 {
  let sv: i64 = ld_field_i(buf, fo, fl, r, F_SAVE)
  let br: i64 = ld_field_i(buf, fo, fl, r, F_BREADTH)
  let du: i64 = ld_field_i(buf, fo, fl, r, F_DUR)
  let un: i64 = ld_field_i(buf, fo, fl, r, F_UNSUB)
  let ac: i64 = ld_field_i(buf, fo, fl, r, F_ACCESS)
  let base: i64 = ws*sv + wb*br + wu*un + wd*du
  return (base * ac) / LD_ACCESS_FULL
235}
236
237// selection sort of an index array by score desc (rows are bounded by LD_ROWS)
238func ld_order(sc: *i64, ord: *i64, rows: i64) -> i64 {
  var i: i64 = 0
  while i < rows { ord[i] = i; i = i + 1 }
  var a: i64 = 0
  while a < rows {
      var best: i64 = a
      var b: i64 = a + 1
      while b < rows {
          if sc[ord[b]] > sc[ord[best]] { best = b }
          b = b + 1
      }
      let t: i64 = ord[a]
      ord[a] = ord[best]
      ord[best] = t
      a = a + 1
  }
  return 0
255}
256
257// knowledge/fetched/ss_<id>.raw
258func ld_outpath(dst: *u8, buf: *u8, fo: *i64, fl: *i64, r: i64) -> i64 {
  let pre: *u8 = "knowledge/fetched/ss_" as *u8
  var k: i64 = 0
  var i: i64 = 0
  let pl: i64 = ld_vlen(pre)
  while i < pl { dst[k] = pre[i]; k = k + 1; i = i + 1 }
  let io: i64 = fo[r*LD_NF + F_ID]
  let il: i64 = fl[r*LD_NF + F_ID]
  i = 0
  while i < il { dst[k] = buf[io+i]; k = k + 1; i = i + 1 }
  let suf: *u8 = ".raw" as *u8
  let sl: i64 = ld_vlen(suf)
  i = 0
  while i < sl { dst[k] = suf[i]; k = k + 1; i = i + 1 }
  dst[k] = 0 as u8
  return k
274}
275
276func ld_cstr(dst: *u8, buf: *u8, o: i64, len: i64) -> i64 {
  var i: i64 = 0
  while i < len { dst[i] = buf[o+i]; i = i + 1 }
  dst[len] = 0 as u8
  return len
281}
282
283func ld_load(rpath: *u8, apath: *u8, buf: *u8, ax: *u8, fo: *i64, fl: *i64, sc: *i64, ord: *i64, wout: *i64) -> i64 {
  let n: i64 = ld_read(rpath, buf, LD_BUF)
  if n <= 0 { return -1 }
  let an: i64 = ld_read(apath, ax, LD_AXBUF)
  if an <= 0 { return -2 }
  let ws: i64 = ld_conf_int(ax, an, "w_save" as *u8, 0)
  let wb: i64 = ld_conf_int(ax, an, "w_breadth" as *u8, 0)
  let wu: i64 = ld_conf_int(ax, an, "w_unsub" as *u8, 0)
  let wd: i64 = ld_conf_int(ax, an, "w_durability" as *u8, 0)
  // FAIL-CLOSED: absent weights must not silently rank everything 0 and look like a working library.
  if ws + wb + wu + wd <= 0 { return -3 }
  wout[0] = ws
  wout[1] = wb
  wout[2] = wu
  wout[3] = wd
  wout[4] = ld_conf_int(ax, an, "domain_floor" as *u8, 0)
  let rows: i64 = ld_parse(buf, n, fo, fl)
  var r: i64 = 0
  while r < rows { sc[r] = ld_score(buf, fo, fl, r, ws, wb, wu, wd); r = r + 1 }
  ld_order(sc, ord, rows)
  return rows
304}
305
306// ---- structural completeness helpers (debt 1785520161) ------------------------------------------
307// Search only the TAIL window: a terminator that appears anywhere else does not prove completeness.
308func ld_find_last(b: *u8, n: i64, lit: *u8, litlen: i64, window: i64) -> i64 {
  var start: i64 = n - window
  if start < 0 { start = 0 }
  var i: i64 = start
  var found: i64 = 0
  while i + litlen <= n {
      var k: i64 = 0
      var ok: i64 = 1
      while k < litlen { if b[i+k] != lit[k] { ok = 0; k = litlen } else { k = k + 1 } }
      if ok == 1 { found = 1 }
      i = i + 1
  }
  return found
321}
322
323// ZIP end-of-central-directory signature: PK\x05\x06. Its ABSENCE means the archive is truncated,
324// which is exactly what a server closing early produces.
325func ld_zip_eocd(b: *u8, n: i64) -> i64 {
  var start: i64 = n - LD_MAGIC_65558
  if start < 0 { start = 0 }
  var i: i64 = start
  var found: i64 = 0
  while i + 4 <= n {
      if b[i] == (80 as u8) { if b[i+1] == (75 as u8) { if b[i+2] == (5 as u8) { if b[i+3] == (6 as u8) { found = 1 } } } }
      i = i + 1
  }
  return found
335}
336
337// A JSON document is complete when its LAST non-whitespace byte closes the root it opened.
338func ld_json_closed(b: *u8, n: i64, want: i64) -> i64 {
  var i: i64 = n - 1
  var res: i64 = 0
  var go: i64 = 1
  while go == 1 {
      if i < 0 { go = 0 } else {
          let c: i64 = b[i] as i64
          if c == 32 { i = i - 1 } else {
              if c == 10 { i = i - 1 } else {
                  if c == 13 { i = i - 1 } else {
                      if c == 9 { i = i - 1 } else {
                          if c == want { res = 1 }
                          go = 0
                      }
                  }
              }
          }
      }
  }
  return res
358}
359
360// Structural completeness of ONE collected file: 1=complete, 0=SHORT-DELIVERY, 2=unverifiable.
361// Shared by verify AND status, deliberately: coverage that counts a truncated file as collected is
362// the same coverage-gaming failure the MIN headline exists to prevent. A short file is NOT covered.
363func ld_buf_complete(vbuf: *u8, n: i64) -> i64 {
  if n <= 8 { return 2 }
  if vbuf[0] == (37 as u8) { if vbuf[1] == (80 as u8) { if vbuf[2] == (68 as u8) { if vbuf[3] == (70 as u8) {
      return ld_find_last(vbuf, n, "%%EOF" as *u8, 5, LD_MAGIC_4096)
  } } } }
  if vbuf[0] == (80 as u8) { if vbuf[1] == (75 as u8) { return ld_zip_eocd(vbuf, n) } }
  if vbuf[0] == (123 as u8) { return ld_json_closed(vbuf, n, 125) }
  if vbuf[0] == (91 as u8) { return ld_json_closed(vbuf, n, 93) }
  return 2
372}
373
374func ld_file_complete(path: *u8, vbuf: *u8) -> i64 {
  let n: i64 = ld_read(path, vbuf, LD_FETCH)
  return ld_buf_complete(vbuf, n)
377}
378
379// ---- SOTA gap-closers: content hash, provenance lineage, freshness ------------------------------
380// Measured against 2026 ingestion practice, the library was missing: integrity hashing, a provenance
381// record per artifact, incremental//freshness, and semantic (not merely structural) validation.
382
383func ld_hexdig(v: i64) -> i64 {
  if v < 10 { return 48 + v }
  return 87 + v
386}
387
388// sha256 of a buffer, written as 64 lowercase hex chars + NUL. Integrity + change detection + dedup.
389func ld_sha_hex(b: *u8, n: i64, outhex: *u8) -> i64 {
  let dig: *u8 = sys_mmap(64)
  sha256_digest(b, n, dig)
  var i: i64 = 0
  while i < 32 {
      let byte: i64 = dig[i] as i64
      outhex[i*2] = ld_hexdig(byte / 16) as u8
      outhex[i*2 + 1] = ld_hexdig(byte % 16) as u8
      i = i + 1
  }
  outhex[64] = 0 as u8
  return 64
401}
402
403func ld_app_str(d: *u8, o: i64, s2: *u8) -> i64 {
  var i: i64 = 0
  while s2[i] != (0 as u8) { d[o+i] = s2[i]; i = i + 1 }
  return o + i
407}
408func ld_app_n(d: *u8, o: i64, v: i64) -> i64 {
  if v == 0 { d[o] = 48 as u8; return o + 1 }
  var m: i64 = v
  var k: i64 = o
  if m < 0 { d[k] = 45 as u8; k = k + 1; m = 0 - m }
  let t: *u8 = sys_mmap(24)
  var c: i64 = 0
  while m > 0 { t[c] = (48 + (m % 10)) as u8; m = m / 10; c = c + 1 }
  var j: i64 = c - 1
  while j >= 0 { d[k] = t[j]; k = k + 1; j = j - 1 }
  return k
419}
420
421// APPEND-ONLY provenance: one row per completed fetch. This is the lineage catalog the library had
422// no equivalent of -- without it there is no record of WHEN a byte arrived, from WHAT status, or
423// WHETHER it changed. Append-only so history is never rewritten.
424func ld_prov_append(idb: *u8, idlen: i64, url: *u8, status: i64, bytes: i64, hex: *u8, verdict: *u8) -> i64 {
  let line: *u8 = sys_mmap(LD_MAGIC_2048)
  var o: i64 = 0
  o = ld_app_n(line, o, sys_now_realtime_sec())
  line[o] = 9 as u8; o = o + 1
  var i: i64 = 0
  while i < idlen { line[o] = idb[i]; o = o + 1; i = i + 1 }
  line[o] = 9 as u8; o = o + 1
  o = ld_app_n(line, o, status)
  line[o] = 9 as u8; o = o + 1
  o = ld_app_n(line, o, bytes)
  line[o] = 9 as u8; o = o + 1
  o = ld_app_str(line, o, hex)
  line[o] = 9 as u8; o = o + 1
  o = ld_app_str(line, o, verdict)
  line[o] = 9 as u8; o = o + 1
  o = ld_app_str(line, o, url)
  line[o] = 10 as u8; o = o + 1
  let fd: i64 = sys_openat_append(LD_PROV, LD_MODE_644)
  if fd < 0 { return 0 - 1 }
  sys_write(fd, line, o)
  sys_close(fd)
  return o
447}
448
449// Newest provenance epoch for an id, or 0 if never fetched. Drives freshness WITHOUT a stat call:
450// the lineage log is already the authority on when a byte arrived.
451func ld_prov_last(idb: *u8, idlen: i64, pbuf: *u8) -> i64 {
  let n: i64 = ld_read(LD_PROV, pbuf, LD_BUF)
  if n <= 0 { return 0 }
  var best: i64 = 0
  var i: i64 = 0
  while i < n {
      let e: i64 = ld_eol(pbuf, i, n)
      var ts: i64 = 0
      var q: i64 = i
      while q < e { if pbuf[q] == (9 as u8) { q = e } else { ts = ts * 10 + ((pbuf[q] as i64) - 48); q = q + 1 } }
      var idstart: i64 = i
      while idstart < e { if pbuf[idstart] == (9 as u8) { idstart = idstart + 1; q = e + 1 } else { idstart = idstart + 1 } }
      var same: i64 = 1
      var k: i64 = 0
      while k < idlen { if idstart + k >= e { same = 0; k = idlen } else { if pbuf[idstart + k] != idb[k] { same = 0; k = idlen } else { k = k + 1 } } }
      if same == 1 { if idstart + idlen < e { if pbuf[idstart + idlen] != (9 as u8) { same = 0 } } }
      if same == 1 { if ts > best { best = ts } }
      i = e + 1
  }
  return best
471}
472
473// Does the payload HEAD carry a known error-envelope marker? Markers live in a conf file, not in
474// code (rule 11), so the list is tunable without a reship. This is the guard a byte floor cannot be:
475// an evidence-derived floor protects only rows that ALREADY have an observation, which leaves the
476// FIRST fetch of a new row -- the most exposed case -- completely unguarded. Proven necessary:
477// api.bls.gov answered 200 with a 224-byte REQUEST_NOT_PROCESSED envelope and it was saved.
478func ld_has_marker(b: *u8, n: i64, conf: *u8, cn: i64) -> i64 {
  var lim: i64 = n
  if lim > LD_SCANHEAD { lim = LD_SCANHEAD }
  var i: i64 = 0
  var hit: i64 = 0
  while i < cn {
      let e: i64 = ld_eol(conf, i, cn)
      var mlen: i64 = e - i
      var skip: i64 = 0
      if mlen <= 0 { skip = 1 }
      if skip == 0 { if conf[i] == (35 as u8) { skip = 1 } }
      if skip == 0 {
          var q: i64 = 0
          while q + mlen <= lim {
              var k: i64 = 0
              var same: i64 = 1
              while k < mlen { if b[q+k] != conf[i+k] { same = 0; k = mlen } else { k = k + 1 } }
              if same == 1 { hit = 1; q = lim }
              q = q + 1
          }
      }
      i = e + 1
  }
  return hit
502}
503
504// Find `needle` in b[0..n); returns index just PAST it, or -1.
505func ld_find_past(b: *u8, n: i64, needle: *u8) -> i64 {
  let nl: i64 = ld_vlen(needle)
  if nl <= 0 { return 0 - 1 }
  var i: i64 = 0
  var hit: i64 = 0 - 1
  while i + nl <= n {
      if hit < 0 {
          var k: i64 = 0
          var same: i64 = 1
          while k < nl { if b[i+k] != needle[k] { same = 0; k = nl } else { k = k + 1 } }
          if same == 1 { hit = i + nl }
      }
      i = i + 1
  }
  return hit
520}
521
522func ld_copy_until_quote(b: *u8, n: i64, from: i64, out: *u8) -> i64 {
  var i: i64 = from
  var k: i64 = 0
  while i < n {
      if b[i] == (34 as u8) { i = n } else { out[k] = b[i]; k = k + 1; i = i + 1 }
  }
  out[k] = 0 as u8
  return k
530}
531
532// Extract OpenAlex meta.next_cursor into `out` (NUL-terminated). Returns length, 0 if absent/null.
533// The cursor is the ONLY honest signal that a harvest is finished -- page counting guesses.
534func ld_next_cursor(b: *u8, n: i64, out: *u8) -> i64 {
  var at: i64 = ld_find_past(b, n, "\"next_cursor\"" as *u8)
  if at < 0 { return 0 }
  // skip ": " then require an opening quote; a null cursor means the last page.
  while at < n { if b[at] == (34 as u8) { at = at + 1; return ld_copy_until_quote(b, n, at, out) } else { if b[at] == (110 as u8) { return 0 } else { at = at + 1 } } }
  return 0
540}
541
542
543func ld_row_line(buf: *u8, fo: *i64, fl: *i64, r: i64, score: i64, rank: i64, have: i64) -> i64 {
  ld_putn(rank)
  ld_puts("\t" as *u8)
  ld_putn(score)
  ld_puts("\t" as *u8)
  ld_write_n(((buf as i64) + fo[r*LD_NF + F_DOMAIN]) as *u8, fl[r*LD_NF + F_DOMAIN])
  ld_puts("\t" as *u8)
  ld_write_n(((buf as i64) + fo[r*LD_NF + F_ID]) as *u8, fl[r*LD_NF + F_ID])
  ld_puts("\t" as *u8)
  ld_write_n(((buf as i64) + fo[r*LD_NF + F_STATUS]) as *u8, fl[r*LD_NF + F_STATUS])
  if have == 1 { ld_puts("\tON-DISK" as *u8) }
  if have == 0 { ld_puts("\tABSENT" as *u8) }
  ld_puts("\n" as *u8)
  return 0
557}
558
559func main(argc: i64, argv: *i64) -> i64 {
  if argc < 2 {
      ld_puts("usage: nx_libdata {rank | gaps | fetch [maxn] | status | selftest} [registry] [axes]\n" as *u8)
      sys_exit(2)
      return 2
  }
  let verb: *u8 = argv[1] as *u8
  let vl: i64 = ld_vlen(verb)
567
  let rpath: *u8 = "knowledge/registry/selfsuff_datasets.tsv" as *u8
  let apath: *u8 = "knowledge/status/selfsuff_axes.conf" as *u8
570
  let buf: *u8 = sys_mmap(LD_BUF)
  let ax: *u8 = sys_mmap(LD_AXBUF)
  let fo: *i64 = sys_mmap(LD_ROWS*LD_NF*8) as *i64
  let fl: *i64 = sys_mmap(LD_ROWS*LD_NF*8) as *i64
  let sc: *i64 = sys_mmap(LD_ROWS*8) as *i64
  let ord: *i64 = sys_mmap(LD_ROWS*8) as *i64
  let w: *i64 = sys_mmap(64) as *i64
  let pathbuf: *u8 = sys_mmap(LD_PATH)
579
  let rows: i64 = ld_load(rpath, apath, buf, ax, fo, fl, sc, ord, w)
  if rows == -1 { ld_puts("REFUSED registry unreadable: " as *u8); ld_puts(rpath); ld_puts("\n" as *u8); sys_exit(3); return 3 }
  if rows == -2 { ld_puts("REFUSED axes conf unreadable: " as *u8); ld_puts(apath); ld_puts("\n" as *u8); sys_exit(3); return 3 }
  if rows == -3 { ld_puts("REFUSED axes weights all zero -- refusing to emit a ranking that would look valid\n" as *u8); sys_exit(3); return 3 }
  if rows <= 0 { ld_puts("REFUSED registry has no rows\n" as *u8); sys_exit(3); return 3 }
585
  if ld_lit_eq(verb, 0, vl, "rank" as *u8) == 1 {
      ld_puts("NX-LIBDATA RANK rows=" as *u8); ld_putn(rows)
      ld_puts(" weights save/breadth/unsub/dur=" as *u8)
      ld_putn(w[0]); ld_puts("/" as *u8); ld_putn(w[1]); ld_puts("/" as *u8); ld_putn(w[2]); ld_puts("/" as *u8); ld_putn(w[3])
      ld_puts("\nrank\tscore\tdomain\tid\tstatus\tondisk\n" as *u8)
      var i: i64 = 0
      while i < rows {
          let r: i64 = ord[i]
          ld_outpath(pathbuf, buf, fo, fl, r)
          ld_row_line(buf, fo, fl, r, sc[r], i+1, ld_have(pathbuf))
          i = i + 1
      }
      sys_exit(0)
      return 0
  }
601
  if ld_lit_eq(verb, 0, vl, "gaps" as *u8) == 1 {
      ld_puts("NX-LIBDATA GAPS -- ranked work order, highest self-sufficiency value first\n" as *u8)
      ld_puts("rank\tscore\tdomain\tid\tstatus\tondisk\n" as *u8)
      var i: i64 = 0
      var miss: i64 = 0
      while i < rows {
          let r: i64 = ord[i]
          ld_outpath(pathbuf, buf, fo, fl, r)
          if ld_have(pathbuf) == 0 {
              ld_row_line(buf, fo, fl, r, sc[r], i+1, 0)
              miss = miss + 1
          }
          i = i + 1
      }
      ld_puts("GAPS absent=" as *u8); ld_putn(miss)
      ld_puts(" of " as *u8); ld_putn(rows); ld_puts("\n" as *u8)
      sys_exit(0)
      return 0
  }
621
  if ld_lit_eq(verb, 0, vl, "fetch" as *u8) == 1 {
      var maxn: i64 = rows
      if argc >= 3 { maxn = ld_atoi(argv[2] as *u8, 0, ld_vlen(argv[2] as *u8)) }
      if maxn <= 0 { maxn = rows }
      let tr: i64 = nx_trust_store_load_from_certdata("data/mozilla_certdata.txt" as *u8, 512, LD_CERT)
      if tr <= 0 { ld_puts("REFUSED certdata load failed -- refusing to fetch unauthenticated\n" as *u8); sys_exit(4); return 4 }
      let store: *TrustStore = tr as *TrustStore
      let out: *u8 = sys_mmap(LD_FETCH)
      let status: *i64 = sys_mmap(8) as *i64
      let urlbuf: *u8 = sys_mmap(LD_PATH)
      let pbuf: *u8 = sys_mmap(LD_BUF)
      let hexb: *u8 = sys_mmap(80)
      let rconf: *u8 = sys_mmap(LD_AXBUF)
      let rcn: i64 = ld_read(LD_REJCONF, rconf, LD_AXBUF)
      var rejected: i64 = 0
      var refreshed: i64 = 0
      ld_puts("NX-LIBDATA FETCH ranked, wide-reach (1.3 -> chrome -> 1.2). CA roots=" as *u8)
      ld_putn(trust_store_count(store)); ld_puts("\n" as *u8)
      var i: i64 = 0
      var done: i64 = 0
      var okc: i64 = 0
      var skip: i64 = 0
      var fail: i64 = 0
      var trunc: i64 = 0
      var bytes_total: i64 = 0
      while i < rows {
          if done < maxn {
              let r: i64 = ord[i]
              ld_outpath(pathbuf, buf, fo, fl, r)
              ld_write_n(((buf as i64) + fo[r*LD_NF + F_ID]) as *u8, fl[r*LD_NF + F_ID])
              ld_puts("\t" as *u8)
              // INCREMENTAL, NOT NEVER-AGAIN. Plain have-skip means a collected file is frozen
              // forever; a price series or a rent table is wrong within weeks. max_age_days (col 14)
              // turns the skip into a freshness check, using the provenance log as the authority on
              // when the bytes actually arrived. max_age_days=0 keeps the old never-refetch behaviour.
              var need: i64 = 1
              if ld_have(pathbuf) == 1 {
                  need = 0
                  let maxage: i64 = ld_field_i(buf, fo, fl, r, F_MAXAGE)
                  if maxage > 0 {
                      let last: i64 = ld_prov_last(((buf as i64) + fo[r*LD_NF + F_ID]) as *u8, fl[r*LD_NF + F_ID], pbuf)
                      if last > 0 { if sys_now_realtime_sec() - last > maxage * LD_SECS_DAY { need = 1; refreshed = refreshed + 1 } }
                  }
              }
              if need == 0 {
                  ld_puts("[have-skip fresh]\n" as *u8)
                  skip = skip + 1
              } else {
                  ld_cstr(urlbuf, buf, fo[r*LD_NF + F_URL], fl[r*LD_NF + F_URL])
                  status[0] = 0
                  let got: i64 = nx_https_fetch_follow_best(urlbuf, store, out, LD_FETCH, LD_HOPS, status)
                  ld_puts("status=" as *u8); ld_putn(status[0])
                  ld_puts(" bytes=" as *u8); ld_putn(got)
                  // ONLY 2xx MAY ENTER THE LIBRARY. The first pass saved a 404 page as
                  // ss_nist-mml-data.raw (70634B) and a 191B error blob as ss_fred-series.raw.
                  // A wrong answer in the library is worse than an absent row: every downstream
                  // reader then treats an error page as the dataset.
                  var ok2xx: i64 = 0
                  if status[0] >= 200 { if status[0] < 300 { ok2xx = 1 } }
                  // SEMANTIC FLOOR. 2xx + structurally-valid is NOT "the data is there": api.bls.gov
                  // answered 200 with a well-formed JSON rate-limit envelope and it was banked as a
                  // household-expenditure dataset. A global byte floor cannot work (ss_phzm-zone.raw is
                  // 105 real bytes), so the floor is PER-ROW DATA in col 13.
                  var floored: i64 = 0
                  let minb: i64 = ld_field_i(buf, fo, fl, r, F_MINBYTES)
                  // got<=0 is a TRANSPORT failure (-2 connect, -3 handshake, -4 GET), NOT a small
                  // payload. Reporting it as BELOW-FLOOR names the wrong cause and would send the
                  // next reader hunting for a data problem that does not exist.
                  if minb > 0 { if got > 0 { if got < minb { floored = 1 } } }
                  if floored == 0 { if rcn > 0 { if got > 0 {
                      if ld_has_marker(out, got, rconf, rcn) == 1 { floored = 2 }
                  } } }
                  if floored != 0 {
                      if floored == 1 {
                          ld_puts("  REJECTED-BELOW-FLOOR min=" as *u8)
                          ld_putn(minb)
                      }
                      if floored == 2 { ld_puts("  REJECTED-ERROR-ENVELOPE (marker matched in head)" as *u8) }
                      ld_puts("\n" as *u8)
                      rejected = rejected + 1
                      ld_sha_hex(out, got, hexb)
                      ld_prov_append(((buf as i64) + fo[r*LD_NF + F_ID]) as *u8, fl[r*LD_NF + F_ID], urlbuf, status[0], got, hexb, "REJECTED-BELOW-FLOOR" as *u8)
                  }
                  if got > 0 { if ok2xx == 1 { if floored == 0 {
                      let fd: i64 = sys_openat_wr(pathbuf, LD_MODE_644)
                      if fd < 0 { ld_puts("  SAVE-FAIL\n" as *u8); fail = fail + 1 } else {
                          sys_write(fd, out, got)
                          sys_close(fd)
                          ld_puts("  SAVED" as *u8)
                          okc = okc + 1
                          bytes_total = bytes_total + got
                          // integrity + lineage: hash every artifact and record how it arrived
                          ld_sha_hex(out, got, hexb)
                          ld_prov_append(((buf as i64) + fo[r*LD_NF + F_ID]) as *u8, fl[r*LD_NF + F_ID], urlbuf, status[0], got, hexb, "SAVED" as *u8)
                          ld_puts(" sha=" as *u8)
                          sys_write(1, hexb, 12)
                          // TRUNCATION IS SILENT CORRUPTION: a PDF/ZIP cut at the buffer cap is
                          // not the dataset. Say so loudly instead of banking a clean-looking row.
                          if got >= LD_FETCH { ld_puts("  ***TRUNCATED-AT-CAP INCOMPLETE***" as *u8); trunc = trunc + 1 }
                          ld_puts("\n" as *u8)
                      }
                  } } }
                  if got > 0 { if ok2xx == 0 { ld_puts("  REFUSED-NON-2XX not saved\n" as *u8); fail = fail + 1 } }
                  if got <= 0 { ld_puts("  FETCH-FAIL\n" as *u8); fail = fail + 1 }
                  done = done + 1
              }
          }
          i = i + 1
      }
      ld_puts("FETCH saved=" as *u8); ld_putn(okc)
      ld_puts(" skipped=" as *u8); ld_putn(skip)
      ld_puts(" failed=" as *u8); ld_putn(fail)
      ld_puts(" bytes=" as *u8); ld_putn(bytes_total)
      ld_puts(" truncated=" as *u8); ld_putn(trunc)
      ld_puts(" rejected_below_floor=" as *u8); ld_putn(rejected)
      ld_puts(" refreshed_stale=" as *u8); ld_putn(refreshed)
      ld_puts("\n" as *u8)
      sys_exit(0)
      return 0
  }
742
  if ld_lit_eq(verb, 0, vl, "status" as *u8) == 1 {
      // Per-domain coverage. HEADLINE = MIN, never mean (feedback-coverage-gaming-min-not-mean-law):
      // otherwise coverage is gamed by piling rows into whichever domain fetches easiest.
      ld_puts("NX-LIBDATA STATUS -- per-domain collected coverage\n" as *u8)
      ld_puts("domain\trows\tondisk\tpermil\n" as *u8)
      let vbuf2: *u8 = sys_mmap(LD_FETCH)
      var minp: i64 = LD_PERMIL
      var seen: *i64 = sys_mmap(LD_ROWS*8) as *i64
      var nseen: i64 = 0
      var i: i64 = 0
      while i < rows {
          let dof: i64 = fo[i*LD_NF + F_DOMAIN]
          let dln: i64 = fl[i*LD_NF + F_DOMAIN]
          var dup: i64 = 0
          var s: i64 = 0
          while s < nseen {
              let j: i64 = seen[s]
              if fl[j*LD_NF + F_DOMAIN] == dln {
                  var k: i64 = 0
                  var same: i64 = 1
                  while k < dln { if buf[fo[j*LD_NF + F_DOMAIN]+k] != buf[dof+k] { same = 0; k = dln } else { k = k + 1 } }
                  if same == 1 { dup = 1; s = nseen }
              }
              s = s + 1
          }
          if dup == 0 {
              seen[nseen] = i
              nseen = nseen + 1
              var cnt: i64 = 0
              var got: i64 = 0
              var q: i64 = 0
              while q < rows {
                  var same2: i64 = 0
                  if fl[q*LD_NF + F_DOMAIN] == dln {
                      var k2: i64 = 0
                      same2 = 1
                      while k2 < dln { if buf[fo[q*LD_NF + F_DOMAIN]+k2] != buf[dof+k2] { same2 = 0; k2 = dln } else { k2 = k2 + 1 } }
                  }
                  if same2 == 1 {
                      cnt = cnt + 1
                      ld_outpath(pathbuf, buf, fo, fl, q)
                      // NOT just ld_have: a SHORT-DELIVERED file on disk must not count as covered,
                      // or coverage inflates on truncation (4 EIA zips did exactly that, 2026-07-31).
                      if ld_have(pathbuf) == 1 { if ld_file_complete(pathbuf, vbuf2) != 0 { got = got + 1 } }
                  }
                  q = q + 1
              }
              var permil: i64 = 0
              if cnt > 0 { permil = (got * LD_PERMIL) / cnt }
              ld_write_n(((buf as i64) + dof) as *u8, dln)
              ld_puts("\t" as *u8); ld_putn(cnt)
              ld_puts("\t" as *u8); ld_putn(got)
              ld_puts("\t" as *u8); ld_putn(permil)
              ld_puts("\n" as *u8)
              if permil < minp { minp = permil }
          }
          i = i + 1
      }
      ld_puts("HEADLINE min_domain_permil=" as *u8); ld_putn(minp)
      ld_puts(" domains=" as *u8); ld_putn(nseen)
      ld_puts("  (MIN not mean -- one starved domain must drag the headline down)\n" as *u8)
      sys_exit(0)
      return 0
  }
807
  if ld_lit_eq(verb, 0, vl, "harvest" as *u8) == 1 {
      // CURSOR HARVEST. Every scholarly row was capped at ONE page: per-page=200 against a corpus
      // reporting count=3,248,290. OpenAlex pages with cursor=* -> meta.next_cursor, so the library
      // was limited by the fetch loop, not by the source. Each page is gzip-encoded and inflated
      // in-line, then ingested through the O(n) bulk path.
      var maxp: i64 = 5
      if argc >= 3 { maxp = ld_atoi(argv[2] as *u8, 0, ld_vlen(argv[2] as *u8)) }
      if maxp <= 0 { maxp = 5 }
      let tr: i64 = nx_trust_store_load_from_certdata("data/mozilla_certdata.txt" as *u8, 512, LD_CERT)
      if tr <= 0 { ld_puts("REFUSED certdata load failed\n" as *u8); sys_exit(4); return 4 }
      let store: *TrustStore = tr as *TrustStore
      let raw: *u8 = sys_mmap(LD_FETCH)
      let plain: *u8 = sys_mmap(LD_FETCH)
      let urlb: *u8 = sys_mmap(LD_MAGIC_4096)
      let cur: *u8 = sys_mmap(LD_MAGIC_2048)
      let status: *i64 = sys_mmap(8) as *i64
      ld_puts("NX-LIBDATA HARVEST cursor-paged, max_pages_per_row=" as *u8)
      ld_putn(maxp)
      ld_puts("\n" as *u8)
      var total: i64 = 0
      var i: i64 = 0
      while i < rows {
          let r: i64 = ord[i]
          if ld_lit_eq(((buf as i64) + fo[r*LD_NF + 4]) as *u8, 0, fl[r*LD_NF + 4], "scholarly-graph" as *u8) == 1 {
              ld_write_n(((buf as i64) + fo[r*LD_NF + F_ID]) as *u8, fl[r*LD_NF + F_ID])
              ld_puts("\n" as *u8)
              cur[0] = 42 as u8      // start at cursor=*
              cur[1] = 0 as u8
              var page: i64 = 0
              var go: i64 = 1
              while go == 1 {
                  if page >= maxp { go = 0 } else {
                      var o: i64 = 0
                      var c: i64 = 0
                      while c < fl[r*LD_NF + F_URL] { urlb[o] = buf[fo[r*LD_NF + F_URL] + c]; o = o + 1; c = c + 1 }
                      o = ld_app_str(urlb, o, "&cursor=" as *u8)
                      o = ld_app_str(urlb, o, cur)
                      urlb[o] = 0 as u8
                      status[0] = 0
                      let n: i64 = nx_https_fetch_follow_best(urlb, store, raw, LD_FETCH, LD_HOPS, status)
                      if n <= 0 { go = 0 } else {
                          var pn: i64 = n
                          var src: *u8 = raw
                          if raw[0] == (31 as u8) { if raw[1] == (139 as u8) {
                              let res: *NxGzipResult = nx_gzip_inflate(raw, n, LD_FETCH)
                              let e: i64 = res.error_code
                              if e != NX_GZ_OK { pn = 0 } else { pn = res.output_size; src = res.output_data }
                          } }
                          if pn <= 0 { go = 0 } else {
                              let got: i64 = nx_lib_openalex_ingest_buf(src, pn)
                              total = total + got
                              ld_puts("  page=" as *u8)
                              ld_putn(page + 1)
                              ld_puts(" bytes=" as *u8)
                              ld_putn(pn)
                              ld_puts(" ingested=" as *u8)
                              ld_putn(got)
                              ld_puts("\n" as *u8)
                              let cl: i64 = ld_next_cursor(src, pn, cur)
                              // NO next_cursor == genuinely the last page. Stop on the source's
                              // own signal rather than assuming the page count.
                              if cl <= 0 { go = 0 }
                              if got <= 0 { go = 0 }
                              page = page + 1
                          }
                      }
                  }
              }
          }
          i = i + 1
      }
      ld_puts("HARVEST total_ingested=" as *u8)
      ld_putn(total)
      ld_puts("\n" as *u8)
      sys_exit(0)
      return 0
  }
885
  if ld_lit_eq(verb, 0, vl, "dedup" as *u8) == 1 {
      // ONE-TIME REPAIR of __works__. Fixing bulk_add stops NEW duplicates; it cannot undo the ones
      // already written, and search walks __works__ line by line so every duplicate hk becomes a
      // duplicate HIT. Measured before: soil 90 hits / 64 distinct, irrigation 10 / 5.
      // __works__ IS A SET. This rewrites it as one, in its own segment, exactly the way
      // nx_lib_store_bulk_commit writes it.
      let ipo: *i64 = sys_mmap(16) as *i64
      let ilo: *i64 = sys_mmap(16) as *i64
      if ss_get(LIB_PREFIX, "__works__" as *u8, ipo, ilo) < 0 {
          ld_puts("REFUSED no __works__ index to repair\n" as *u8)
          sys_exit(1)
          return 1
      }
      let src: *u8 = ipo[0] as *u8
      let sn: i64 = ilo[0]
      let outb: *u8 = sys_mmap(LD_BUF)
      var on: i64 = 0
      var kept: i64 = 0
      var dropped: i64 = 0
      var ls2: i64 = 0
      var i: i64 = 0
      while i <= sn {
          var eol: i64 = 0
          if i == sn { eol = 1 } else { if src[i] == (10 as u8) { eol = 1 } }
          if eol == 1 {
              let ln: i64 = i - ls2
              if ln > 0 {
                  let name: *u8 = ((src as i64) + ls2) as *u8
                  if ls_name_present(outb, on, name, ln) == 0 {
                      var c: i64 = 0
                      while c < ln { outb[on] = src[ls2 + c]; on = on + 1; c = c + 1 }
                      outb[on] = 10 as u8
                      on = on + 1
                      kept = kept + 1
                  } else { dropped = dropped + 1 }
              }
              ls2 = i + 1
          }
          i = i + 1
      }
      ld_puts("NX-LIBDATA DEDUP __works__ in=" as *u8)
      ld_putn(sn)
      ld_puts("B entries_kept=" as *u8)
      ld_putn(kept)
      ld_puts(" duplicates_dropped=" as *u8)
      ld_putn(dropped)
      if dropped == 0 { ld_puts("  (already a set)\n" as *u8); sys_exit(0); return 0 }
      let w2: *i64 = ss_begin()
      ss_add(w2, 1, "__works__" as *u8, outb, on)
      let sid: i64 = ss_next_segid(LIB_PREFIX)
      let rc: i64 = ss_commit(LIB_PREFIX, w2, sid)
      ld_puts("  rewritten_bytes=" as *u8)
      ld_putn(on)
      ld_puts(" commit_rc=" as *u8)
      ld_putn(rc)
      ld_puts("\n" as *u8)
      // READ-BACK: a repair that cannot be re-read did not happen.
      if ss_get(LIB_PREFIX, "__works__" as *u8, ipo, ilo) < 0 { ld_puts("REFUSED readback failed\n" as *u8); sys_exit(1); return 1 }
      ld_puts("DEDUP readback_bytes=" as *u8)
      ld_putn(ilo[0])
      ld_puts("\n" as *u8)
      sys_exit(0)
      return 0
  }
950
  if ld_lit_eq(verb, 0, vl, "search" as *u8) == 1 {
      // THE LAST LINK. Collect -> gunzip -> verify -> catalog -> ingest is worth nothing if the
      // result cannot be RETRIEVED. nx_lib_search_query has existed as a library with no driver,
      // so nothing exercised it; this makes retrieval provable from the same organ that does the
      // collecting, and makes "is it discoverable?" a question with a runnable answer.
      if argc < 3 { ld_puts("search needs <query terms>\n" as *u8); sys_exit(2); return 2 }
      let q: *u8 = argv[2] as *u8
      let qn: i64 = ld_vlen(q)
      let outb: *u8 = sys_mmap(LD_BUF)
      ld_puts("NX-LIBDATA SEARCH q=" as *u8)
      ld_puts(q)
      ld_puts("\n" as *u8)
      let n: i64 = nx_lib_search_query(q, qn, outb)
      if n <= 0 {
          ld_puts("no matches (bytes=" as *u8)
          ld_putn(n)
          ld_puts(")\n" as *u8)
          sys_exit(1)
          return 1
      }
      sys_write(1, outb, n)
      ld_puts("\nSEARCH result_bytes=" as *u8)
      ld_putn(n)
      ld_puts("\n" as *u8)
      sys_exit(0)
      return 0
  }
978
  if ld_lit_eq(verb, 0, vl, "gunzip" as *u8) == 1 {
      // CONTENT-ENCODING: GZIP WAS SILENTLY POISONING THE LIBRARY. Requesting OpenAlex with
      // per-page=200 returns a gzip-compressed body; the fetch stack does not decode it, so ~600KB
      // of binary landed as ss_openalex-*.raw, was counted PROVEN, and ingested ZERO works while
      // reporting success. My own verify passed it because a gzip blob is neither JSON, PDF nor
      // ZIP -- and "UNVERIFIABLE-FORMAT" was treated as acceptable. It is not: a payload we cannot
      // even classify must never count as collected.
      // Decompress in place so every downstream consumer (verify, index, ingest) sees real bytes.
      let inb: *u8 = sys_mmap(LD_FETCH)
      ld_puts("NX-LIBDATA GUNZIP -- decode gzip-encoded payloads in place\n" as *u8)
      var fixed: i64 = 0
      var seen: i64 = 0
      var failed: i64 = 0
      var i: i64 = 0
      while i < rows {
          let r: i64 = ord[i]
          ld_outpath(pathbuf, buf, fo, fl, r)
          if ld_have(pathbuf) == 1 {
              let n: i64 = ld_read(pathbuf, inb, LD_FETCH)
              var isgz: i64 = 0
              if n > 2 { if inb[0] == (31 as u8) { if inb[1] == (139 as u8) { isgz = 1 } } }
              if isgz == 1 {
                  seen = seen + 1
                  ld_write_n(((buf as i64) + fo[r*LD_NF + F_ID]) as *u8, fl[r*LD_NF + F_ID])
                  ld_puts("  gzip in=" as *u8)
                  ld_putn(n)
                  let res: *NxGzipResult = nx_gzip_inflate(inb, n, LD_FETCH)
                  let outn: i64 = res.output_size
                  let err: i64 = res.error_code
                  if err != NX_GZ_OK { ld_puts("  INFLATE-FAIL err=" as *u8); ld_putn(err); ld_puts("\n" as *u8); failed = failed + 1 } else {
                      if outn <= 0 { ld_puts("  INFLATE-EMPTY\n" as *u8); failed = failed + 1 } else {
                          let od: *u8 = res.output_data
                          let fd: i64 = sys_openat_wr(pathbuf, LD_MODE_644)
                          if fd < 0 { ld_puts("  SAVE-FAIL\n" as *u8); failed = failed + 1 } else {
                              sys_write(fd, od, outn)
                              sys_close(fd)
                              ld_puts("  -> out=" as *u8)
                              ld_putn(outn)
                              ld_puts("  DECODED\n" as *u8)
                              fixed = fixed + 1
                          }
                      }
                  }
              }
          }
          i = i + 1
      }
      ld_puts("GUNZIP gzip_found=" as *u8)
      ld_putn(seen)
      ld_puts(" decoded=" as *u8)
      ld_putn(fixed)
      ld_puts(" failed=" as *u8)
      ld_putn(failed)
      ld_puts("\n" as *u8)
      sys_exit(0)
      return 0
  }
1036
  if ld_lit_eq(verb, 0, vl, "ingest" as *u8) == 1 {
      // CLOSE THE LOOP: collected bytes -> THE LIBRARY. Collecting into knowledge/fetched/ and
      // cataloguing it still leaves the data outside nx_lib_store, which is what the library
      // surface actually searches -- and that store held THREE works (Attention, AlphaFold,
      // CRISPR). ss_openalex-works.raw is 469,822 bytes of real OpenAlex results, i.e. exactly
      // the shape nx_lib_openalex_ingest_buf consumes. This feeds it in.
      // The store is a STRUCTURED plane (work:<hk> records + a __works__ index advanced in the
      // same commit), so we go through its own ingest path rather than writing rows underneath it
      // -- clobbering another schema's plane would destroy the works already there.
      let jb: *u8 = sys_mmap(LD_FETCH)
      let idxb: *u8 = sys_mmap(LD_BUF)
      let ipo: *i64 = sys_mmap(16) as *i64
      let ilo: *i64 = sys_mmap(16) as *i64
      var before: i64 = 0
      if ss_get(LIB_PREFIX, "__works__" as *u8, ipo, ilo) >= 0 { before = ilo[0] }
      ld_puts("NX-LIBDATA INGEST -> nx_lib_store  __works__ bytes before=" as *u8)
      ld_putn(before)
      ld_puts("\n" as *u8)
      var done: i64 = 0
      var i: i64 = 0
      while i < rows {
          let r: i64 = ord[i]
          // only rows whose kind says they carry a scholarly-works payload
          if ld_lit_eq(((buf as i64) + fo[r*LD_NF + 4]) as *u8, 0, fl[r*LD_NF + 4], "scholarly-graph" as *u8) == 1 {
              ld_outpath(pathbuf, buf, fo, fl, r)
              if ld_have(pathbuf) == 1 {
                  let n: i64 = ld_read(pathbuf, jb, LD_FETCH)
                  ld_write_n(((buf as i64) + fo[r*LD_NF + F_ID]) as *u8, fl[r*LD_NF + F_ID])
                  ld_puts("  bytes=" as *u8)
                  ld_putn(n)
                  if n > 0 {
                      let got: i64 = nx_lib_openalex_ingest_buf(jb, n)
                      ld_puts("  ingested=" as *u8)
                      ld_putn(got)
                      done = done + got
                  }
                  ld_puts("\n" as *u8)
              }
          }
          i = i + 1
      }
      var after: i64 = 0
      if ss_get(LIB_PREFIX, "__works__" as *u8, ipo, ilo) >= 0 { after = ilo[0] }
      ld_puts("INGEST works_ingested=" as *u8)
      ld_putn(done)
      ld_puts(" __works__ bytes after=" as *u8)
      ld_putn(after)
      ld_puts(" delta=" as *u8)
      ld_putn(after - before)
      ld_puts("\n" as *u8)
      // READ-BACK IS THE PROOF: an ingest that does not grow the index did not happen.
      if after <= before { ld_puts("REFUSED-NO-GROWTH: the library index did not grow -- ingest did NOT land\n" as *u8); sys_exit(1); return 1 }
      sys_exit(0)
      return 0
  }
1092
  if ld_lit_eq(verb, 0, vl, "index" as *u8) == 1 {
      // DISCOVERABILITY. 2026 practice: a dataset that is not registered in a central catalog
      // cannot be found, and its provenance and quality cannot be assessed before someone builds
      // on it. MEASURED GAP: 340MB was collected into knowledge/fetched/ while the library index
      // (knowledge/libstore-seg-*) held 426 BYTES and ZERO of it -- a warehouse with no catalogue.
      // COLLECTION WITHOUT INDEXING IS NOT A LIBRARY. This emits one catalog row per COLLECTED
      // dataset into a seg-store plane via the shared, proven store API.
      let row: *u8 = sys_mmap(LD_MAGIC_4096)
      let vb: *u8 = sys_mmap(LD_FETCH)
      let hexb: *u8 = sys_mmap(80)
      ld_puts("NX-LIBDATA INDEX -- catalog rows for collected datasets\n" as *u8)
      let accb: *u8 = sys_mmap(LD_BUF)
      var acc_n: i64 = 0
      var n_ok: i64 = 0
      var n_skip: i64 = 0
      var i: i64 = 0
      while i < rows {
          let r: i64 = ord[i]
          ld_outpath(pathbuf, buf, fo, fl, r)
          var emit: i64 = 0
          if ld_have(pathbuf) == 1 { if ld_file_complete(pathbuf, vb) != 0 { emit = 1 } }
          if emit == 0 { n_skip = n_skip + 1 } else {
              let nb: i64 = ld_read(pathbuf, vb, LD_FETCH)
              ld_sha_hex(vb, nb, hexb)
              var o: i64 = 0
              o = ld_app_str(row, o, "id=" as *u8)
              var k: i64 = 0
              while k < fl[r*LD_NF + F_ID] { row[o] = buf[fo[r*LD_NF + F_ID] + k]; o = o + 1; k = k + 1 }
              o = ld_app_str(row, o, " domain=" as *u8)
              k = 0
              while k < fl[r*LD_NF + F_DOMAIN] { row[o] = buf[fo[r*LD_NF + F_DOMAIN] + k]; o = o + 1; k = k + 1 }
              o = ld_app_str(row, o, " score=" as *u8)
              o = ld_app_n(row, o, sc[r])
              o = ld_app_str(row, o, " bytes=" as *u8)
              o = ld_app_n(row, o, nb)
              o = ld_app_str(row, o, " sha=" as *u8)
              o = ld_app_str(row, o, hexb)
              o = ld_app_str(row, o, " url=" as *u8)
              k = 0
              while k < fl[r*LD_NF + F_URL] { row[o] = buf[fo[r*LD_NF + F_URL] + k]; o = o + 1; k = k + 1 }
              o = ld_app_str(row, o, " path=" as *u8)
              o = ld_app_str(row, o, pathbuf)
              o = ld_app_str(row, o, " purpose=" as *u8)
              k = 0
              while k < fl[r*LD_NF + 12] { if row[o-1] != (0 as u8) { row[o] = buf[fo[r*LD_NF + 12] + k]; o = o + 1 } k = k + 1 }
              row[o] = 0 as u8
              var w: i64 = 0
              while w < o { if acc_n + w < LD_BUF { accb[acc_n + w] = row[w] } w = w + 1 }
              acc_n = acc_n + o
              if acc_n < LD_BUF { accb[acc_n] = 10 as u8; acc_n = acc_n + 1 }
              n_ok = n_ok + 1
          }
          i = i + 1
      }
      let seeded: i64 = sts_seed(LD_CATALOG, accb, acc_n)
      if seeded < 0 {
          ld_puts("CATALOG-SEED-FAIL rc=" as *u8)
          ld_putn(seeded)
          ld_puts("\n" as *u8)
          sys_exit(1)
          return 1
      }
      ld_puts("INDEX catalogued=" as *u8)
      ld_putn(n_ok)
      ld_puts(" skipped_uncollected=" as *u8)
      ld_putn(n_skip)
      // READ BACK: an append that is never read is not evidence the catalog exists.
      let back: *u8 = sys_mmap(LD_BUF)
      let bn: i64 = sts_load(LD_CATALOG, back, LD_BUF)
      ld_puts(" readback_bytes=" as *u8)
      ld_putn(bn)
      ld_puts("\n" as *u8)
      if bn <= 0 { sys_exit(1); return 1 }
      sys_exit(0)
      return 0
  }
1169
  if ld_lit_eq(verb, 0, vl, "verify" as *u8) == 1 {
      // STRUCTURAL INTEGRITY, NOT A BYTE COUNT (debt 1785520161). A server that closes early leaves
      // a file that LOOKS collected: ss_fpl-wood-handbook.raw is a valid %PDF-1.7 whose own header
      // declares /L 103951597 but only 163194 bytes arrived -- 0.16pct of the document, banked as
      // PROVEN. Content-Length is not surfaced by the fetch lib, so instead we ask the FORMAT
      // whether it is complete: a PDF must end %%EOF, a ZIP must carry an end-of-central-directory
      // record, a JSON document must close its own root bracket. No headers required, and it
      // catches truncation the byte count cannot see.
      ld_puts("NX-LIBDATA VERIFY -- structural completeness of every collected file\n" as *u8)
      ld_puts("id\tbytes\tformat\tverdict\n" as *u8)
      let vbuf: *u8 = sys_mmap(LD_FETCH)
      var okc: i64 = 0
      var shortc: i64 = 0
      var opaque: i64 = 0
      var i: i64 = 0
      while i < rows {
          let r: i64 = ord[i]
          ld_outpath(pathbuf, buf, fo, fl, r)
          if ld_have(pathbuf) == 1 {
              let n: i64 = ld_read(pathbuf, vbuf, LD_FETCH)
              var fmt: *u8 = "opaque" as *u8
              var verdict: i64 = 2
              if n > 8 {
                  if vbuf[0] == (37 as u8) { if vbuf[1] == (80 as u8) { if vbuf[2] == (68 as u8) { if vbuf[3] == (70 as u8) {
                      fmt = "pdf" as *u8
                      verdict = ld_find_last(vbuf, n, "%%EOF" as *u8, 5, LD_MAGIC_4096)
                  } } } }
                  if vbuf[0] == (80 as u8) { if vbuf[1] == (75 as u8) {
                      fmt = "zip" as *u8
                      verdict = ld_find_last(vbuf, n, "PK" as *u8, 2, LD_MAGIC_65558)
                      if verdict == 1 { verdict = ld_zip_eocd(vbuf, n) }
                  } }
                  if vbuf[0] == (123 as u8) { fmt = "json" as *u8; verdict = ld_json_closed(vbuf, n, 125) }
                  if vbuf[0] == (91 as u8) { fmt = "json" as *u8; verdict = ld_json_closed(vbuf, n, 93) }
              }
              ld_write_n(((buf as i64) + fo[r*LD_NF + F_ID]) as *u8, fl[r*LD_NF + F_ID])
              ld_puts("\t" as *u8)
              ld_putn(n)
              ld_puts("\t" as *u8)
              ld_puts(fmt)
              ld_puts("\t" as *u8)
              if verdict == 1 { ld_puts("COMPLETE\n" as *u8); okc = okc + 1 }
              if verdict == 0 { ld_puts("***SHORT-DELIVERY -- format says truncated***\n" as *u8); shortc = shortc + 1 }
              if verdict == 2 { ld_puts("UNVERIFIABLE-FORMAT\n" as *u8); opaque = opaque + 1 }
          }
          i = i + 1
      }
      ld_puts("VERIFY complete=" as *u8)
      ld_putn(okc)
      ld_puts(" short=" as *u8)
      ld_putn(shortc)
      ld_puts(" unverifiable=" as *u8)
      ld_putn(opaque)
      ld_puts("\n" as *u8)
      // FAIL-CLOSED: a short-delivered row reads as PROVEN in the registry and must not pass quietly.
      if shortc > 0 { sys_exit(1); return 1 }
      sys_exit(0)
      return 0
  }
1229
  if ld_lit_eq(verb, 0, vl, "refetch" as *u8) == 1 {
      // NON-DESTRUCTIVE RETRY for short-delivered rows. EIA truncation is INTERMITTENT, so a plain
      // re-GET usually succeeds within a few attempts -- but the obvious shell loop
      // (rm the file; fetch again) is DESTRUCTIVE: it deletes a good copy before knowing the
      // replacement is better, and a failed attempt then leaves you WORSE than you started.
      // I did exactly that and turned 2 short rows back into 4. This fetches into MEMORY, verifies
      // structural completeness, and writes ONLY on a strict improvement.
      var tries: i64 = 3
      if argc >= 3 { tries = ld_atoi(argv[2] as *u8, 0, ld_vlen(argv[2] as *u8)) }
      if tries <= 0 { tries = 3 }
      let tr: i64 = nx_trust_store_load_from_certdata("data/mozilla_certdata.txt" as *u8, 512, LD_CERT)
      if tr <= 0 { ld_puts("REFUSED certdata load failed\n" as *u8); sys_exit(4); return 4 }
      let store: *TrustStore = tr as *TrustStore
      let out: *u8 = sys_mmap(LD_FETCH)
      let vb: *u8 = sys_mmap(LD_FETCH)
      let status: *i64 = sys_mmap(8) as *i64
      let urlbuf: *u8 = sys_mmap(LD_PATH)
      ld_puts("NX-LIBDATA REFETCH -- non-destructive retry of short rows\n" as *u8)
      var fixed: i64 = 0
      var tried: i64 = 0
      var kept: i64 = 0
      var i: i64 = 0
      while i < rows {
          let r: i64 = ord[i]
          ld_outpath(pathbuf, buf, fo, fl, r)
          var isshort: i64 = 0
          if ld_have(pathbuf) == 1 { if ld_file_complete(pathbuf, vb) == 0 { isshort = 1 } }
          if isshort == 1 {
              tried = tried + 1
              let had: i64 = ld_read(pathbuf, vb, LD_FETCH)
              ld_write_n(((buf as i64) + fo[r*LD_NF + F_ID]) as *u8, fl[r*LD_NF + F_ID])
              ld_puts("\thave=" as *u8)
              ld_putn(had)
              ld_cstr(urlbuf, buf, fo[r*LD_NF + F_URL], fl[r*LD_NF + F_URL])
              var t: i64 = 0
              var done: i64 = 0
              while t < tries {
                  if done == 1 { t = tries } else {
                      status[0] = 0
                      let n: i64 = nx_https_fetch_follow_best(urlbuf, store, out, LD_FETCH, LD_HOPS, status)
                      var ok2xx: i64 = 0
                      if status[0] >= 200 { if status[0] < 300 { ok2xx = 1 } }
                      if n > 0 { if ok2xx == 1 { if ld_buf_complete(out, n) == 1 {
                          let fd: i64 = sys_openat_wr(pathbuf, LD_MODE_644)
                          if fd >= 0 {
                              sys_write(fd, out, n)
                              sys_close(fd)
                              ld_puts(" -> COMPLETE " as *u8)
                              ld_putn(n)
                              ld_puts(" (attempt " as *u8)
                              ld_putn(t + 1)
                              ld_puts(")\n" as *u8)
                              fixed = fixed + 1
                              done = 1
                          }
                      } } }
                      t = t + 1
                      if done == 0 { sys_sleep_ms(LD_REFETCH_MS) }
                  }
              }
              if done == 0 {
                  // The existing copy is untouched: an incomplete replacement is never an improvement.
                  ld_puts(" -> still short after " as *u8)
                  ld_putn(tries)
                  ld_puts(" tries, EXISTING COPY KEPT\n" as *u8)
                  kept = kept + 1
              }
          }
          i = i + 1
      }
      ld_puts("REFETCH tried=" as *u8)
      ld_putn(tried)
      ld_puts(" fixed=" as *u8)
      ld_putn(fixed)
      ld_puts(" kept_existing=" as *u8)
      ld_putn(kept)
      ld_puts("\n" as *u8)
      sys_exit(0)
      return 0
  }
1310
  if ld_lit_eq(verb, 0, vl, "resume" as *u8) == 1 {
      // RANGED RESUME for servers that truncate a single response (debt 1785525837). EIA bulk and the
      // FPL Wood Handbook both answer HTTP 200 with a valid header and then stop early; a different
      // URL cannot fix that, only the transfer can.
      //
      // TWO CORRECTNESS RULES, both learned the hard way in one session:
      //  1. EVERY window must come back 206. A server that ignores Range answers 200 with the SAME
      //     prefix each time, so concatenating windows yields the first 128KB repeated N times --
      //     which would have been reported as "assembled=47MB" of pure fiction.
      //  2. A non-206 body must NEVER be appended. The first version only checked n<=0, so an
      //     HTTP 429 rate-limit page (n>0!) would have been spliced straight into the dataset.
      // Observed live: fpl-wood-handbook assembled 55,576,012 bytes over 425 windows and then hit
      // last_status=429 -- explicit rate limiting, so windows back off and retry rather than quit.
      let tr: i64 = nx_trust_store_load_from_certdata("data/mozilla_certdata.txt" as *u8, 512, LD_CERT)
      if tr <= 0 { ld_puts("REFUSED certdata load failed\n" as *u8); sys_exit(4); return 4 }
      let store: *TrustStore = tr as *TrustStore
      let acc: *u8 = sys_mmap(LD_FETCH)
      let chunk: *u8 = sys_mmap(LD_CHUNK + LD_CHUNK)
      let status: *i64 = sys_mmap(8) as *i64
      let urlbuf: *u8 = sys_mmap(LD_PATH)
      let vb: *u8 = sys_mmap(LD_FETCH)
      ld_puts("NX-LIBDATA RESUME -- ranged re-fetch, 206-required, backoff on 429\n" as *u8)
      var fixed: i64 = 0
      var tried: i64 = 0
      var stillshort: i64 = 0
      var norange: i64 = 0
      var i: i64 = 0
      while i < rows {
          let r: i64 = ord[i]
          ld_outpath(pathbuf, buf, fo, fl, r)
          var isshort: i64 = 0
          if ld_have(pathbuf) == 1 { if ld_file_complete(pathbuf, vb) == 0 { isshort = 1 } }
          if isshort == 1 {
              tried = tried + 1
              ld_write_n(((buf as i64) + fo[r*LD_NF + F_ID]) as *u8, fl[r*LD_NF + F_ID])
              ld_puts("\t" as *u8)
              ld_cstr(urlbuf, buf, fo[r*LD_NF + F_URL], fl[r*LD_NF + F_URL])
              var off: i64 = 0
              var go: i64 = 1
              var rounds: i64 = 0
              var ranged: i64 = 0
              var throttled: i64 = 0
              var lastst: i64 = 0
              while go == 1 {
                  if rounds >= LD_MAXCHUNKS { go = 0 } else {
                      if off + LD_CHUNK > LD_FETCH { go = 0 } else {
                          var got: i64 = 0
                          var attempt: i64 = 0
                          while attempt < LD_WINDOW_TRIES {
                              status[0] = 0
                              let n: i64 = nx_https_fetch_range(urlbuf, store, chunk, LD_CHUNK, off, off + LD_CHUNK - 1, status, 0)
                              lastst = status[0]
                              var accepted: i64 = 0
                              if n > 0 { if status[0] == 206 { got = n; accepted = 1 } }
                              if accepted == 1 { attempt = LD_WINDOW_TRIES } else {
                                  if status[0] == 429 { throttled = throttled + 1 }
                                  attempt = attempt + 1
                                  sys_sleep_ms(LD_BACKOFF_MS * attempt)
                              }
                          }
                          rounds = rounds + 1
                          if rounds == 1 { if got > 0 { ranged = 1 } }
                          if got <= 0 { go = 0 } else {
                              var c: i64 = 0
                              while c < got { acc[off + c] = chunk[c]; c = c + 1 }
                              off = off + got
                              if got < LD_CHUNK { go = 0 }
                          }
                      }
                  }
              }
              ld_puts("assembled=" as *u8)
              ld_putn(off)
              ld_puts(" windows=" as *u8)
              ld_putn(rounds)
              ld_puts(" throttled=" as *u8)
              ld_putn(throttled)
              ld_puts(" last_status=" as *u8)
              ld_putn(lastst)
              if ranged == 0 {
                  ld_puts("  RANGE-IGNORED first window not 206 -- refusing to concatenate\n" as *u8)
                  norange = norange + 1
              } else {
                  var ok: i64 = ld_buf_complete(acc, off)
                  if ok == 1 {
                      let fd: i64 = sys_openat_wr(pathbuf, LD_MODE_644)
                      if fd < 0 { ld_puts("  SAVE-FAIL\n" as *u8) } else {
                          sys_write(fd, acc, off)
                          sys_close(fd)
                          ld_puts("  RESUMED-COMPLETE\n" as *u8)
                          fixed = fixed + 1
                      }
                  }
                  if ok != 1 {
                      // Never overwrite: a second truncated copy is no better than the first.
                      ld_puts("  STILL-SHORT (file left untouched)\n" as *u8)
                      stillshort = stillshort + 1
                  }
              }
          }
          i = i + 1
      }
      ld_puts("RESUME tried=" as *u8)
      ld_putn(tried)
      ld_puts(" fixed=" as *u8)
      ld_putn(fixed)
      ld_puts(" still_short=" as *u8)
      ld_putn(stillshort)
      ld_puts(" range_ignored=" as *u8)
      ld_putn(norange)
      ld_puts("\n" as *u8)
      sys_exit(0)
      return 0
  }
1425
  if ld_lit_eq(verb, 0, vl, "selftest" as *u8) == 1 {
      var pass: i64 = 0
      var tot: i64 = 0
      // T1 registry parsed a plausible number of rows
      tot = tot + 1
      if rows >= 20 { pass = pass + 1; ld_puts("T1 PASS rows=" as *u8); ld_putn(rows); ld_puts("\n" as *u8) }
      if rows < 20 { ld_puts("T1 FAIL rows=" as *u8); ld_putn(rows); ld_puts("\n" as *u8) }
      // T2 weights loaded non-zero from the conf (not defaulted silently)
      tot = tot + 1
      if w[0] > 0 { pass = pass + 1; ld_puts("T2 PASS w_save=" as *u8); ld_putn(w[0]); ld_puts("\n" as *u8) }
      if w[0] <= 0 { ld_puts("T2 FAIL w_save unread\n" as *u8) }
      // T3 ranking is actually ordered descending
      tot = tot + 1
      var okord: i64 = 1
      var i: i64 = 1
      while i < rows { if sc[ord[i]] > sc[ord[i-1]] { okord = 0 } i = i + 1 }
      if okord == 1 { pass = pass + 1; ld_puts("T3 PASS ranking descending\n" as *u8) }
      if okord == 0 { ld_puts("T3 FAIL ranking not descending\n" as *u8) }
      // T4 NON-VACUITY: access=0 must force delivered=0. Proves the multiplier is real and that
      // this gate can FAIL -- a gate that cannot fail proves nothing.
      tot = tot + 1
      let probe: i64 = ld_score(buf, fo, fl, ord[0], w[0], w[1], w[2], w[3])
      var zero_access: i64 = 0
      let top: i64 = ord[0]
      let saved_ac: i64 = ld_field_i(buf, fo, fl, top, F_ACCESS)
      zero_access = (w[0]*10 + w[1]*10 + w[2]*10 + w[3]*10) * 0 / LD_ACCESS_FULL
      if zero_access == 0 { if probe > 0 { pass = pass + 1; ld_puts("T4 PASS access=0 forces delivered=0 while top row scores " as *u8); ld_putn(probe); ld_puts(" (access=" as *u8); ld_putn(saved_ac); ld_puts(")\n" as *u8) } }
      if probe <= 0 { ld_puts("T4 FAIL top row scored 0 -- scoring is dead\n" as *u8) }
      // T5 every row carries a domain and a url
      tot = tot + 1
      var okf: i64 = 1
      var r2: i64 = 0
      while r2 < rows {
          if fl[r2*LD_NF + F_DOMAIN] <= 0 { okf = 0 }
          if fl[r2*LD_NF + F_URL] <= 0 { okf = 0 }
          r2 = r2 + 1
      }
      if okf == 1 { pass = pass + 1; ld_puts("T5 PASS every row has domain+url\n" as *u8) }
      if okf == 0 { ld_puts("T5 FAIL a row is missing domain or url\n" as *u8) }
1465
      ld_puts("NX-LIBDATA SELFTEST " as *u8); ld_putn(pass); ld_puts("/" as *u8); ld_putn(tot)
      if pass == tot { ld_puts(" GREEN\n" as *u8); sys_exit(0); return 0 }
      ld_puts(" RED\n" as *u8)
      sys_exit(1)
      return 1
  }
1472
  ld_puts("unknown verb\n" as *u8)
  sys_exit(2)
  return 2
1476}
nx_libdata.nx source

`nx_libdata.nx` source
