code wiki / (root) / nx_incumbent_lib.nx
`nx_incumbent_lib.nx` source

↩ module page · 1427 lines · 61815 B
1// nx_incumbent_lib.nx -- THE ONE RULER FOR A RUNG CONTRACT'S INCUMBENTS AND THE RECORD'S REJECTIONS (engineshift ES28).
2//
3// Operator 2026-09-14, on the search R0 review: "this is the stuff we need the search and nishi estate to do
4// proactively not rely on you treasure hunting." A prior seat rebuilt the R0 rerank arm as a learned fusion over
5// PPMI while the estate already held the trained dense embedding (knowledge/index/embed_v1.bin), the lib that
6// scores with it (nx_dr_densejudge) and, in that lib's own header, the MEASURED REJECTION of exactly that fusion
7// (DR-13). The reviewing seat found all three by glob and header reads: a retrieval failure, not a discovery.
8// nx_capsearch ranks registered tools and libs by name, title and grammar; it cannot see a header's prose, a data
9// asset, or a rejection. This lib answers a rung's contract from the record itself, and nx_compare_rank prints the
10// answer on every open rung so no seat starts a build from its own memory.
11//
12// THE INDEX (a derived artefact, stamped, refused when stale): one row per organ source in the two runtime roots
13//   org|<name>|<root>|<header words, lowercase, unique, first 12 bytes each>|<knowledge/ paths the header names>|<rejection lines>
14// and one per data asset under knowledge/index:   asset|<name>|<name words>
15// headed by   # NX-DERIVED incumbent index generated_at=<epoch> files=<n> head_truncated=<n> assets=<n> corpus_complete=<0|1>
16// The HEADER of an organ is its leading comment block (the // lines before the first code line); its words, its
17// basename parts and its column-0 func names are one bag. A header longer than the read window is COUNTED
18// (head_truncated), never silently cut. A bag word is kept to 12 bytes for display; no key or match reads past 8.
19//
20// THE MATCH: the contract terms are the rung's title, symbol and note tokenised to lowercase runs of letters and
21// digits at least min_tok long, deduplicated by their MATCH PREFIX (rerank and reranker are one term, beat and
22// beats are one term); an all-digit term is DROPPED and counted (a number is a measurement, never a capability word:
23// measured 2026-09-14, the 321 in "321 permille" matched three throwaway test organs at a rare-token weight). A term
24// matches a bag word when their leading bytes agree -- the first morph_long bytes for a term at least that long,
25// else the WHOLE term (mine~miner is the prefix rule nx_capsearch measured on its gold set at 4 bytes; here the
26// 4-byte key only narrows the posting chain, because measured on 2026-09-14 the 4-byte cut made dense match density
27// and wired match wire). Each matched term weighs idf_scale / (idf_base + df), df
28// being the number of organs carrying it (the weighting nx_capsearch ships), and a term carried by more than
29// df_max_permil of the organs is DROPPED as non-discriminating and COUNTED, so no stop-word list is hand-written:
30// the corpus decides which words say nothing. An organ's score is the sum over its distinct matched terms, and a
31// term that also hits the organ's own NAME parts adds its idf a second time: the name is the organ's own
32// declaration of what it is, a second piece of evidence weighed like the first (the rule nx_capsearch's known-good
33// tooltop applies, a stem hit on the name counted beside a hit in the title). MEASURED 2026-09-14 on the live tree
34// (20,820 organs): ranking by a name TIER first put an organ named for two process words (wired, exceed) second
35// for R0 at a tiny weight, so the name hit is weighed, never sorted on. The rung's own organ is excluded.
36// THE LIST IS THE ANSWER, NEVER A THRESHOLD: the top topn organs print with their name hits, score and matched
37// terms, then the data assets those headers name plus assets whose own name matches a term, then the rejection
38// lines those headers carry. PRIOR-REJECTIONS is its own axis: beyond the top organs, every organ whose NAME carries
39// a contract term and whose header records a rejection is listed (capped by rej_orgs, overflow counted), because a
40// rejection on an organ named for the contract's own word is the record answering the contract -- that is how R0
41// reaches nx_dr_densejudge (named dense) and its DR-13 line, and through that header the embed_v1.bin asset, while
42// the BEIR lane's own organs hold the top of the incumbents list. NONE when nothing matches, with the terms tried.
43// COVERAGE travels with every answer: files scanned, headers truncated, corpus_complete, index age and state.
44// COMPOSES sys_read_file, sys_getdents64 (the ps_has loop shape of nx_presubmit_lib), sys_openat_wr + sys_renameat
45// (atomic publish), sys_clock_gettime_real. Every number lives in knowledge/incumbent.conf (conf > defaults).
46// Scratch buffers are allocated once per build or per match, never per file or per word (no allocation in a hot loop).
47// license_tier: ORIGINAL   Writes only the index it is asked to write. No hw writes (Rule 26).
48import "nx_syscalls.nx"
49
50const INC_I64: i64 = 8
51const INC_NL: i64 = 10
52const INC_CR: i64 = 13
53const INC_TAB: i64 = 9
54const INC_PIPE: i64 = 124
55const INC_SPACE: i64 = 32
56const INC_SLASH: i64 = 47
57const INC_SEMI: i64 = 59
58const INC_EQ: i64 = 61
59const INC_HASHCH: i64 = 35
60const INC_DOT: i64 = 46
61const INC_COLON: i64 = 58
62const INC_LPAREN: i64 = 40
63const INC_RPAREN: i64 = 41
64const INC_COMMA: i64 = 44
65const INC_DQUOTE: i64 = 34
66const INC_SQUOTE: i64 = 39
67const INC_RBRACK: i64 = 93
68const INC_GT: i64 = 62
69const INC_MINUS: i64 = 45
70const INC_A: i64 = 97
71const INC_Z: i64 = 122
72const INC_UA: i64 = 65
73const INC_UZ: i64 = 90
74const INC_D0: i64 = 48
75const INC_D9: i64 = 57
76const INC_CH_N: i64 = 110
77const INC_CH_X: i64 = 120
78const INC_CASE_DELTA: i64 = 32
79const INC_KEY_BYTES: i64 = 8                  // a key packs up to 8 leading bytes into one i64; no match reads past 8
80const INC_WORD_KEEP: i64 = 12                 // a bag word or a term is kept to 12 bytes for display
81const INC_BYTE_BITS: i64 = 8
82const INC_HASH_MUL: i64 = 1099511628211       // an odd multiplier for the packed key (the FNV-1a prime)
83const INC_HASH_SHIFT: i64 = 29
84const INC_NAME_CAP: i64 = 256
85const INC_PATH_CAP: i64 = 1024
86const INC_NUM_CAP: i64 = 32
87const INC_DIRBUF: i64 = 65536                 // the getdents window nx_presubmit_lib uses (PS_DIRBUF)
88const INC_SETCAP: i64 = 4096                  // per-file word set slots (a header carries hundreds of words, never thousands)
89const INC_HASH_MIN: i64 = 1024
90const INC_CONF_A: *u8 = "knowledge/incumbent.conf"
91const INC_CONF_B: *u8 = "../knowledge/incumbent.conf"
92const INC_REJ_A: *u8 = "knowledge/incumbent_reject.conf"
93const INC_REJ_B: *u8 = "../knowledge/incumbent_reject.conf"
94const INC_INDEX_A: *u8 = "knowledge/status/incumbent_index.txt"
95const INC_INDEX_B: *u8 = "../knowledge/status/incumbent_index.txt"
96const INC_TMP_SUFFIX: *u8 = ".tmp"
97const INC_ROOT_RT_A: *u8 = "buildroot/runtime"
98const INC_ROOT_HDL_A: *u8 = "buildroot/runtime/_hdl_build"
99const INC_ASSET_A: *u8 = "knowledge/index"
100const INC_ROOT_RT_B: *u8 = "runtime"
101const INC_ROOT_HDL_B: *u8 = "runtime/_hdl_build"
102const INC_ASSET_B: *u8 = "../knowledge/index"
103const INC_HEAD_MARK: *u8 = "# NX-DERIVED incumbent index generated_at="
104const INC_ORG_TAG: *u8 = "org|"
105const INC_ASSET_TAG: *u8 = "asset|"
106const INC_KNOW: *u8 = "knowledge/"
107const INC_FUNC: *u8 = "func "
108const INC_FUNC_LEN: i64 = 5
109const INC_REJ_SEP: *u8 = ";; "
110const INC_ORG_FIELDS: i64 = 6
111const INC_ASSET_FIELDS: i64 = 3
112const INC_ROW_SLACK: i64 = 1024               // per row beyond the header window: name, root, separators, asset paths
113// defaults: bootstrap values, overridden by knowledge/incumbent.conf (the configuration hierarchy)
114const INC_D_HEAD_BYTES: i64 = 8192
115const INC_D_MORPH_LONG: i64 = 6
116const INC_D_MORPH_SHORT: i64 = 4
117const INC_D_MIN_TOK: i64 = 3
118const INC_D_TOPN: i64 = 8
119const INC_D_DF_MAX_PERMIL: i64 = 250
120const INC_D_IDF_SCALE: i64 = 1000000
121const INC_D_IDF_BASE: i64 = 3
122const INC_D_REJ_PER_ORG: i64 = 2
123const INC_D_REJ_LINE_CAP: i64 = 160
124const INC_D_INDEX_MAX_AGE_S: i64 = 172800
125const INC_D_MAX_TERMS: i64 = 62
126const INC_D_REJ_ORGS: i64 = 8
127const INC_PERMIL: i64 = 1000
128// conf slots
129const INC_C_HEAD_BYTES: i64 = 0
130const INC_C_MORPH_LONG: i64 = 1
131const INC_C_MORPH_SHORT: i64 = 2
132const INC_C_MIN_TOK: i64 = 3
133const INC_C_TOPN: i64 = 4
134const INC_C_DF_MAX_PERMIL: i64 = 5
135const INC_C_IDF_SCALE: i64 = 6
136const INC_C_IDF_BASE: i64 = 7
137const INC_C_REJ_PER_ORG: i64 = 8
138const INC_C_REJ_LINE_CAP: i64 = 9
139const INC_C_INDEX_MAX_AGE_S: i64 = 10
140const INC_C_MAX_TERMS: i64 = 11
141const INC_C_SRC: i64 = 12                     // 1 conf file read, 0 defaults
142const INC_C_REJ_ORGS: i64 = 13                // organs listed under PRIOR-REJECTIONS beyond the top organs
143const INC_C_N: i64 = 14
144// index g-box slots
145const INC_G_BUF: i64 = 0
146const INC_G_N: i64 = 1
147const INC_G_ROWS: i64 = 2
148const INC_G_R_NAME: i64 = 3
149const INC_G_R_ROOT: i64 = 4
150const INC_G_R_WORDS: i64 = 5
151const INC_G_R_ASSETS: i64 = 6
152const INC_G_R_REJ: i64 = 7
153const INC_G_ASSETS: i64 = 8
154const INC_G_A_NAME: i64 = 9
155const INC_G_A_WORDS: i64 = 10
156const INC_G_HCAP: i64 = 11
157const INC_G_HKEY: i64 = 12
158const INC_G_HHEAD: i64 = 13
159const INC_G_PWORD: i64 = 14
160const INC_G_PROW: i64 = 15
161const INC_G_PNEXT: i64 = 16
162const INC_G_NPOST: i64 = 17
163const INC_G_GEN: i64 = 18
164const INC_G_FILES: i64 = 19
165const INC_G_TRUNC: i64 = 20
166const INC_G_COMPLETE: i64 = 21
167const INC_G_STATE: i64 = 22
168const INC_G_AGE: i64 = 23
169const INC_G_PATH: i64 = 24
170const INC_G_SEEN: i64 = 25                    // per-row scratch stamp for df counting
171const INC_G_SCORE: i64 = 26
172const INC_G_MASK: i64 = 27
173const INC_G_TIER: i64 = 28                    // per-row scratch: contract terms hitting the organ's name parts
174const INC_G_NIDF: i64 = 29                    // per-row scratch: the idf of the terms hitting the organ's name parts
175const INC_G_N_SLOTS: i64 = 30
176// index states
177const INC_S_FRESH: i64 = 0
178const INC_S_STALE: i64 = 1
179const INC_S_ABSENT: i64 = 2
180const INC_S_MALFORMED: i64 = 3
181// result g-box slots
182const INC_R_N: i64 = 0
183const INC_R_ROW: i64 = 1
184const INC_R_SCORE: i64 = 2
185const INC_R_MASK: i64 = 3
186const INC_R_NTERMS: i64 = 4
187const INC_R_TERMS: i64 = 5
188const INC_R_TOFF: i64 = 6
189const INC_R_DROPPED: i64 = 7
190const INC_R_DROPMASK: i64 = 8
191const INC_R_OVER: i64 = 9
192const INC_R_MATCHED: i64 = 10
193const INC_R_TIER: i64 = 11
194const INC_R_NUMERIC: i64 = 12                 // all-digit terms dropped
195const INC_R_TIDF: i64 = 13                    // per-term idf weight (0 when dropped or unmatched)
196const INC_R_N_SLOTS: i64 = 14
197// build envelope slots
198const INC_E_FILES: i64 = 0
199const INC_E_TRUNC: i64 = 1
200const INC_E_ASSETS: i64 = 2
201const INC_E_COMPLETE: i64 = 3
202const INC_E_GEN: i64 = 4
203const INC_E_BYTES: i64 = 5
204const INC_E_N: i64 = 6
205// build context slots (one box, allocated once per build)
206const INC_B_CONF: i64 = 0
207const INC_B_ENV: i64 = 1
208const INC_B_REJ: i64 = 2
209const INC_B_NREJ: i64 = 3
210const INC_B_SET: i64 = 4
211const INC_B_ROOT: i64 = 5
212const INC_B_NAME: i64 = 6
213const INC_B_WORD: i64 = 7
214const INC_B_POS: i64 = 8
215const INC_B_CAND: i64 = 9
216const INC_B_HEAD: i64 = 10
217const INC_B_N: i64 = 11
218// render scratch slots
219const INC_V_ASTART: i64 = 0
220const INC_V_NA: i64 = 1
221const INC_V_N: i64 = 2
222const INC_NONE: i64 = 0 - 1
223const INC_CLOCK_WORDS: i64 = 2
224
225static inc_numbuf: i64
226
227// ---- tiny string helpers (bounded where they write) ----
228func inc_slen(s: *u8) -> i64 {
  var n: i64 = 0
  while s[n] != (0 as u8) { n = n + 1 }
  return n
232}
233func inc_cat(d: *u8, o: i64, s: *u8) -> i64 {
  var i: i64 = 0
  var oo: i64 = o
  while s[i] != (0 as u8) { d[oo] = s[i]; oo = oo + 1; i = i + 1 }
  d[oo] = 0 as u8
  return oo
239}
240// bounded cat: never writes past cap-1; the caller announces a cut
241func inc_catb(d: *u8, o: i64, cap: i64, s: *u8) -> i64 {
  var i: i64 = 0
  var oo: i64 = o
  while s[i] != (0 as u8) { if oo < cap - 1 { d[oo] = s[i]; oo = oo + 1 } i = i + 1 }
  d[oo] = 0 as u8
  return oo
247}
248func inc_catn(d: *u8, o: i64, cap: i64, v: i64) -> i64 {
  if inc_numbuf == 0 { inc_numbuf = sys_mmap(INC_NUM_CAP) as i64 }
  let t: *u8 = inc_numbuf as *u8
  var m: i64 = v
  var k: i64 = 0
  var neg: i64 = 0
  if m < 0 { neg = 1; m = 0 - m }
  if m == 0 { t[k] = INC_D0 as u8; k = k + 1 }
  while m > 0 { t[k] = (INC_D0 + m - (m / 10) * 10) as u8; m = m / 10; k = k + 1 }
  var oo: i64 = o
  if neg == 1 { if oo < cap - 1 { d[oo] = INC_MINUS as u8; oo = oo + 1 } }
  while k > 0 { k = k - 1; if oo < cap - 1 { d[oo] = t[k]; oo = oo + 1 } }
  d[oo] = 0 as u8
  return oo
262}
263func inc_streq(a: *u8, b: *u8) -> i64 {
  var i: i64 = 0
  while a[i] != (0 as u8) { if a[i] != b[i] { return 0 } i = i + 1 }
  if b[i] != (0 as u8) { return 0 }
  return 1
268}
269func inc_starts(s: *u8, pre: *u8) -> i64 {
  var i: i64 = 0
  while pre[i] != (0 as u8) { if s[i] != pre[i] { return 0 } i = i + 1 }
  return 1
273}
274// the index of the first NL at or after p, or n
275func inc_lend(buf: *u8, n: i64, p: i64) -> i64 {
  var e: i64 = p
  var go: i64 = 1
  while go == 1 { if e >= n { go = 0 } else { if buf[e] == (INC_NL as u8) { go = 0 } else { e = e + 1 } } }
  return e
280}
281// the index of the first space or NUL at or after p, or n
282func inc_wend(buf: *u8, n: i64, p: i64) -> i64 {
  var e: i64 = p
  var go: i64 = 1
  while go == 1 { if e >= n { go = 0 } else { if buf[e] == (INC_SPACE as u8) { go = 0 } else { if buf[e] == (0 as u8) { go = 0 } else { e = e + 1 } } } }
  return e
287}
288// does s[0..n) contain needle (plain substring)
289func inc_contains(s: *u8, n: i64, needle: *u8) -> i64 {
  let m: i64 = inc_slen(needle)
  if m == 0 { return 0 }
  var i: i64 = 0
  while i + m <= n {
      var j: i64 = 0
      var ok: i64 = 1
      while j < m { if s[i + j] != needle[j] { ok = 0; j = m } else { j = j + 1 } }
      if ok == 1 { return 1 }
      i = i + 1
  }
  return 0
301}
302func inc_is_alnum(b: i64) -> i64 {
  if b >= INC_A { if b <= INC_Z { return 1 } }
  if b >= INC_UA { if b <= INC_UZ { return 1 } }
  if b >= INC_D0 { if b <= INC_D9 { return 1 } }
  return 0
307}
308func inc_is_digit(b: i64) -> i64 {
  if b < INC_D0 { return 0 }
  if b > INC_D9 { return 0 }
  return 1
312}
313func inc_lower(b: i64) -> i64 {
  if b >= INC_UA { if b <= INC_UZ { return b + INC_CASE_DELTA } }
  return b
316}
317// decimal digits at s[off..] -> value; stops at the first non-digit
318func inc_atoi(s: *u8, off: i64) -> i64 {
  var v: i64 = 0
  var i: i64 = off
  var go: i64 = 1
  while go == 1 {
      let b: i64 = s[i] as i64
      if inc_is_digit(b) == 0 { go = 0 } else { v = v * 10 + (b - INC_D0); i = i + 1 }
  }
  return v
327}
328// the value after "key=" anywhere in the NUL-terminated line s; INC_NONE when the key is absent
329func inc_kv_int(s: *u8, key: *u8) -> i64 {
  let n: i64 = inc_slen(s)
  let m: i64 = inc_slen(key)
  var i: i64 = 0
  while i + m + 1 <= n {
      var j: i64 = 0
      var ok: i64 = 1
      while j < m { if s[i + j] != key[j] { ok = 0; j = m } else { j = j + 1 } }
      if ok == 1 { if s[i + m] == (INC_EQ as u8) { return inc_atoi(s, i + m + 1) } }
      i = i + 1
  }
  return INC_NONE
341}
342func inc_now() -> i64 {
  let ts: *i64 = sys_mmap(INC_CLOCK_WORDS * INC_I64) as *i64
  ts[0] = 0
  sys_clock_gettime_real(ts)
  return ts[0]
347}
348func inc_ends_nx(nm: *u8, l: i64) -> i64 {
  if l <= 3 { return 0 }
  if nm[l - 3] != (INC_DOT as u8) { return 0 }
  if nm[l - 2] != (INC_CH_N as u8) { return 0 }
  if nm[l - 1] != (INC_CH_X as u8) { return 0 }
  return 1
354}
355// the organ name of a source path: the bytes after the last / with a trailing .nx removed
356func inc_organ_name(path: *u8, out: *u8) -> i64 {
  let n: i64 = inc_slen(path)
  var s: i64 = 0
  var i: i64 = 0
  while i < n { if path[i] == (INC_SLASH as u8) { s = i + 1 } i = i + 1 }
  var e: i64 = n
  if inc_ends_nx(path, n) == 1 { e = n - 3 }
  var o: i64 = 0
  while s < e { if o < INC_NAME_CAP - 1 { out[o] = path[s]; o = o + 1 } s = s + 1 }
  out[o] = 0 as u8
  return o
367}
368// is name one of the space-separated tokens of buf[from..o)
369func inc_listed(buf: *u8, from: i64, o: i64, name: *u8) -> i64 {
  var s: i64 = from
  let nl: i64 = inc_slen(name)
  while s < o {
      let e: i64 = inc_wend(buf, o, s)
      if e - s == nl {
          var j: i64 = 0
          var eq: i64 = 1
          while j < nl { if buf[s + j] != name[j] { eq = 0; j = nl } else { j = j + 1 } }
          if eq == 1 { return 1 }
      }
      s = e + 1
  }
  return 0
383}
384// where am I: the serving root (buildroot/runtime opens) or buildroot itself (runtime opens)
385func inc_cwd_is_nishihost() -> i64 {
  let fd: i64 = sys_openat_rd(INC_ROOT_RT_A)
  if fd < 0 { return 0 }
  sys_close(fd)
  return 1
390}
391
392// ---- conf ----
393func inc_conf_take(c: *i64, ln: *u8, key: *u8, slot: i64) -> i64 {
  let v: i64 = inc_kv_int(ln, key)
  if v != INC_NONE { c[slot] = v }
  return 0
397}
398// reads knowledge/incumbent.conf (then ../knowledge/), key=value lines; every slot falls back to its default
399func inc_conf_load() -> *i64 {
  let c: *i64 = sys_mmap(INC_C_N * INC_I64) as *i64
  c[INC_C_HEAD_BYTES] = INC_D_HEAD_BYTES
  c[INC_C_MORPH_LONG] = INC_D_MORPH_LONG
  c[INC_C_MORPH_SHORT] = INC_D_MORPH_SHORT
  c[INC_C_MIN_TOK] = INC_D_MIN_TOK
  c[INC_C_TOPN] = INC_D_TOPN
  c[INC_C_DF_MAX_PERMIL] = INC_D_DF_MAX_PERMIL
  c[INC_C_IDF_SCALE] = INC_D_IDF_SCALE
  c[INC_C_IDF_BASE] = INC_D_IDF_BASE
  c[INC_C_REJ_PER_ORG] = INC_D_REJ_PER_ORG
  c[INC_C_REJ_LINE_CAP] = INC_D_REJ_LINE_CAP
  c[INC_C_INDEX_MAX_AGE_S] = INC_D_INDEX_MAX_AGE_S
  c[INC_C_MAX_TERMS] = INC_D_MAX_TERMS
  c[INC_C_REJ_ORGS] = INC_D_REJ_ORGS
  c[INC_C_SRC] = 0
  let lenp: *i64 = sys_mmap(INC_I64) as *i64
  lenp[0] = 0
  var buf: *u8 = sys_read_file(INC_CONF_A, lenp)
  if lenp[0] <= 0 { buf = sys_read_file(INC_CONF_B, lenp) }
  if lenp[0] <= 0 { return c }
  c[INC_C_SRC] = 1
  let n: i64 = lenp[0]
  var p: i64 = 0
  while p < n {
      let e: i64 = inc_lend(buf, n, p)
      buf[e] = 0 as u8
      let ln: *u8 = (buf as i64 + p) as *u8
      if ln[0] != (INC_HASHCH as u8) {
          inc_conf_take(c, ln, "head_bytes" as *u8, INC_C_HEAD_BYTES)
          inc_conf_take(c, ln, "morph_long" as *u8, INC_C_MORPH_LONG)
          inc_conf_take(c, ln, "morph_short" as *u8, INC_C_MORPH_SHORT)
          inc_conf_take(c, ln, "min_tok" as *u8, INC_C_MIN_TOK)
          inc_conf_take(c, ln, "topn" as *u8, INC_C_TOPN)
          inc_conf_take(c, ln, "df_max_permil" as *u8, INC_C_DF_MAX_PERMIL)
          inc_conf_take(c, ln, "idf_scale" as *u8, INC_C_IDF_SCALE)
          inc_conf_take(c, ln, "idf_base" as *u8, INC_C_IDF_BASE)
          inc_conf_take(c, ln, "rej_per_org" as *u8, INC_C_REJ_PER_ORG)
          inc_conf_take(c, ln, "rej_line_cap" as *u8, INC_C_REJ_LINE_CAP)
          inc_conf_take(c, ln, "index_max_age_s" as *u8, INC_C_INDEX_MAX_AGE_S)
          inc_conf_take(c, ln, "max_terms" as *u8, INC_C_MAX_TERMS)
          inc_conf_take(c, ln, "rej_orgs" as *u8, INC_C_REJ_ORGS)
      }
      p = e + 1
  }
  if c[INC_C_MORPH_LONG] > INC_KEY_BYTES { c[INC_C_MORPH_LONG] = INC_KEY_BYTES }
  if c[INC_C_MORPH_SHORT] > c[INC_C_MORPH_LONG] { c[INC_C_MORPH_SHORT] = c[INC_C_MORPH_LONG] }
  if c[INC_C_MAX_TERMS] > INC_D_MAX_TERMS { c[INC_C_MAX_TERMS] = INC_D_MAX_TERMS }
  return c
448}
449// the rejection phrases: knowledge/incumbent_reject.conf (then ../knowledge/), one per line, # comments; a
450// NUL-separated buffer with count[0] phrases (0 when the conf is absent: then no line can be a rejection, announced)
451func inc_reject_load(count: *i64) -> *u8 {
  let lenp: *i64 = sys_mmap(INC_I64) as *i64
  lenp[0] = 0
  var buf: *u8 = sys_read_file(INC_REJ_A, lenp)
  if lenp[0] <= 0 { buf = sys_read_file(INC_REJ_B, lenp) }
  count[0] = 0
  if lenp[0] <= 0 { return sys_mmap(INC_I64) }
  let n: i64 = lenp[0]
  let out: *u8 = sys_mmap(n + 2)
  var o: i64 = 0
  var p: i64 = 0
  while p < n {
      let e: i64 = inc_lend(buf, n, p)
      if e > p { if buf[p] != (INC_HASHCH as u8) {
          var i: i64 = p
          while i < e { if buf[i] != (INC_CR as u8) { out[o] = buf[i]; o = o + 1 } i = i + 1 }
          out[o] = 0 as u8
          o = o + 1
          count[0] = count[0] + 1
      } }
      p = e + 1
  }
  out[o] = 0 as u8
  return out
475}
476func inc_reject_nth(rej: *u8, k: i64) -> *u8 {
  var p: i64 = 0
  var i: i64 = 0
  while i < k { while rej[p] != (0 as u8) { p = p + 1 } p = p + 1; i = i + 1 }
  return (rej as i64 + p) as *u8
481}
482
483// ---- the word bag ----
484// the next alnum run in s[pos..n): lowercased into out (kept to INC_WORD_KEEP, the whole run consumed); returns the
485// run's full length, 0 when none is left; pos advances past the run
486func inc_next_word(s: *u8, n: i64, pos: *i64, out: *u8) -> i64 {
  var p: i64 = pos[0]
  var found: i64 = 0
  var go: i64 = 1
  while go == 1 { if p >= n { go = 0 } else { if inc_is_alnum(s[p] as i64) == 1 { found = 1; go = 0 } else { p = p + 1 } } }
  if found == 0 { pos[0] = n; out[0] = 0 as u8; return 0 }
  var l: i64 = 0
  go = 1
  while go == 1 {
      if p >= n { go = 0 } else {
          if inc_is_alnum(s[p] as i64) == 1 { if l < INC_WORD_KEEP { out[l] = inc_lower(s[p] as i64) as u8 } l = l + 1; p = p + 1 }
          else { go = 0 }
      }
  }
  pos[0] = p
  var kept: i64 = l
  if kept > INC_WORD_KEEP { kept = INC_WORD_KEEP }
  out[kept] = 0 as u8
  return l
505}
506// pack the first take bytes of a word (fewer when shorter) into an i64 key; never 0 for a non-empty word
507func inc_key(w: *u8, take: i64) -> i64 {
  var k: i64 = 0
  var i: i64 = 0
  var go: i64 = 1
  while go == 1 { if i >= take { go = 0 } else { if w[i] == (0 as u8) { go = 0 } else { k = k | ((w[i] as i64) << (i * INC_BYTE_BITS)); i = i + 1 } } }
  return k
513}
514func inc_hash(k: i64, cap: i64) -> i64 {
  var h: i64 = k * INC_HASH_MUL
  h = h ^ (h >> INC_HASH_SHIFT)
  return h & (cap - 1)
518}
519
520// ---- the index build ----
521// list the .nx entries of dir into names (INC_NAME_CAP bytes each); want == 0 counts only; INC_NONE = unreadable dir
522func inc_list_dir(dir: *u8, names: *u8, want: i64, srconly: i64) -> i64 {
  let fd: i64 = sys_openat_rd(dir)
  if fd < 0 { return INC_NONE }
  let dbuf: *u8 = sys_mmap(INC_DIRBUF)
  var count: i64 = 0
  var go: i64 = 1
  while go == 1 {
      let nr: i64 = sys_getdents64(fd, dbuf, INC_DIRBUF)
      if nr <= 0 { go = 0 } else {
          var off: i64 = 0
          while off < nr {
              let rec: *u8 = (dbuf as i64 + off) as *u8
              let nm: *u8 = dirent_name(rec)
              let l: i64 = inc_slen(nm)
              var ok: i64 = 0
              if srconly == 1 { ok = inc_ends_nx(nm, l) }
              else { if nm[0] != (INC_DOT as u8) { if dirent_type(rec) == DT_REG { ok = 1 } } }
              if ok == 1 {
                  if want > 0 { if count < want {
                      let dst: *u8 = (names as i64 + count * INC_NAME_CAP) as *u8
                      var i: i64 = 0
                      while i < l { if i < INC_NAME_CAP - 1 { dst[i] = nm[i] } i = i + 1 }
                      if l < INC_NAME_CAP { dst[l] = 0 as u8 } else { dst[INC_NAME_CAP - 1] = 0 as u8 }
                  } }
                  count = count + 1
              }
              off = off + dirent_reclen(rec)
          }
      }
  }
  sys_close(fd)
  return count
554}
555// read up to cap bytes of path; returns bytes read (INC_NONE when unreadable)
556func inc_read_head(path: *u8, buf: *u8, cap: i64) -> i64 {
  let fd: i64 = sys_openat_rd(path)
  if fd < 0 { return INC_NONE }
  var got: i64 = 0
  var go: i64 = 1
  while go == 1 {
      if got >= cap { go = 0 } else {
          let r: i64 = sys_read(fd, (buf as i64 + got) as *u8, cap - got)
          if r <= 0 { go = 0 } else { got = got + r }
      }
  }
  sys_close(fd)
  return got
569}
570// add a word (lowercase) to the per-file set keyed on its first 8 bytes; returns 1 when new
571func inc_set_add(set: *i64, cap: i64, w: *u8) -> i64 {
  let k: i64 = inc_key(w, INC_KEY_BYTES)
  if k == 0 { return 0 }
  var h: i64 = inc_hash(k, cap)
  var probes: i64 = 0
  while probes < cap {
      if set[h] == 0 { set[h] = k; return 1 }
      if set[h] == k { return 0 }
      h = (h + 1) & (cap - 1)
      probes = probes + 1
  }
  return 0
583}
584// emit every word of s[0..n) (>= min_tok, new to the set) into out at o, space-separated after the first
585func inc_bag_emit(b: *i64, s: *u8, n: i64, out: *u8, o: i64, firstp: *i64) -> i64 {
  let c: *i64 = b[INC_B_CONF] as *i64
  let set: *i64 = b[INC_B_SET] as *i64
  let w: *u8 = b[INC_B_WORD] as *u8
  let pos: *i64 = b[INC_B_POS] as *i64
  var oo: i64 = o
  pos[0] = 0
  var l: i64 = inc_next_word(s, n, pos, w)
  while l > 0 {
      if l >= c[INC_C_MIN_TOK] { if inc_set_add(set, INC_SETCAP, w) == 1 {
          if firstp[0] == 0 { oo = inc_cat(out, oo, " " as *u8) }
          oo = inc_cat(out, oo, w)
          firstp[0] = 0
      } }
      l = inc_next_word(s, n, pos, w)
  }
  return oo
602}
603// the end of the leading comment block of hb[0..got): // lines with blank lines allowed; trunc[0]=1 when the block
604// runs to the end of a full window
605func inc_head_end(hb: *u8, got: i64, cap: i64, trunc: *i64) -> i64 {
  var hend: i64 = 0
  var p: i64 = 0
  var go: i64 = 1
  trunc[0] = 0
  while go == 1 {
      if p >= got { go = 0; if got >= cap { trunc[0] = 1 } }
      else {
          let eol: i64 = inc_lend(hb, got, p)
          var blank: i64 = 1
          var q: i64 = p
          while q < eol { let bq: i64 = hb[q] as i64; if bq != INC_SPACE { if bq != INC_CR { if bq != INC_TAB { blank = 0 } } } q = q + 1 }
          var iscomment: i64 = 0
          if eol - p >= 2 { if hb[p] == (INC_SLASH as u8) { if hb[p + 1] == (INC_SLASH as u8) { iscomment = 1 } } }
          if iscomment == 1 { hend = eol; p = eol + 1 }
          else { if blank == 1 { p = eol + 1 } else { go = 0 } }
      }
  }
  return hend
624}
625// is b a byte that ends a knowledge/ path token
626func inc_path_stop(b: i64) -> i64 {
  if b == INC_SPACE { return 1 }
  if b == INC_RPAREN { return 1 }
  if b == INC_COMMA { return 1 }
  if b == INC_SEMI { return 1 }
  if b == INC_DQUOTE { return 1 }
  if b == INC_SQUOTE { return 1 }
  if b == INC_NL { return 1 }
  if b == INC_CR { return 1 }
  if b == INC_PIPE { return 1 }
  if b == INC_RBRACK { return 1 }
  if b == INC_GT { return 1 }
  return 0
639}
640// one organ source -> one index row appended at out[o..]; returns the new offset
641func inc_row_for(b: *i64, path: *u8, out: *u8, o: i64) -> i64 {
  let c: *i64 = b[INC_B_CONF] as *i64
  let env: *i64 = b[INC_B_ENV] as *i64
  let rej: *u8 = b[INC_B_REJ] as *u8
  let nrej: i64 = b[INC_B_NREJ]
  let set: *i64 = b[INC_B_SET] as *i64
  let hb: *u8 = b[INC_B_HEAD] as *u8
  let nm: *u8 = b[INC_B_NAME] as *u8
  let cand: *u8 = b[INC_B_CAND] as *u8
  let cap: i64 = c[INC_C_HEAD_BYTES]
  let got: i64 = inc_read_head(path, hb, cap)
  if got < 0 { return o }
  inc_organ_name(path, nm)
  var i: i64 = 0
  while i < INC_SETCAP { set[i] = 0; i = i + 1 }
  var oo: i64 = inc_cat(out, o, INC_ORG_TAG)
  oo = inc_cat(out, oo, nm)
  oo = inc_cat(out, oo, "|" as *u8)
  oo = inc_cat(out, oo, b[INC_B_ROOT] as *u8)
  oo = inc_cat(out, oo, "|" as *u8)
  let trunc: *i64 = sys_mmap(INC_I64) as *i64
  let hend: i64 = inc_head_end(hb, got, cap, trunc)
  if trunc[0] == 1 { env[INC_E_TRUNC] = env[INC_E_TRUNC] + 1 }
  // the bag: basename parts, header words, column-0 func names anywhere in the window
  let firstp: *i64 = sys_mmap(INC_I64) as *i64
  firstp[0] = 1
  oo = inc_bag_emit(b, nm, inc_slen(nm), out, oo, firstp)
  oo = inc_bag_emit(b, hb, hend, out, oo, firstp)
  var q: i64 = 0
  while q < got {
      var atline: i64 = 0
      if q == 0 { atline = 1 } else { if hb[q - 1] == (INC_NL as u8) { atline = 1 } }
      if atline == 1 { if q + INC_FUNC_LEN < got { if inc_starts((hb as i64 + q) as *u8, INC_FUNC) == 1 {
          let eol: i64 = inc_lend(hb, got, q)
          var e2: i64 = q + INC_FUNC_LEN
          var go: i64 = 1
          while go == 1 { if e2 >= eol { go = 0 } else { if hb[e2] == (INC_LPAREN as u8) { go = 0 } else { e2 = e2 + 1 } } }
          oo = inc_bag_emit(b, (hb as i64 + q + INC_FUNC_LEN) as *u8, e2 - q - INC_FUNC_LEN, out, oo, firstp)
      } } }
      q = q + 1
  }
  // assets: knowledge/ paths named in the header, unique within the row
  oo = inc_cat(out, oo, "|" as *u8)
  let astart: i64 = oo
  var afirst: i64 = 1
  var k: i64 = 0
  let kl: i64 = inc_slen(INC_KNOW)
  while k + kl <= hend {
      if inc_starts((hb as i64 + k) as *u8, INC_KNOW) == 1 {
          var e3: i64 = k
          var stop: i64 = 0
          while stop == 0 { if e3 >= hend { stop = 1 } else { if inc_path_stop(hb[e3] as i64) == 1 { stop = 1 } else { e3 = e3 + 1 } } }
          var e4: i64 = e3
          if e4 > k { if hb[e4 - 1] == (INC_DOT as u8) { e4 = e4 - 1 } else { if hb[e4 - 1] == (INC_COLON as u8) { e4 = e4 - 1 } } }
          var ci: i64 = 0
          while k + ci < e4 { if ci < INC_PATH_CAP - 1 { cand[ci] = hb[k + ci] } ci = ci + 1 }
          if ci >= INC_PATH_CAP { ci = INC_PATH_CAP - 1 }
          cand[ci] = 0 as u8
          if ci > kl { if inc_listed(out, astart, oo, cand) == 0 {
              if afirst == 0 { oo = inc_cat(out, oo, " " as *u8) }
              oo = inc_cat(out, oo, cand)
              afirst = 0
          } }
          k = e3
      } else { k = k + 1 }
  }
  // rejection lines: header lines carrying a phrase, up to rej_per_org, each cut at rej_line_cap; pipes and
  // semicolons become slashes so the row grammar holds
  oo = inc_cat(out, oo, "|" as *u8)
  var kept: i64 = 0
  var p: i64 = 0
  while p < hend {
      let e5: i64 = inc_lend(hb, hend, p)
      if kept < c[INC_C_REJ_PER_ORG] {
          var hit: i64 = 0
          var ri: i64 = 0
          while ri < nrej { if inc_contains((hb as i64 + p) as *u8, e5 - p, inc_reject_nth(rej, ri)) == 1 { hit = 1; ri = nrej } else { ri = ri + 1 } }
          if hit == 1 {
              if kept > 0 { oo = inc_cat(out, oo, INC_REJ_SEP) }
              var s3: i64 = p
              var lead: i64 = 1
              while lead == 1 { if s3 >= e5 { lead = 0 } else { let bl: i64 = hb[s3] as i64; if bl == INC_SLASH { s3 = s3 + 1 } else { if bl == INC_SPACE { s3 = s3 + 1 } else { lead = 0 } } } }
              var wrote: i64 = 0
              while s3 < e5 {
                  if wrote < c[INC_C_REJ_LINE_CAP] {
                      var b2: i64 = hb[s3] as i64
                      if b2 == INC_PIPE { b2 = INC_SLASH }
                      if b2 == INC_SEMI { b2 = INC_SLASH }
                      if b2 == INC_CR { b2 = INC_SPACE }
                      out[oo] = b2 as u8
                      oo = oo + 1
                      wrote = wrote + 1
                  }
                  s3 = s3 + 1
              }
              kept = kept + 1
          }
      }
      p = e5 + 1
  }
  out[oo] = INC_NL as u8
  oo = oo + 1
  out[oo] = 0 as u8
  env[INC_E_FILES] = env[INC_E_FILES] + 1
  return oo
746}
747// one asset entry -> asset|name|words
748func inc_asset_row(b: *i64, name: *u8, out: *u8, o: i64) -> i64 {
  let set: *i64 = b[INC_B_SET] as *i64
  var i: i64 = 0
  while i < INC_SETCAP { set[i] = 0; i = i + 1 }
  var oo: i64 = inc_cat(out, o, INC_ASSET_TAG)
  oo = inc_cat(out, oo, name)
  oo = inc_cat(out, oo, "|" as *u8)
  let firstp: *i64 = sys_mmap(INC_I64) as *i64
  firstp[0] = 1
  oo = inc_bag_emit(b, name, inc_slen(name), out, oo, firstp)
  out[oo] = INC_NL as u8
  oo = oo + 1
  out[oo] = 0 as u8
  return oo
762}
763// write the whole index atomically: <out_path>.tmp then rename; returns bytes written or INC_NONE
764func inc_publish(out_path: *u8, head: *u8, rows: *u8, rows_len: i64) -> i64 {
  let tmp: *u8 = sys_mmap(INC_PATH_CAP)
  var t: i64 = inc_cat(tmp, 0, out_path)
  t = inc_cat(tmp, t, INC_TMP_SUFFIX)
  let fd: i64 = sys_openat_wr(tmp, MODE_0644)
  if fd < 0 { return INC_NONE }
  let hl: i64 = inc_slen(head)
  let w1: i64 = sys_write(fd, head, hl)
  var w2: i64 = 0
  var off: i64 = 0
  var go: i64 = 1
  while go == 1 {
      if off >= rows_len { go = 0 } else {
          let r: i64 = sys_write(fd, (rows as i64 + off) as *u8, rows_len - off)
          if r <= 0 { go = 0 } else { off = off + r; w2 = w2 + r }
      }
  }
  sys_close(fd)
  if w1 != hl { return INC_NONE }
  if w2 != rows_len { return INC_NONE }
  if sys_renameat(tmp, out_path) != 0 { return INC_NONE }
  return hl + rows_len
786}
787func inc_fill_names(dir: *u8, cnt: i64, srconly: i64, env: *i64) -> *u8 {
  let names: *u8 = sys_mmap((cnt + 1) * INC_NAME_CAP)
  if cnt > 0 { let r: i64 = inc_list_dir(dir, names, cnt, srconly); if r != cnt { env[INC_E_COMPLETE] = 0 } }
  return names
791}
792// BUILD: the two source roots and the asset dir -> the index at out_path. Returns the envelope box.
793func inc_index_build(c: *i64, root_a: *u8, root_b: *u8, asset_dir: *u8, out_path: *u8) -> *i64 {
  let env: *i64 = sys_mmap(INC_E_N * INC_I64) as *i64
  var k: i64 = 0
  while k < INC_E_N { env[k] = 0; k = k + 1 }
  env[INC_E_COMPLETE] = 1
  env[INC_E_GEN] = inc_now()
  let scratch: *u8 = sys_mmap(INC_I64)
  var ca: i64 = inc_list_dir(root_a, scratch, 0, 1)
  var cb: i64 = inc_list_dir(root_b, scratch, 0, 1)
  var cs: i64 = inc_list_dir(asset_dir, scratch, 0, 0)
  if ca < 0 { ca = 0; env[INC_E_COMPLETE] = 0 }
  if cb < 0 { cb = 0; env[INC_E_COMPLETE] = 0 }
  if cs < 0 { cs = 0; env[INC_E_COMPLETE] = 0 }
  let names_a: *u8 = inc_fill_names(root_a, ca, 1, env)
  let names_b: *u8 = inc_fill_names(root_b, cb, 1, env)
  let names_s: *u8 = inc_fill_names(asset_dir, cs, 0, env)
  // the rows buffer, sized from the population (mmap is lazy: headroom costs address space, not memory)
  let per: i64 = c[INC_C_HEAD_BYTES] + INC_ROW_SLACK
  let rows: *u8 = sys_mmap((ca + cb + cs + 2) * per)
  let nrejp: *i64 = sys_mmap(INC_I64) as *i64
  let rej: *u8 = inc_reject_load(nrejp)
  let b: *i64 = sys_mmap(INC_B_N * INC_I64) as *i64
  b[INC_B_CONF] = c as i64
  b[INC_B_ENV] = env as i64
  b[INC_B_REJ] = rej as i64
  b[INC_B_NREJ] = nrejp[0]
  b[INC_B_SET] = sys_mmap(INC_SETCAP * INC_I64) as i64
  b[INC_B_NAME] = sys_mmap(INC_NAME_CAP) as i64
  b[INC_B_WORD] = sys_mmap(INC_WORD_KEEP + 1) as i64
  b[INC_B_POS] = sys_mmap(INC_I64) as i64
  b[INC_B_CAND] = sys_mmap(INC_PATH_CAP) as i64
  b[INC_B_HEAD] = sys_mmap(c[INC_C_HEAD_BYTES] + 1) as i64
  let path: *u8 = sys_mmap(INC_PATH_CAP)
  var o: i64 = 0
  var i: i64 = 0
  b[INC_B_ROOT] = root_a as i64
  while i < ca {
      var t: i64 = inc_cat(path, 0, root_a)
      t = inc_cat(path, t, "/" as *u8)
      t = inc_cat(path, t, (names_a as i64 + i * INC_NAME_CAP) as *u8)
      o = inc_row_for(b, path, rows, o)
      i = i + 1
  }
  b[INC_B_ROOT] = root_b as i64
  i = 0
  while i < cb {
      var t2: i64 = inc_cat(path, 0, root_b)
      t2 = inc_cat(path, t2, "/" as *u8)
      t2 = inc_cat(path, t2, (names_b as i64 + i * INC_NAME_CAP) as *u8)
      o = inc_row_for(b, path, rows, o)
      i = i + 1
  }
  i = 0
  while i < cs {
      o = inc_asset_row(b, (names_s as i64 + i * INC_NAME_CAP) as *u8, rows, o)
      env[INC_E_ASSETS] = env[INC_E_ASSETS] + 1
      i = i + 1
  }
  // the head, written last so its counts are the counts
  let head: *u8 = sys_mmap(INC_PATH_CAP)
  var h: i64 = inc_cat(head, 0, INC_HEAD_MARK)
  h = inc_catn(head, h, INC_PATH_CAP, env[INC_E_GEN])
  h = inc_cat(head, h, " files=" as *u8); h = inc_catn(head, h, INC_PATH_CAP, env[INC_E_FILES])
  h = inc_cat(head, h, " head_truncated=" as *u8); h = inc_catn(head, h, INC_PATH_CAP, env[INC_E_TRUNC])
  h = inc_cat(head, h, " assets=" as *u8); h = inc_catn(head, h, INC_PATH_CAP, env[INC_E_ASSETS])
  h = inc_cat(head, h, " corpus_complete=" as *u8); h = inc_catn(head, h, INC_PATH_CAP, env[INC_E_COMPLETE])
  h = inc_cat(head, h, " reject_phrases=" as *u8); h = inc_catn(head, h, INC_PATH_CAP, nrejp[0])
  h = inc_cat(head, h, "\n" as *u8)
  env[INC_E_BYTES] = inc_publish(out_path, head, rows, o)
  return env
863}
864
865// ---- the index load ----
866// split a NUL-terminated row into fields at |; fld[i] = start offsets; returns the field count
867func inc_split(ln: *u8, fld: *i64, maxf: i64) -> i64 {
  var f: i64 = 1
  var i: i64 = 0
  fld[0] = 0
  while ln[i] != (0 as u8) {
      if ln[i] == (INC_PIPE as u8) { ln[i] = 0 as u8; if f < maxf { fld[f] = i + 1; f = f + 1 } }
      i = i + 1
  }
  return f
876}
877func inc_hput(g: *i64, key: i64, word: i64, row: i64) -> i64 {
  let cap: i64 = g[INC_G_HCAP]
  let hkey: *i64 = g[INC_G_HKEY] as *i64
  let hhead: *i64 = g[INC_G_HHEAD] as *i64
  let pword: *i64 = g[INC_G_PWORD] as *i64
  let prow: *i64 = g[INC_G_PROW] as *i64
  let pnext: *i64 = g[INC_G_PNEXT] as *i64
  var h: i64 = inc_hash(key, cap)
  var probes: i64 = 0
  var slot: i64 = INC_NONE
  while probes < cap {
      if hkey[h] == 0 { hkey[h] = key; hhead[h] = INC_NONE; slot = h; probes = cap }
      else { if hkey[h] == key { slot = h; probes = cap } else { h = (h + 1) & (cap - 1); probes = probes + 1 } }
  }
  if slot == INC_NONE { return INC_NONE }
  let np: i64 = g[INC_G_NPOST]
  pword[np] = word
  prow[np] = row
  pnext[np] = hhead[slot]
  hhead[slot] = np
  g[INC_G_NPOST] = np + 1
  return slot
899}
900func inc_hfind(g: *i64, key: i64) -> i64 {
  let cap: i64 = g[INC_G_HCAP]
  let hkey: *i64 = g[INC_G_HKEY] as *i64
  var h: i64 = inc_hash(key, cap)
  var probes: i64 = 0
  while probes < cap {
      if hkey[h] == 0 { return INC_NONE }
      if hkey[h] == key { return h }
      h = (h + 1) & (cap - 1)
      probes = probes + 1
  }
  return INC_NONE
912}
913func inc_state_name(s: i64) -> *u8 {
  if s == INC_S_FRESH { return "FRESH" as *u8 }
  if s == INC_S_STALE { return "STALE" as *u8 }
  if s == INC_S_ABSENT { return "ABSENT" as *u8 }
  return "MALFORMED" as *u8
918}
919// LOAD the index at path (now = the clock, or a value a gate hands in). Always returns a box; read INC_G_STATE.
920func inc_load_path(c: *i64, path: *u8, now: i64) -> *i64 {
  let g: *i64 = sys_mmap(INC_G_N_SLOTS * INC_I64) as *i64
  var k: i64 = 0
  while k < INC_G_N_SLOTS { g[k] = 0; k = k + 1 }
  g[INC_G_PATH] = path as i64
  g[INC_G_STATE] = INC_S_ABSENT
  let lenp: *i64 = sys_mmap(INC_I64) as *i64
  lenp[0] = 0
  let buf: *u8 = sys_read_file(path, lenp)
  if lenp[0] <= 0 { return g }
  let n: i64 = lenp[0]
  g[INC_G_BUF] = buf as i64
  g[INC_G_N] = n
  if inc_starts(buf, INC_HEAD_MARK) == 0 { g[INC_G_STATE] = INC_S_MALFORMED; return g }
  // pass 1: count rows and an upper bound on words (spaces in org rows)
  var rows: i64 = 0
  var assets: i64 = 0
  var words: i64 = 0
  var p: i64 = 0
  while p < n {
      let e: i64 = inc_lend(buf, n, p)
      if inc_starts((buf as i64 + p) as *u8, INC_ORG_TAG) == 1 {
          rows = rows + 1
          var q: i64 = p
          while q < e { if buf[q] == (INC_SPACE as u8) { words = words + 1 } q = q + 1 }
          words = words + 1
      }
      if inc_starts((buf as i64 + p) as *u8, INC_ASSET_TAG) == 1 { assets = assets + 1 }
      p = e + 1
  }
  g[INC_G_R_NAME] = sys_mmap((rows + 1) * INC_I64) as i64
  g[INC_G_R_ROOT] = sys_mmap((rows + 1) * INC_I64) as i64
  g[INC_G_R_WORDS] = sys_mmap((rows + 1) * INC_I64) as i64
  g[INC_G_R_ASSETS] = sys_mmap((rows + 1) * INC_I64) as i64
  g[INC_G_R_REJ] = sys_mmap((rows + 1) * INC_I64) as i64
  g[INC_G_A_NAME] = sys_mmap((assets + 1) * INC_I64) as i64
  g[INC_G_A_WORDS] = sys_mmap((assets + 1) * INC_I64) as i64
  g[INC_G_SEEN] = sys_mmap((rows + 1) * INC_I64) as i64
  g[INC_G_SCORE] = sys_mmap((rows + 1) * INC_I64) as i64
  g[INC_G_MASK] = sys_mmap((rows + 1) * INC_I64) as i64
  g[INC_G_TIER] = sys_mmap((rows + 1) * INC_I64) as i64
  g[INC_G_NIDF] = sys_mmap((rows + 1) * INC_I64) as i64
  var cap: i64 = INC_HASH_MIN
  while cap < words * 2 { cap = cap * 2 }
  g[INC_G_HCAP] = cap
  g[INC_G_HKEY] = sys_mmap(cap * INC_I64) as i64
  g[INC_G_HHEAD] = sys_mmap(cap * INC_I64) as i64
  g[INC_G_PWORD] = sys_mmap((words + 1) * INC_I64) as i64
  g[INC_G_PROW] = sys_mmap((words + 1) * INC_I64) as i64
  g[INC_G_PNEXT] = sys_mmap((words + 1) * INC_I64) as i64
  g[INC_G_NPOST] = 0
  let rname: *i64 = g[INC_G_R_NAME] as *i64
  let rroot: *i64 = g[INC_G_R_ROOT] as *i64
  let rwords: *i64 = g[INC_G_R_WORDS] as *i64
  let rassets: *i64 = g[INC_G_R_ASSETS] as *i64
  let rrej: *i64 = g[INC_G_R_REJ] as *i64
  let aname: *i64 = g[INC_G_A_NAME] as *i64
  let awords: *i64 = g[INC_G_A_WORDS] as *i64
  let fld: *i64 = sys_mmap(INC_ORG_FIELDS * INC_I64) as *i64
  // pass 2: the head, then the rows (NUL-terminated in place) and their postings
  var ri: i64 = 0
  var ai: i64 = 0
  var first: i64 = 1
  p = 0
  while p < n {
      let e2: i64 = inc_lend(buf, n, p)
      buf[e2] = 0 as u8
      let ln: *u8 = (buf as i64 + p) as *u8
      if first == 1 {
          first = 0
          g[INC_G_GEN] = inc_kv_int(ln, "generated_at" as *u8)
          g[INC_G_FILES] = inc_kv_int(ln, "files" as *u8)
          g[INC_G_TRUNC] = inc_kv_int(ln, "head_truncated" as *u8)
          g[INC_G_COMPLETE] = inc_kv_int(ln, "corpus_complete" as *u8)
      } else {
          if inc_starts(ln, INC_ORG_TAG) == 1 {
              let nf: i64 = inc_split(ln, fld, INC_ORG_FIELDS)
              if nf >= INC_ORG_FIELDS { if ri < rows {
                  rname[ri] = ln as i64 + fld[1]
                  rroot[ri] = ln as i64 + fld[2]
                  rwords[ri] = ln as i64 + fld[3]
                  rassets[ri] = ln as i64 + fld[4]
                  rrej[ri] = ln as i64 + fld[5]
                  // postings: one per bag word, keyed on its first morph_short bytes; the words field becomes NUL-separated
                  let ws: *u8 = rwords[ri] as *u8
                  let wl: i64 = inc_slen(ws)
                  var s: i64 = 0
                  while s < wl {
                      let e3: i64 = inc_wend(ws, wl, s)
                      if e3 > s {
                          ws[e3] = 0 as u8
                          let kk: i64 = inc_key((ws as i64 + s) as *u8, c[INC_C_MORPH_SHORT])
                          if kk != 0 { inc_hput(g, kk, ws as i64 + s, ri) }
                      }
                      s = e3 + 1
                  }
                  ri = ri + 1
              } }
          }
          if inc_starts(ln, INC_ASSET_TAG) == 1 {
              let nf2: i64 = inc_split(ln, fld, INC_ASSET_FIELDS)
              if nf2 >= INC_ASSET_FIELDS { if ai < assets {
                  aname[ai] = ln as i64 + fld[1]
                  awords[ai] = ln as i64 + fld[2]
                  ai = ai + 1
              } }
          }
      }
      p = e2 + 1
  }
  g[INC_G_ROWS] = ri
  g[INC_G_ASSETS] = ai
  if g[INC_G_GEN] <= 0 { g[INC_G_STATE] = INC_S_MALFORMED; return g }
  g[INC_G_AGE] = now - g[INC_G_GEN]
  if g[INC_G_AGE] < 0 { g[INC_G_STATE] = INC_S_STALE; return g }
  if g[INC_G_AGE] > c[INC_C_INDEX_MAX_AGE_S] { g[INC_G_STATE] = INC_S_STALE; return g }
  g[INC_G_STATE] = INC_S_FRESH
  return g
1038}
1039// the index at its standing path (knowledge/status, then ../knowledge/status), judged against the clock
1040func inc_load(c: *i64) -> *i64 {
  let now: i64 = inc_now()
  let g: *i64 = inc_load_path(c, INC_INDEX_A, now)
  if g[INC_G_STATE] == INC_S_ABSENT { return inc_load_path(c, INC_INDEX_B, now) }
  return g
1045}
1046
1047// ---- the match ----
1048// does the query term (full length tlen) match the bag word: the first morph_long bytes when the term is that long,
1049// else the term's own first morph_short bytes (or all of it when shorter)
1050func inc_term_hits(c: *i64, term: *u8, tlen: i64, word: *u8) -> i64 {
  // a term shorter than morph_long is matched WHOLE (measured 2026-09-14: cutting a 5-letter term to the 4-byte key
  // made dense match density and wired match wire, and both filled the rejection axis); the morph_short key only
  // narrows the posting chain the walk reads
  var take: i64 = c[INC_C_MORPH_LONG]
  if tlen < c[INC_C_MORPH_LONG] { take = tlen }
  var i: i64 = 0
  while i < take { if word[i] != term[i] { return 0 } i = i + 1 }
  return 1
1059}
1060// the name hits of an organ: out2[0] = how many matched terms hit its name parts, out2[1] = the sum of their idf
1061func inc_name_hits(c: *i64, r: *i64, name: *u8, w: *u8, pos: *i64, out2: *i64) -> i64 {
  let terms: *u8 = r[INC_R_TERMS] as *u8
  let toff: *i64 = r[INC_R_TOFF] as *i64
  let tidf: *i64 = r[INC_R_TIDF] as *i64
  let nt: i64 = r[INC_R_NTERMS]
  let nl: i64 = inc_slen(name)
  out2[0] = 0
  out2[1] = 0
  var t: i64 = 0
  while t < nt {
      if tidf[t] > 0 {
          let term: *u8 = (terms as i64 + toff[t]) as *u8
          var tl: i64 = inc_slen(term)
          if tl > INC_KEY_BYTES { tl = INC_KEY_BYTES }
          pos[0] = 0
          var hit: i64 = 0
          var l: i64 = inc_next_word(name, nl, pos, w)
          while l > 0 { if hit == 0 { if inc_term_hits(c, term, tl, w) == 1 { hit = 1 } } l = inc_next_word(name, nl, pos, w) }
          if hit == 1 { out2[0] = out2[0] + 1; out2[1] = out2[1] + tidf[t] }
      }
      t = t + 1
  }
  return out2[0]
1084}
1085// MATCH one contract (title, symbol, note) against the loaded index; excl is the rung's own organ name (or "")
1086func inc_match(g: *i64, c: *i64, title: *u8, sym: *u8, note: *u8, excl: *u8) -> *i64 {
  let r: *i64 = sys_mmap(INC_R_N_SLOTS * INC_I64) as *i64
  var k: i64 = 0
  while k < INC_R_N_SLOTS { r[k] = 0; k = k + 1 }
  let rows: i64 = g[INC_G_ROWS]
  let maxt: i64 = c[INC_C_MAX_TERMS]
  // terms: unique lowercase words of title + symbol + note, in that order, deduplicated by match prefix; all-digit
  // runs dropped and counted
  let tl: i64 = inc_slen(title) + inc_slen(sym) + inc_slen(note) + 3
  let text: *u8 = sys_mmap(tl + 1)
  var o: i64 = inc_cat(text, 0, title)
  o = inc_cat(text, o, " " as *u8)
  o = inc_cat(text, o, sym)
  o = inc_cat(text, o, " " as *u8)
  o = inc_cat(text, o, note)
  let terms: *u8 = sys_mmap((maxt + 1) * (INC_WORD_KEEP + 1))
  let toff: *i64 = sys_mmap((maxt + 1) * INC_I64) as *i64
  let tlen: *i64 = sys_mmap((maxt + 1) * INC_I64) as *i64
  let tidf: *i64 = sys_mmap((maxt + 1) * INC_I64) as *i64
  let w: *u8 = sys_mmap(INC_WORD_KEEP + 1)
  let pos: *i64 = sys_mmap(INC_I64) as *i64
  pos[0] = 0
  var nt: i64 = 0
  var to: i64 = 0
  var l: i64 = inc_next_word(text, o, pos, w)
  while l > 0 {
      if l >= c[INC_C_MIN_TOK] {
          var alldig: i64 = 1
          var di: i64 = 0
          while w[di] != (0 as u8) { if inc_is_digit(w[di] as i64) == 0 { alldig = 0 } di = di + 1 }
          var dup: i64 = alldig
          if alldig == 1 { r[INC_R_NUMERIC] = r[INC_R_NUMERIC] + 1 }
          var t: i64 = 0
          while t < nt {
              let tt: *u8 = (terms as i64 + toff[t]) as *u8
              if inc_term_hits(c, tt, tlen[t], w) == 1 { dup = 1 } else { if inc_term_hits(c, w, l, tt) == 1 { dup = 1 } }
              if dup == 1 { t = nt } else { t = t + 1 }
          }
          if dup == 0 {
              if nt < maxt {
                  toff[nt] = to
                  tlen[nt] = l
                  if tlen[nt] > INC_KEY_BYTES { tlen[nt] = INC_KEY_BYTES }
                  to = inc_cat(terms, to, w) + 1
                  nt = nt + 1
              } else { r[INC_R_OVER] = r[INC_R_OVER] + 1 }
          }
      }
      l = inc_next_word(text, o, pos, w)
  }
  r[INC_R_NTERMS] = nt
  r[INC_R_TERMS] = terms as i64
  r[INC_R_TOFF] = toff as i64
  r[INC_R_TIDF] = tidf as i64
  let seen: *i64 = g[INC_G_SEEN] as *i64
  let score: *i64 = g[INC_G_SCORE] as *i64
  let mask: *i64 = g[INC_G_MASK] as *i64
  let tier: *i64 = g[INC_G_TIER] as *i64
  let nidf: *i64 = g[INC_G_NIDF] as *i64
  var i: i64 = 0
  while i < rows { seen[i] = 0; score[i] = 0; mask[i] = 0; tier[i] = 0; nidf[i] = 0; i = i + 1 }
  let hhead: *i64 = g[INC_G_HHEAD] as *i64
  let pword: *i64 = g[INC_G_PWORD] as *i64
  let prow: *i64 = g[INC_G_PROW] as *i64
  let pnext: *i64 = g[INC_G_PNEXT] as *i64
  let rname: *i64 = g[INC_G_R_NAME] as *i64
  let dfmax: i64 = rows * c[INC_C_DF_MAX_PERMIL] / INC_PERMIL
  var t2: i64 = 0
  while t2 < nt {
      let term: *u8 = (terms as i64 + toff[t2]) as *u8
      let key: i64 = inc_key(term, c[INC_C_MORPH_SHORT])
      let h: i64 = inc_hfind(g, key)
      tidf[t2] = 0
      if h != INC_NONE {
          // walk 1: df = distinct rows whose word agrees on the term's full match length
          var df: i64 = 0
          var pi: i64 = hhead[h]
          let stamp: i64 = t2 + 1
          while pi != INC_NONE {
              if inc_term_hits(c, term, tlen[t2], pword[pi] as *u8) == 1 { let rw: i64 = prow[pi]; if seen[rw] != stamp { seen[rw] = stamp; df = df + 1 } }
              pi = pnext[pi]
          }
          if df > dfmax { r[INC_R_DROPPED] = r[INC_R_DROPPED] + 1; r[INC_R_DROPMASK] = r[INC_R_DROPMASK] | (1 << t2) }
          else { if df > 0 {
              let wgt: i64 = c[INC_C_IDF_SCALE] / (c[INC_C_IDF_BASE] + df)
              tidf[t2] = wgt
              let bit: i64 = 1 << t2
              pi = hhead[h]
              while pi != INC_NONE {
                  if inc_term_hits(c, term, tlen[t2], pword[pi] as *u8) == 1 {
                      let rw2: i64 = prow[pi]
                      if (mask[rw2] & bit) == 0 { mask[rw2] = mask[rw2] | bit; score[rw2] = score[rw2] + wgt }
                  }
                  pi = pnext[pi]
              }
          } }
      }
      t2 = t2 + 1
  }
  // the rung's own organ never answers its own contract
  if excl[0] != (0 as u8) { i = 0; while i < rows { if inc_streq(rname[i] as *u8, excl) == 1 { score[i] = 0; mask[i] = 0 } i = i + 1 } }
  // the name hits of every matching row: how many matched terms hit its name parts (tier) and their idf, added to
  // the score as a second piece of evidence weighed like the first
  let nh: *i64 = sys_mmap(2 * INC_I64) as *i64
  var matched: i64 = 0
  i = 0
  while i < rows { if score[i] > 0 { matched = matched + 1; inc_name_hits(c, r, rname[i] as *u8, w, pos, nh); tier[i] = nh[0]; nidf[i] = nh[1]; score[i] = score[i] + nh[1] } i = i + 1 }
  r[INC_R_MATCHED] = matched
  // top-N by score (ties by row order): selection, N is small. The scores of the selected rows are zeroed here;
  // tier[] survives for the rejection axis of the renderer.
  let topn: i64 = c[INC_C_TOPN]
  let rrow: *i64 = sys_mmap((topn + 1) * INC_I64) as *i64
  let rsc: *i64 = sys_mmap((topn + 1) * INC_I64) as *i64
  let rmk: *i64 = sys_mmap((topn + 1) * INC_I64) as *i64
  let rtr: *i64 = sys_mmap((topn + 1) * INC_I64) as *i64
  var nres: i64 = 0
  var round: i64 = 0
  while round < topn {
      var best: i64 = INC_NONE
      var bs: i64 = 0
      i = 0
      while i < rows { if score[i] > bs { bs = score[i]; best = i } i = i + 1 }
      if best == INC_NONE { round = topn }
      else { rrow[nres] = best; rsc[nres] = bs; rmk[nres] = mask[best]; rtr[nres] = tier[best]; nres = nres + 1; score[best] = 0; round = round + 1 }
  }
  r[INC_R_N] = nres
  r[INC_R_ROW] = rrow as i64
  r[INC_R_SCORE] = rsc as i64
  r[INC_R_MASK] = rmk as i64
  r[INC_R_TIER] = rtr as i64
  return r
1217}
1218// does any word of the asset's name words match any kept term
1219func inc_asset_hits(c: *i64, r: *i64, ws: *u8) -> i64 {
  let terms: *u8 = r[INC_R_TERMS] as *u8
  let toff: *i64 = r[INC_R_TOFF] as *i64
  let tidf: *i64 = r[INC_R_TIDF] as *i64
  let nt: i64 = r[INC_R_NTERMS]
  let wl: i64 = inc_slen(ws)
  var t: i64 = 0
  while t < nt {
      if (r[INC_R_DROPMASK] & (1 << t)) == 0 {
          let term: *u8 = (terms as i64 + toff[t]) as *u8
          var tl: i64 = inc_slen(term)
          if tl > INC_KEY_BYTES { tl = INC_KEY_BYTES }
          var s: i64 = 0
          while s < wl {
              let e: i64 = inc_wend(ws, wl, s)
              if e > s { if inc_term_hits(c, term, tl, (ws as i64 + s) as *u8) == 1 { return 1 } }
              s = e + 1
          }
      }
      t = t + 1
  }
  return 0
1241}
1242// append the assets a row's header names (unique in the list so far) to out; v = [astart, na]
1243func inc_render_assets(g: *i64, row: i64, out: *u8, o: i64, cap: i64, v: *i64) -> i64 {
  let rassets: *i64 = g[INC_G_R_ASSETS] as *i64
  let alist: *u8 = rassets[row] as *u8
  let al: i64 = inc_slen(alist)
  let one: *u8 = sys_mmap(INC_PATH_CAP)
  var oo: i64 = o
  var s: i64 = 0
  while s < al {
      let e: i64 = inc_wend(alist, al, s)
      if e > s {
          var j: i64 = 0
          while j < e - s { if j < INC_PATH_CAP - 1 { one[j] = alist[s + j] } j = j + 1 }
          if j >= INC_PATH_CAP { j = INC_PATH_CAP - 1 }
          one[j] = 0 as u8
          if inc_listed(out, v[INC_V_ASTART], oo, one) == 0 { if v[INC_V_NA] > 0 { oo = inc_catb(out, oo, cap, " " as *u8) } oo = inc_catb(out, oo, cap, one); v[INC_V_NA] = v[INC_V_NA] + 1 }
      }
      s = e + 1
  }
  return oo
1262}
1263// append one row's rejection lines to out; v[INC_V_N] counts rows written
1264func inc_render_rej(g: *i64, row: i64, out: *u8, o: i64, cap: i64, v: *i64) -> i64 {
  let rname: *i64 = g[INC_G_R_NAME] as *i64
  let rrej: *i64 = g[INC_G_R_REJ] as *i64
  let rj: *u8 = rrej[row] as *u8
  if rj[0] == (0 as u8) { return o }
  var oo: i64 = o
  if v[INC_V_N] > 0 { oo = inc_catb(out, oo, cap, " " as *u8) }
  oo = inc_catb(out, oo, cap, rname[row] as *u8)
  oo = inc_catb(out, oo, cap, ": " as *u8)
  oo = inc_catb(out, oo, cap, rj)
  v[INC_V_N] = v[INC_V_N] + 1
  return oo
1276}
1277// is row a rejection-axis candidate: a name hit, a rejection line on record, not among the top results
1278func inc_rej_cand(g: *i64, r: *i64, row: i64) -> i64 {
  let tier: *i64 = g[INC_G_TIER] as *i64
  if tier[row] <= 0 { return 0 }
  let rrej: *i64 = g[INC_G_R_REJ] as *i64
  let rj: *u8 = rrej[row] as *u8
  if rj[0] == (0 as u8) { return 0 }
  let rrow: *i64 = r[INC_R_ROW] as *i64
  var q: i64 = 0
  while q < r[INC_R_N] { if rrow[q] == row { return 0 } q = q + 1 }
  return 1
1288}
1289// RENDER one answer into out (cap bytes, a cut announced with [CUT]): INCUMBENTS(rid): ... | ASSETS: ... | PRIOR-REJECTIONS: ...
1290func inc_render(g: *i64, c: *i64, r: *i64, rid: *u8, out: *u8, cap: i64) -> i64 {
  var o: i64 = inc_catb(out, 0, cap, "INCUMBENTS(" as *u8)
  o = inc_catb(out, o, cap, rid)
  o = inc_catb(out, o, cap, "): " as *u8)
  let n: i64 = r[INC_R_N]
  let terms: *u8 = r[INC_R_TERMS] as *u8
  let toff: *i64 = r[INC_R_TOFF] as *i64
  let nt: i64 = r[INC_R_NTERMS]
  let rname: *i64 = g[INC_G_R_NAME] as *i64
  let rrej: *i64 = g[INC_G_R_REJ] as *i64
  let rrow: *i64 = r[INC_R_ROW] as *i64
  let rsc: *i64 = r[INC_R_SCORE] as *i64
  let rmk: *i64 = r[INC_R_MASK] as *i64
  let rtr: *i64 = r[INC_R_TIER] as *i64
  if n == 0 {
      o = inc_catb(out, o, cap, "NONE (0 of " as *u8)
      o = inc_catn(out, o, cap, g[INC_G_ROWS])
      o = inc_catb(out, o, cap, " organs match; terms tried=" as *u8)
      var t0: i64 = 0
      while t0 < nt { if t0 > 0 { o = inc_catb(out, o, cap, "," as *u8) } o = inc_catb(out, o, cap, (terms as i64 + toff[t0]) as *u8); t0 = t0 + 1 }
      o = inc_catb(out, o, cap, " dropped_common=" as *u8)
      o = inc_catn(out, o, cap, r[INC_R_DROPPED])
      o = inc_catb(out, o, cap, " dropped_numeric=" as *u8)
      o = inc_catn(out, o, cap, r[INC_R_NUMERIC])
      o = inc_catb(out, o, cap, ")" as *u8)
      if o >= cap - 1 { o = inc_cat(out, cap - 6, "[CUT]" as *u8) }
      return o
  }
  var i: i64 = 0
  while i < n {
      if i > 0 { o = inc_catb(out, o, cap, " " as *u8) }
      o = inc_catb(out, o, cap, rname[rrow[i]] as *u8)
      o = inc_catb(out, o, cap, "(name" as *u8)
      o = inc_catn(out, o, cap, rtr[i])
      o = inc_catb(out, o, cap, " idf" as *u8)
      o = inc_catn(out, o, cap, rsc[i])
      o = inc_catb(out, o, cap, ":" as *u8)
      var t: i64 = 0
      var firstt: i64 = 1
      while t < nt { if (rmk[i] & (1 << t)) != 0 { if firstt == 0 { o = inc_catb(out, o, cap, "," as *u8) } o = inc_catb(out, o, cap, (terms as i64 + toff[t]) as *u8); firstt = 0 } t = t + 1 }
      o = inc_catb(out, o, cap, ")" as *u8)
      i = i + 1
  }
  o = inc_catb(out, o, cap, " of " as *u8)
  o = inc_catn(out, o, cap, r[INC_R_MATCHED])
  o = inc_catb(out, o, cap, " matching, dropped_common=" as *u8)
  o = inc_catn(out, o, cap, r[INC_R_DROPPED])
  o = inc_catb(out, o, cap, " dropped_numeric=" as *u8)
  o = inc_catn(out, o, cap, r[INC_R_NUMERIC])
  // the rejection axis beyond the top organs: every organ whose NAME carries a contract term and whose header
  // records a rejection (a rejection on an organ named for the contract's own word is the record answering the
  // contract); capped by rej_orgs, the overflow counted
  // the candidates ranked by the idf of their name hits: the rarer the contract word in an organ's name, the more
  // specifically that organ is named for the contract (a name hit on a common word is how a generic organ intrudes)
  let nidf: *i64 = g[INC_G_NIDF] as *i64
  let xcap: i64 = c[INC_C_REJ_ORGS]
  let xrows: *i64 = sys_mmap((xcap + 1) * INC_I64) as *i64
  var nx: i64 = 0
  var cands: i64 = 0
  var ri: i64 = 0
  while ri < g[INC_G_ROWS] { if inc_rej_cand(g, r, ri) == 1 { cands = cands + 1 } ri = ri + 1 }
  var round: i64 = 0
  while round < xcap {
      var best: i64 = INC_NONE
      var bv: i64 = INC_NONE
      ri = 0
      while ri < g[INC_G_ROWS] {
          if inc_rej_cand(g, r, ri) == 1 {
              var taken: i64 = 0
              var q: i64 = 0
              while q < nx { if xrows[q] == ri { taken = 1; q = nx } else { q = q + 1 } }
              if taken == 0 { if nidf[ri] > bv { bv = nidf[ri]; best = ri } }
          }
          ri = ri + 1
      }
      if best == INC_NONE { round = xcap } else { xrows[nx] = best; nx = nx + 1; round = round + 1 }
  }
  let xover: i64 = cands - nx
  // assets: named in the matched headers and the rejection organs' headers (unique), then assets whose own name
  // matches a term
  o = inc_catb(out, o, cap, " | ASSETS: " as *u8)
  let v: *i64 = sys_mmap(INC_V_N * INC_I64 + INC_I64) as *i64
  v[INC_V_ASTART] = o
  v[INC_V_NA] = 0
  v[INC_V_N] = 0
  i = 0
  while i < n { o = inc_render_assets(g, rrow[i], out, o, cap, v); i = i + 1 }
  i = 0
  while i < nx { o = inc_render_assets(g, xrows[i], out, o, cap, v); i = i + 1 }
  let aname: *i64 = g[INC_G_A_NAME] as *i64
  let awords: *i64 = g[INC_G_A_WORDS] as *i64
  var ai: i64 = 0
  while ai < g[INC_G_ASSETS] {
      if inc_asset_hits(c, r, awords[ai] as *u8) == 1 { if inc_listed(out, v[INC_V_ASTART], o, aname[ai] as *u8) == 0 {
          if v[INC_V_NA] > 0 { o = inc_catb(out, o, cap, " " as *u8) }
          o = inc_catb(out, o, cap, aname[ai] as *u8)
          o = inc_catb(out, o, cap, "(by-name)" as *u8)
          v[INC_V_NA] = v[INC_V_NA] + 1
      } }
      ai = ai + 1
  }
  if v[INC_V_NA] == 0 { o = inc_catb(out, o, cap, "none" as *u8) }
  // rejections: the top organs' lines, then the rejection axis
  o = inc_catb(out, o, cap, " | PRIOR-REJECTIONS: " as *u8)
  v[INC_V_N] = 0
  i = 0
  while i < n { o = inc_render_rej(g, rrow[i], out, o, cap, v); i = i + 1 }
  i = 0
  while i < nx { o = inc_render_rej(g, xrows[i], out, o, cap, v); i = i + 1 }
  if v[INC_V_N] == 0 { o = inc_catb(out, o, cap, "none recorded in the matched headers or on any name-tier organ" as *u8) }
  if xover > 0 { o = inc_catb(out, o, cap, " (+" as *u8); o = inc_catn(out, o, cap, xover); o = inc_catb(out, o, cap, " more name-tier organs record rejections; raise rej_orgs to list them)" as *u8) }
  if o >= cap - 1 { o = inc_cat(out, cap - 6, "[CUT]" as *u8) }
  return o
1403}
1404// the coverage envelope line for a loaded index
1405func inc_envelope(g: *i64, out: *u8, cap: i64) -> i64 {
  var o: i64 = inc_catb(out, 0, cap, "INCUMBENTS index=" as *u8)
  o = inc_catb(out, o, cap, g[INC_G_PATH] as *u8)
  o = inc_catb(out, o, cap, " state=" as *u8)
  o = inc_catb(out, o, cap, inc_state_name(g[INC_G_STATE]))
  o = inc_catb(out, o, cap, " generated_at=" as *u8)
  o = inc_catn(out, o, cap, g[INC_G_GEN])
  o = inc_catb(out, o, cap, " age_s=" as *u8)
  o = inc_catn(out, o, cap, g[INC_G_AGE])
  o = inc_catb(out, o, cap, " organs=" as *u8)
  o = inc_catn(out, o, cap, g[INC_G_ROWS])
  o = inc_catb(out, o, cap, " files=" as *u8)
  o = inc_catn(out, o, cap, g[INC_G_FILES])
  o = inc_catb(out, o, cap, " head_truncated=" as *u8)
  o = inc_catn(out, o, cap, g[INC_G_TRUNC])
  o = inc_catb(out, o, cap, " assets=" as *u8)
  o = inc_catn(out, o, cap, g[INC_G_ASSETS])
  o = inc_catb(out, o, cap, " corpus_complete=" as *u8)
  o = inc_catn(out, o, cap, g[INC_G_COMPLETE])
  o = inc_catb(out, o, cap, " postings=" as *u8)
  o = inc_catn(out, o, cap, g[INC_G_NPOST])
  return o
1427}
nx_incumbent_lib.nx source

`nx_incumbent_lib.nx` source
