`nx_claims.nx` source

↩ module page · 866 lines · 37392 B
1// nx_claims.nx -- SESSION-CLAIMS AS AN ECOSYSTEM CAPABILITY (ws=ws-intel2, 2026-07-20).
2// Eats debt 1784408445 (claims protocol shell-only via WSL) + feeds 1784408708 (claims hub
3// to NAS = standup claim-holder liveness): claim/beat/release/walk become MCP tools/call
4// verbs on an append-only NAS journal -- peers of nx_ws_sync (journal) / nx_ws_cycle (phase).
5// HOLDERSHIP IS DERIVED, NEVER STORED (evidence law): latest CLAIM not RELEASEd by its
6// holder = the claim; freshness = latest CLAIM/BEAT ts by that holder vs its TTL ->
7// HELD | EXPIRED (crash-expiry BY CONSTRUCTION -- a dead session's claim self-expires,
8// the F214 lease semantics) | FREE (released) | ABSENT. Claim on a contended resource is
9// REFUSED fail-closed (exit 3) -- never silently stolen; an EXPIRED claim is claimable.
10// Frame: <ts>\t<VERB>\t<resource>\t<actor>\t<ttl>\t<note>   VERB in {CLAIM, BEAT, RELEASE}
11// SCALE LAW: windowed reads + declared envelope (window_bytes/truncated/claims_capped).
12// license_tier: ORIGINAL   No hw writes (Rule 26).
13//   claim    <journal> <resource> <actor> <ttl_sec> <note>  -> HELD | CONTENDED(3)
14//   beat     <journal> <resource> <actor> <note>            -> BEAT | NOT-HOLDER(3)
15//   release  <journal> <resource> <actor> <note>            -> RELEASED | NOT-HOLDER(3)
16//   state    <journal> <resource>   -> ONE-LINE probe: state=HELD|EXPIRED|FREE|ABSENT holder=..
17//            (seq543/seq552: lets nx_seat checkout classify NOT-HOLDER honestly; exit 0 always)
18//   walk     <journal>                                      -> JSON all resources
19//   reap     <journal> <reaper> <note>  -> F214: release ONLY provably-EXPIRED claims
20//            (age>ttl by the claim's OWN ttl field) + ORPHAN-REAPED audit note; idempotent; exit 0
21//   selftest <scratch-journal>                              -> gate T1..T8 (caller pre-cleans)
22import "nx_syscalls.nx"
23import "nx_gate_verdict.nx"
24const CL_MAGIC_4096: i64 = 4096
25const CL_MAGIC_2000: i64 = 2000
26const CL_MAGIC_200000: i64 = 200000
27const CL_MAGIC_5000: i64 = 5000
28
29const CL_WIN: i64 = 4194304
30const CL_OUT: i64 = 262144
31const CL_SOFT: i64 = 49152
32const CL_NOTE_MAX: i64 = 200
33const CL_NAME_MAX: i64 = 120
34// THE LEASE CEILING (2026-08-09). MEASURED: `walk` showed held=2 expired=0, BOTH held by one dead seat
35// claude-76b93d3f at ttl_sec=7200000 (83.3 DAYS) against age 16.4 days -- so age < ttl, cl_state derived
36// HELD, and cl_reap (which acts ONLY on st==2) skipped them BY CONSTRUCTION. Two lanes were locked until
37// ~2026-10-14. Proven corpus_complete=1 over 22,811 files: the ONLY ttl validation in the estate was
38// `if ttl <= 0`, with NO UPPER BOUND ANYWHERE. Live journal TTLs are 3600/5400/7200/10800/14400/21600/
39// 86400; 7200000 is exactly 1000x the modal 7200 -- a typo nothing said no to.
40// ***HOLDERSHIP IS DERIVED SO THE HOLDER CANNOT ASSERT ITS OWN LIVENESS -- BUT THE TTL IT IS DIVIDED BY
41// WAS A NUMBER THE HOLDER CHOSE, SO THE HOLDER DEFINED ITS OWN DEATH. A LEASE WHOSE EXPIRY THE LESSEE
42// SETS IS NOT A LEASE.*** The 2026 distributed-systems rule is the same: never trust a process to know
43// that its own lock has expired.
44// 86400 MATCHES THE INCUMBENT rather than inventing a number: nx_no_cookie_session.nx (`if ttl_s > 86400
45// -> BAD_INPUT`) and nx_modern_auth_flow.nx (NX_MAUTH_HARD_MAX_TTL_S = 86400) already bound session TTL
46// at 24h, and 86400 is also the largest legitimate TTL observed in the live journal.
47const CL_TTL_MAX: i64 = 86400
48
49func cl_cat(d: *u8, o: i64, s: *u8) -> i64 { var p: i64=o; var i: i64=0; while s[i]!=(0 as u8){ d[p]=s[i]; p=p+1; i=i+1 } return p }
50func cl_catn(d: *u8, o: i64, v: i64) -> i64 {
  let t: *u8 = sys_mmap(28)
  var m: i64 = v
  var p: i64 = o
  if m < 0 { d[p]=45 as u8; p=p+1; m=0-m }
  var k: i64 = 0
  if m == 0 { t[0]=48 as u8; k=1 }
  while m > 0 { t[k]=(48+(m%10)) as u8; m=m/10; k=k+1 }
  var i: i64 = 0
  while i < k { d[p]=t[k-1-i]; p=p+1; i=i+1 }
  return p
61}
62func cl_vlen(s: *u8) -> i64 { var n: i64=0; while s[n]!=(0 as u8){n=n+1} return n }
63func cl_atoi_z(s: *u8) -> i64 { var v: i64=0; var i: i64=0; while s[i]!=(0 as u8){ let c: i64=s[i] as i64; if c>=48 { if c<=57 { v=v*10+(c-48) } } i=i+1 } return v }
64func cl_read(path: *u8, buf: *u8, cap: i64) -> i64 {
  let fd: i64 = sys_openat_rd(path)
  if fd < 0 { return 0 }
  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
72}
73// append one frame: <ts>\t<verb>\t<resource>\t<actor>\t<ttl>\t<note>\n  (ts<0 => real clock; note flattened)
74func cl_append(journal: *u8, ts: i64, verb: *u8, res: *u8, actor: *u8, ttl: i64, note: *u8) -> i64 {
  var t: i64 = ts
  if t < 0 { t = sys_now_realtime_sec() }
  let ln: *u8 = sys_mmap(CL_MAGIC_4096)
  var o: i64 = 0
  o = cl_catn(ln, o, t)
  ln[o]=9 as u8; o=o+1
  o = cl_cat(ln, o, verb)
  ln[o]=9 as u8; o=o+1
  o = cl_cat(ln, o, res)
  ln[o]=9 as u8; o=o+1
  o = cl_cat(ln, o, actor)
  ln[o]=9 as u8; o=o+1
  o = cl_catn(ln, o, ttl)
  ln[o]=9 as u8; o=o+1
  var i: i64 = 0
  var used: i64 = 0
  while note[i]!=(0 as u8) {
      if used < CL_MAGIC_2000 {
          let c: i64 = note[i] as i64
          if c==9 { ln[o]=32 as u8; o=o+1 } else { if c==10 { ln[o]=32 as u8; o=o+1 } else { if c==13 { ln[o]=32 as u8; o=o+1 } else { ln[o]=c as u8; o=o+1 } } }
          used = used + 1
      }
      i = i + 1
  }
  ln[o]=10 as u8; o=o+1
  let fd: i64 = sys_openat_append(journal, 0x1a4)
  if fd < 0 { return -1 }
  sys_write(fd, ln, o)
  sys_close(fd)
  return 0
105}
106func cl_le(q: *u8, i: i64, n: i64) -> i64 {
  var le: i64 = i
  var s: i64 = 1
  while s==1 { if le>=n { s=0 } else { if q[le]==(10 as u8){s=0} else {le=le+1} } }
  return le
111}
112func cl_col(q: *u8, ls: i64, le: i64, c: i64, out: *i64) -> i64 {
  var col: i64 = 0
  var p: i64 = ls
  while col < c {
      var s: i64 = 1
      while s == 1 { if p >= le { return 0 } if q[p]==(9 as u8) { s = 0 } else { p = p+1 } }
      p = p + 1
      col = col + 1
  }
  var e: i64 = p
  var s2: i64 = 1
  while s2 == 1 { if e >= le { s2 = 0 } else { if q[e]==(9 as u8) { s2 = 0 } else { e = e+1 } } }
  out[0] = p
  out[1] = e
  return 1
127}
128func cl_lit_eq(q: *u8, s: i64, e: i64, lit: *u8) -> i64 {
  var i: i64 = 0
  while s+i < e { if lit[i]==(0 as u8) { return 0 } if q[s+i]!=lit[i] { return 0 } i=i+1 }
  if lit[i]!=(0 as u8) { return 0 }
  return 1
133}
134func cl_span_eq(q: *u8, s1: i64, e1: i64, s2: i64, e2: i64) -> i64 {
  if e1-s1 != e2-s2 { return 0 }
  var i: i64 = 0
  while s1+i < e1 { if q[s1+i]!=q[s2+i] { return 0 } i=i+1 }
  return 1
139}
140func cl_atoi(q: *u8, s: i64, e: i64) -> i64 {
  var v: i64 = 0
  var i: i64 = s
  while i < e { let c: i64 = q[i] as i64; if c>=48 { if c<=57 { v = v*10 + (c-48) } } i=i+1 }
  return v
145}
146// DERIVED claim state for a resource span. Returns -1 ABSENT / 1 HELD / 2 EXPIRED / 3 FREE.
147// out[0..1]=holder span, out[2]=ttl, out[3]=last_activity_ts (valid when state 1|2).
148func cl_state(q: *u8, cx: *i64, res_s: i64, res_e: i64, out: *i64) -> i64 {
  let n: i64 = cx[0]
  let cv: *i64 = sys_mmap(16) as *i64
  let cr: *i64 = sys_mmap(16) as *i64
  let ca: *i64 = sys_mmap(16) as *i64
  let ct: *i64 = sys_mmap(16) as *i64
  let c0: *i64 = sys_mmap(16) as *i64
  var mode: i64 = 0
  var ever: i64 = 0
  var hs: i64 = -1
  var he: i64 = -1
  var ttl: i64 = 0
  var last: i64 = 0
  var i: i64 = 0
  while i < n {
      let le: i64 = cl_le(q,i,n)
      if cl_col(q,i,le,2,cr)==1 { if cl_span_eq(q,cr[0],cr[1],res_s,res_e)==1 {
          if cl_col(q,i,le,1,cv)==1 { if cl_col(q,i,le,0,c0)==1 { if cl_col(q,i,le,3,ca)==1 {
              let ts: i64 = cl_atoi(q,c0[0],c0[1])
              if cl_lit_eq(q,cv[0],cv[1],"CLAIM" as *u8)==1 {
                  mode=1
                  ever=1
                  hs=ca[0]
                  he=ca[1]
                  last=ts
                  if cl_col(q,i,le,4,ct)==1 { ttl = cl_atoi(q,ct[0],ct[1]) }
              }
              if cl_lit_eq(q,cv[0],cv[1],"BEAT" as *u8)==1 {
                  if mode==1 { if cl_span_eq(q,ca[0],ca[1],hs,he)==1 { last=ts } }
              }
              if cl_lit_eq(q,cv[0],cv[1],"RELEASE" as *u8)==1 {
                  if mode==1 { if cl_span_eq(q,ca[0],ca[1],hs,he)==1 { mode=0 } }
              }
          } } }
      } }
      i = le + 1
  }
  if ever==0 { return -1 }
  if mode==0 { return 3 }
  out[0]=hs
  out[1]=he
  out[2]=ttl
  out[3]=last
  let age: i64 = cx[1] - last
  // THE GUARD AND ITS PAIRED REPAIR IN ONE PLACE. Bounding only the CLAIM path would fix future claims
  // and leave the two already-written immortals locked forever -- and the estate's own law is that a
  // guard shipped without its paired repair is a permanent outage of the thing it guards. Capping HERE,
  // in the single derivation every consumer (walk/state/beat/release/reap) already shares, retroactively
  // corrects out-of-policy rows WITHOUT rewriting the append-only journal (additive-only holds).
  // FAIL DIRECTION: this can only ever make a lease expire SOONER. It cannot manufacture a false HELD.
  // out[2] deliberately still reports the RECORDED ttl, so `walk` shows state=EXPIRED beside
  // ttl_sec=7200000 and the original defect stays VISIBLE rather than being silently normalised.
  var eff: i64 = ttl
  if eff > CL_TTL_MAX { eff = CL_TTL_MAX }
  if age > eff { return 2 }
  return 1
204}
205func cl_state_name(st: i64) -> *u8 {
  if st==1 { return "HELD" as *u8 }
  if st==2 { return "EXPIRED" as *u8 }
  if st==3 { return "FREE" as *u8 }
  return "ABSENT" as *u8
210}
211// resource span first occurrence? (walk dedupe)
212func cl_res_seen(q: *u8, upto: i64, r_s: i64, r_e: i64) -> i64 {
  let cr: *i64 = sys_mmap(16) as *i64
  var i: i64 = 0
  while i < upto {
      let le: i64 = cl_le(q,i,upto)
      if cl_col(q,i,le,2,cr)==1 { if cl_span_eq(q,cr[0],cr[1],r_s,r_e)==1 { return 1 } }
      i = le + 1
  }
  return 0
221}
222// find span of a resource by literal name; 1 if any frame carries it
223func cl_res_span_lit(q: *u8, cx: *i64, res: *u8, out: *i64) -> i64 {
  let n: i64 = cx[0]
  let cr: *i64 = sys_mmap(16) as *i64
  var i: i64 = 0
  while i < n {
      let le: i64 = cl_le(q,i,n)
      if cl_col(q,i,le,2,cr)==1 { if cl_lit_eq(q,cr[0],cr[1],res)==1 { out[0]=cr[0]; out[1]=cr[1]; return 1 } }
      i = le + 1
  }
  return 0
233}
234// last note (col5) for a resource
235func cl_note_span(q: *u8, cx: *i64, res_s: i64, res_e: i64, out: *i64) -> i64 {
  let n: i64 = cx[0]
  let cr: *i64 = sys_mmap(16) as *i64
  let cn: *i64 = sys_mmap(16) as *i64
  var ns: i64 = -1
  var ne: i64 = -1
  var i: i64 = 0
  while i < n {
      let le: i64 = cl_le(q,i,n)
      if cl_col(q,i,le,2,cr)==1 { if cl_span_eq(q,cr[0],cr[1],res_s,res_e)==1 {
          if cl_col(q,i,le,5,cn)==1 { ns=cn[0]; ne=cn[1] }
      } }
      i = le + 1
  }
  if ns >= 0 { out[0]=ns; out[1]=ne; return 1 }
  return 0
251}
252func cl_jesc(d: *u8, o: i64, q: *u8, s: i64, e: i64, maxb: i64) -> i64 {
  var p: i64 = o
  var i: i64 = s
  var used: i64 = 0
  while i < e {
      if used >= maxb { i = e } else {
          let c: i64 = q[i] as i64
          if c == 34 { d[p]=92 as u8; p=p+1; d[p]=34 as u8; p=p+1 } else { if c == 92 { d[p]=92 as u8; p=p+1; d[p]=92 as u8; p=p+1 } else { if c < 32 { d[p]=32 as u8; p=p+1 } else { d[p]=c as u8; p=p+1 } } }
          used = used + 2
          i = i + 1
      }
  }
  return p
265}
266func cl_key(d: *u8, o: i64, name: *u8) -> i64 {
  d[o]=34 as u8
  var p: i64 = o + 1
  p = cl_cat(d,p,name)
  d[p]=34 as u8
  p = p + 1
  d[p]=58 as u8
  p = p + 1
  return p
275}
276func cl_qlit(d: *u8, o: i64, s: *u8) -> i64 {
  var p: i64 = o
  d[p]=34 as u8; p=p+1
  p = cl_cat(d,p,s)
  d[p]=34 as u8; p=p+1
  return p
282}
283func cl_emit_res(d: *u8, o: i64, q: *u8, cx: *i64, r_s: i64, r_e: i64) -> i64 {
  var p: i64 = o
  let st_out: *i64 = sys_mmap(32) as *i64
  let no: *i64 = sys_mmap(16) as *i64
  d[p]=123 as u8; p=p+1
  p = cl_key(d,p,"resource" as *u8)
  d[p]=34 as u8; p=p+1
  p = cl_jesc(d,p,q,r_s,r_e,CL_NAME_MAX)
  d[p]=34 as u8; p=p+1
  d[p]=44 as u8; p=p+1
  let st: i64 = cl_state(q,cx,r_s,r_e,st_out)
  p = cl_key(d,p,"state" as *u8)
  let sn: *u8 = cl_state_name(st)
  p = cl_qlit(d,p,sn)
  d[p]=44 as u8; p=p+1
  p = cl_key(d,p,"holder" as *u8)
  d[p]=34 as u8; p=p+1
  if st==1 { p = cl_jesc(d,p,q,st_out[0],st_out[1],CL_NAME_MAX) }
  if st==2 { p = cl_jesc(d,p,q,st_out[0],st_out[1],CL_NAME_MAX) }
  d[p]=34 as u8; p=p+1
  d[p]=44 as u8; p=p+1
  p = cl_key(d,p,"ttl_sec" as *u8)
  var tv: i64 = -1
  if st==1 { tv = st_out[2] }
  if st==2 { tv = st_out[2] }
  p = cl_catn(d,p,tv)
  d[p]=44 as u8; p=p+1
  p = cl_key(d,p,"age_sec" as *u8)
  var age: i64 = -1
  if st==1 { age = cx[1] - st_out[3] }
  if st==2 { age = cx[1] - st_out[3] }
  p = cl_catn(d,p,age)
  d[p]=44 as u8; p=p+1
  p = cl_key(d,p,"last_note" as *u8)
  d[p]=34 as u8; p=p+1
  let hn: i64 = cl_note_span(q,cx,r_s,r_e,no)
  if hn==1 { p = cl_jesc(d,p,q,no[0],no[1],CL_NOTE_MAX) }
  d[p]=34 as u8; p=p+1
  d[p]=125 as u8; p=p+1
  return p
323}
324func cl_walk_json(q: *u8, cx: *i64, d: *u8) -> i64 {
  let n: i64 = cx[0]
  var p: i64 = 0
  d[p]=123 as u8; p=p+1
  p = cl_key(d,p,"v" as *u8)
  p = cl_catn(d,p,1)
  d[p]=44 as u8; p=p+1
  p = cl_key(d,p,"tool" as *u8)
  p = cl_qlit(d,p,"nx_claims" as *u8)
  d[p]=44 as u8; p=p+1
  p = cl_key(d,p,"journal" as *u8)
  d[p]=34 as u8; p=p+1
  let jp: *u8 = cx[5] as *u8
  let jl: i64 = cl_vlen(jp)
  p = cl_jesc(d,p,jp,0,jl,200)
  d[p]=34 as u8; p=p+1
  d[p]=44 as u8; p=p+1
  p = cl_key(d,p,"journal_bytes" as *u8)
  p = cl_catn(d,p,n)
  d[p]=44 as u8; p=p+1
  p = cl_key(d,p,"window_bytes" as *u8)
  p = cl_catn(d,p,CL_WIN)
  d[p]=44 as u8; p=p+1
  p = cl_key(d,p,"truncated" as *u8)
  p = cl_catn(d,p,cx[4])
  d[p]=44 as u8; p=p+1
  p = cl_key(d,p,"now" as *u8)
  p = cl_catn(d,p,cx[1])
  d[p]=44 as u8; p=p+1
  // totals pass
  let cr: *i64 = sys_mmap(16) as *i64
  let st_out: *i64 = sys_mmap(32) as *i64
  var theld: i64 = 0
  var texp: i64 = 0
  var tfree: i64 = 0
  var i: i64 = 0
  while i < n {
      let le: i64 = cl_le(q,i,n)
      if cl_col(q,i,le,2,cr)==1 { if cl_res_seen(q,i,cr[0],cr[1])==0 {
          let st: i64 = cl_state(q,cx,cr[0],cr[1],st_out)
          if st==1 { theld=theld+1 }
          if st==2 { texp=texp+1 }
          if st==3 { tfree=tfree+1 }
      } }
      i = le + 1
  }
  p = cl_key(d,p,"totals" as *u8)
  d[p]=123 as u8; p=p+1
  p = cl_key(d,p,"held" as *u8)
  p = cl_catn(d,p,theld)
  d[p]=44 as u8; p=p+1
  p = cl_key(d,p,"expired" as *u8)
  p = cl_catn(d,p,texp)
  d[p]=44 as u8; p=p+1
  p = cl_key(d,p,"free" as *u8)
  p = cl_catn(d,p,tfree)
  d[p]=125 as u8; p=p+1
  d[p]=44 as u8; p=p+1
  p = cl_key(d,p,"resources" as *u8)
  d[p]=91 as u8; p=p+1
  var capped: i64 = 0
  var first: i64 = 1
  var j: i64 = 0
  while j < n {
      let je: i64 = cl_le(q,j,n)
      if cl_col(q,j,je,2,cr)==1 { if cl_res_seen(q,j,cr[0],cr[1])==0 {
          if p > CL_SOFT { capped=1 } else {
              if first==0 { d[p]=44 as u8; p=p+1 }
              first=0
              p = cl_emit_res(d,p,q,cx,cr[0],cr[1])
          }
      } }
      j = je + 1
  }
  d[p]=93 as u8; p=p+1
  d[p]=44 as u8; p=p+1
  p = cl_key(d,p,"claims_capped" as *u8)
  p = cl_catn(d,p,capped)
  d[p]=125 as u8; p=p+1
  d[p]=10 as u8; p=p+1
  return p
405}
406func cl_hesc(d: *u8, o: i64, q: *u8, s: i64, e: i64, maxb: i64) -> i64 {
  var p: i64 = o
  var i: i64 = s
  var used: i64 = 0
  while i < e {
      if used >= maxb { i = e } else {
          let c: i64 = q[i] as i64
          if c == 60 { p = cl_cat(d,p,"&lt;" as *u8) } else { if c == 62 { p = cl_cat(d,p,"&gt;" as *u8) } else { if c == 38 { p = cl_cat(d,p,"&amp;" as *u8) } else { if c < 32 { d[p]=32 as u8; p=p+1 } else { d[p]=c as u8; p=p+1 } } } }
          used = used + 5
          i = i + 1
      }
  }
  return p
419}
420func cl_page_html(q: *u8, cx: *i64, d: *u8) -> i64 {
  let n: i64 = cx[0]
  var p: i64 = 0
  p = cl_cat(d,p,"<" as *u8)
  d[p]=33 as u8
  p = p + 1
  p = cl_cat(d,p,"doctype html><html><head><meta charset=utf-8><title>Nishi Claims</title></head><body>" as *u8)
  p = cl_cat(d,p,"<h1>Nishi Claims -- who holds what (TTL crash-expiry, derived never asserted)</h1>" as *u8)
  let cr: *i64 = sys_mmap(16) as *i64
  let st_out: *i64 = sys_mmap(32) as *i64
  let no: *i64 = sys_mmap(16) as *i64
  var theld: i64 = 0
  var texp: i64 = 0
  var tfree: i64 = 0
  var i: i64 = 0
  while i < n {
      let le: i64 = cl_le(q,i,n)
      if cl_col(q,i,le,2,cr)==1 { if cl_res_seen(q,i,cr[0],cr[1])==0 {
          let st: i64 = cl_state(q,cx,cr[0],cr[1],st_out)
          if st==1 { theld=theld+1 }
          if st==2 { texp=texp+1 }
          if st==3 { tfree=tfree+1 }
      } }
      i = le + 1
  }
  p = cl_cat(d,p,"<p>held=" as *u8)
  p = cl_catn(d,p,theld)
  p = cl_cat(d,p," expired=" as *u8)
  p = cl_catn(d,p,texp)
  p = cl_cat(d,p," free=" as *u8)
  p = cl_catn(d,p,tfree)
  p = cl_cat(d,p,"</p>" as *u8)
  p = cl_cat(d,p,"<table border=1><tr><th>resource</th><th>state</th><th>holder</th><th>ttl-sec</th><th>age-sec</th><th>last note</th></tr>" as *u8)
  var truncated_rows: i64 = 0
  var j: i64 = 0
  while j < n {
      let je: i64 = cl_le(q,j,n)
      if cl_col(q,j,je,2,cr)==1 { if cl_res_seen(q,j,cr[0],cr[1])==0 {
          if p > CL_MAGIC_200000 { truncated_rows = truncated_rows + 1 } else {
              p = cl_cat(d,p,"<tr><td>" as *u8)
              p = cl_hesc(d,p,q,cr[0],cr[1],CL_NAME_MAX)
              p = cl_cat(d,p,"</td><td>" as *u8)
              let st2: i64 = cl_state(q,cx,cr[0],cr[1],st_out)
              let sn: *u8 = cl_state_name(st2)
              p = cl_cat(d,p,sn)
              p = cl_cat(d,p,"</td><td>" as *u8)
              if st2==1 { p = cl_hesc(d,p,q,st_out[0],st_out[1],CL_NAME_MAX) }
              if st2==2 { p = cl_hesc(d,p,q,st_out[0],st_out[1],CL_NAME_MAX) }
              p = cl_cat(d,p,"</td><td>" as *u8)
              var tv: i64 = -1
              if st2==1 { tv = st_out[2] }
              if st2==2 { tv = st_out[2] }
              p = cl_catn(d,p,tv)
              p = cl_cat(d,p,"</td><td>" as *u8)
              var age: i64 = -1
              if st2==1 { age = cx[1] - st_out[3] }
              if st2==2 { age = cx[1] - st_out[3] }
              p = cl_catn(d,p,age)
              p = cl_cat(d,p,"</td><td>" as *u8)
              let hn: i64 = cl_note_span(q,cx,cr[0],cr[1],no)
              if hn==1 { p = cl_hesc(d,p,q,no[0],no[1],CL_NOTE_MAX) }
              p = cl_cat(d,p,"</td></tr>" as *u8)
          }
      } }
      j = je + 1
  }
  p = cl_cat(d,p,"</table>" as *u8)
  if truncated_rows > 0 {
      p = cl_cat(d,p,"<p>ENVELOPE: rows_truncated=" as *u8)
      p = cl_catn(d,p,truncated_rows)
      p = cl_cat(d,p,"</p>" as *u8)
  }
  p = cl_cat(d,p,"<p>envelope window_bytes=" as *u8)
  p = cl_catn(d,p,CL_WIN)
  p = cl_cat(d,p," journal_bytes=" as *u8)
  p = cl_catn(d,p,n)
  p = cl_cat(d,p," generated=" as *u8)
  p = cl_catn(d,p,cx[1])
  p = cl_cat(d,p," | source=knowledge/status/claims.jrnl | tool=nx_claims (MCP) | <a href=/standup>standup</a> <a href=/wsmine>wsmine</a> <a href=/frontier>frontier</a></p>" as *u8)
  p = cl_cat(d,p,"</body></html>" as *u8)
  d[p]=10 as u8
  p = p + 1
  return p
503}
504func cl_find(d: *u8, dn: i64, lit: *u8) -> i64 {
  let ll: i64 = cl_vlen(lit)
  if ll == 0 { return 0 }
  var i: i64 = 0
  while i + ll <= dn {
      var k: i64 = 0
      var ok: i64 = 1
      while k < ll { if d[i+k]!=lit[k] { ok=0; k=ll } else { k=k+1 } }
      if ok==1 { return 1 }
      i = i + 1
  }
  return 0
516}
517
518// F214 ORPHAN REAP -- fail-safe BY CONSTRUCTION: derive+append on ONE snapshot; release ONLY
519// claims whose state derives EXPIRED (age>ttl by the claim's OWN ttl field). NEVER by name,
520// NEVER by looks-stale, no special cases. Additive-only (RELEASE frames appended, history kept).
521// Idempotent: post-reap state=FREE so a re-run appends NOTHING. Audit=who/when/why in the note.
522func cl_span_z(q: *u8, s: i64, e: i64, d: *u8, cap: i64) -> i64 {
  if e - s >= cap { return 0 }
  var i: i64 = 0
  while s + i < e { d[i] = q[s+i]; i = i + 1 }
  d[i] = 0 as u8
  return 1
528}
529func cl_reap(journal: *u8, q: *u8, cx: *i64, reaper: *u8, note: *u8) -> i64 {
  let n: i64 = cx[0]
  let cr: *i64 = sys_mmap(16) as *i64
  let so: *i64 = sys_mmap(32) as *i64
  let rname: *u8 = sys_mmap(512)
  let hname: *u8 = sys_mmap(512)
  let rnote: *u8 = sys_mmap(CL_MAGIC_4096)
  var reaped: i64 = 0
  var scanned: i64 = 0
  var i: i64 = 0
  while i < n {
      let le: i64 = cl_le(q,i,n)
      if cl_col(q,i,le,2,cr)==1 { if cl_res_seen(q,i,cr[0],cr[1])==0 {
          scanned = scanned + 1
          let st: i64 = cl_state(q,cx,cr[0],cr[1],so)
          if st==2 {
              let okr: i64 = cl_span_z(q,cr[0],cr[1],rname,500)
              let okh: i64 = cl_span_z(q,so[0],so[1],hname,500)
              if okr==1 { if okh==1 {
                  let age: i64 = cx[1] - so[3]
                  var o: i64 = 0
                  o = cl_cat(rnote,0,"ORPHAN-REAPED by=" as *u8)
                  o = cl_cat(rnote,o,reaper)
                  o = cl_cat(rnote,o," expired age=" as *u8)
                  o = cl_catn(rnote,o,age)
                  o = cl_cat(rnote,o,"s ttl=" as *u8)
                  o = cl_catn(rnote,o,so[2])
                  o = cl_cat(rnote,o,"s " as *u8)
                  o = cl_cat(rnote,o,note)
                  rnote[o] = 0 as u8
                  let arc: i64 = cl_append(journal,-1,"RELEASE" as *u8,rname,hname,0,rnote)
                  if arc==0 {
                      reaped = reaped + 1
                      gv_puts("NX-CLAIMS REAPED resource=" as *u8)
                      gv_puts(rname)
                      gv_puts(" holder=" as *u8)
                      gv_puts(hname)
                      gv_puts(" age=" as *u8)
                      gv_num(age)
                      gv_puts(" ttl=" as *u8)
                      gv_num(so[2])
                      gv_puts("\n" as *u8)
                  } else {
                      gv_puts("NX-CLAIMS REAP-APPEND-FAIL resource=" as *u8)
                      gv_puts(rname)
                      gv_puts("\n" as *u8)
                  }
              } }
              if okr==0 { gv_puts("NX-CLAIMS REAP-SKIP resource-name-too-long\n" as *u8) } else { if okh==0 { gv_puts("NX-CLAIMS REAP-SKIP holder-too-long\n" as *u8) } }
          }
      } }
      i = le + 1
  }
  gv_puts("NX-CLAIMS REAP-DONE reaped=" as *u8)
  gv_num(reaped)
  gv_puts(" scanned=" as *u8)
  gv_num(scanned)
  gv_puts(" now=" as *u8)
  gv_num(cx[1])
  gv_puts("\n" as *u8)
  return reaped
590}
591
592// ---------- selftest gate (T1..T13, deterministic via injected timestamps) ----------
593func cl_selftest(journal: *u8) -> i64 {
  let ctr: *i64 = gv_ctr()
  gv_head("nx_claims selftest -- lease/claim teeth (caller pre-cleans journal)" as *u8)
  let q: *u8 = sys_mmap(CL_WIN)
  let cx: *i64 = sys_mmap(64) as *i64
  let sp: *i64 = sys_mmap(16) as *i64
  let st_out: *i64 = sys_mmap(32) as *i64
  let now: i64 = sys_now_realtime_sec()
  let rcap: i64 = CL_WIN - 8
  // T1 empty journal -> absent resource honestly ABSENT
  var n: i64 = cl_read(journal,q,rcap)
  cx[0]=n; cx[1]=now; cx[2]=0; cx[3]=0; cx[4]=0; cx[5]=journal as i64
  var ok1: i64 = 0
  if n==0 { ok1=1 }
  gv_check("T1 empty journal no fabricated claims" as *u8, ok1, ctr)
  // T2 fresh claim -> HELD by claimer
  let t2ts: i64 = now - 100
  cl_append(journal, t2ts, "CLAIM" as *u8, "resA" as *u8, "sess1" as *u8, 1000, "claimA" as *u8)
  n = cl_read(journal,q,rcap)
  cx[0]=n
  var ok2: i64 = 0
  if cl_res_span_lit(q,cx,"resA" as *u8,sp)==1 {
      let st2: i64 = cl_state(q,cx,sp[0],sp[1],st_out)
      if st2==1 { if cl_lit_eq(q,st_out[0],st_out[1],"sess1" as *u8)==1 { ok2=1 } }
  }
  gv_check("T2 fresh claim derives HELD by claimer" as *u8, ok2, ctr)
  // T3 contender predicate: HELD + holder != sess2 -> claim verb would refuse
  var ok3: i64 = 0
  if cl_res_span_lit(q,cx,"resA" as *u8,sp)==1 {
      let st3: i64 = cl_state(q,cx,sp[0],sp[1],st_out)
      if st3==1 { if cl_lit_eq(q,st_out[0],st_out[1],"sess2" as *u8)==0 { ok3=1 } }
  }
  gv_check("T3 contended claim predicate refuses other actor" as *u8, ok3, ctr)
  // T4 beat by holder revives freshness: old claim + fresh beat -> HELD
  let t4c: i64 = now - CL_MAGIC_5000
  let t4b: i64 = now - 50
  cl_append(journal, t4c, "CLAIM" as *u8, "resB" as *u8, "sess1" as *u8, 1000, "claimB" as *u8)
  cl_append(journal, t4b, "BEAT" as *u8, "resB" as *u8, "sess1" as *u8, 0, "beatB" as *u8)
  n = cl_read(journal,q,rcap)
  cx[0]=n
  var ok4: i64 = 0
  if cl_res_span_lit(q,cx,"resB" as *u8,sp)==1 { let st4: i64 = cl_state(q,cx,sp[0],sp[1],st_out); if st4==1 { ok4=1 } }
  gv_check("T4 holder beat revives freshness HELD" as *u8, ok4, ctr)
  // T5 stale claim without beats -> EXPIRED (crash-expiry)
  let t5c: i64 = now - CL_MAGIC_5000
  cl_append(journal, t5c, "CLAIM" as *u8, "resC" as *u8, "sess3" as *u8, 1000, "claimC" as *u8)
  n = cl_read(journal,q,rcap)
  cx[0]=n
  var ok5: i64 = 0
  if cl_res_span_lit(q,cx,"resC" as *u8,sp)==1 { let st5: i64 = cl_state(q,cx,sp[0],sp[1],st_out); if st5==2 { ok5=1 } }
  gv_check("T5 stale claim derives EXPIRED crash-expiry" as *u8, ok5, ctr)
  // T6 release -> FREE, then re-claim by other -> HELD by new holder
  let t6c: i64 = now - 300
  let t6r: i64 = now - 200
  let t6c2: i64 = now - 100
  cl_append(journal, t6c, "CLAIM" as *u8, "resD" as *u8, "sess1" as *u8, 1000, "claimD" as *u8)
  cl_append(journal, t6r, "RELEASE" as *u8, "resD" as *u8, "sess1" as *u8, 0, "releaseD" as *u8)
  n = cl_read(journal,q,rcap)
  cx[0]=n
  var ok6a: i64 = 0
  if cl_res_span_lit(q,cx,"resD" as *u8,sp)==1 { let st6: i64 = cl_state(q,cx,sp[0],sp[1],st_out); if st6==3 { ok6a=1 } }
  cl_append(journal, t6c2, "CLAIM" as *u8, "resD" as *u8, "sess2" as *u8, 1000, "reclaimD" as *u8)
  n = cl_read(journal,q,rcap)
  cx[0]=n
  var ok6: i64 = 0
  if ok6a==1 { if cl_res_span_lit(q,cx,"resD" as *u8,sp)==1 {
      let st6b: i64 = cl_state(q,cx,sp[0],sp[1],st_out)
      if st6b==1 { if cl_lit_eq(q,st_out[0],st_out[1],"sess2" as *u8)==1 { ok6=1 } }
  } }
  gv_check("T6 release frees then other actor claims" as *u8, ok6, ctr)
  // T7 neg-control: absent resource stays absent
  var ok7: i64 = 0
  if cl_res_span_lit(q,cx,"resNOPE" as *u8,sp)==0 { ok7=1 }
  gv_check("T7 neg-control absent resource stays absent" as *u8, ok7, ctr)
  // T8 walk JSON smoke: totals + states + envelope
  let d: *u8 = sys_mmap(CL_OUT)
  let dl: i64 = cl_walk_json(q,cx,d)
  var ok8: i64 = 0
  if dl > 0 { if d[0]==(123 as u8) { if cl_find(d,dl,"EXPIRED" as *u8)==1 { if cl_find(d,dl,"claims_capped" as *u8)==1 { if cl_find(d,dl,"held" as *u8)==1 { ok8=1 } } } } }
  gv_check("T8 walk JSON carries totals plus declared envelope" as *u8, ok8, ctr)
  // T9 page HTML smoke: table + states + envelope
  let d2: *u8 = sys_mmap(CL_OUT)
  let dl9: i64 = cl_page_html(q,cx,d2)
  var ok9: i64 = 0
  if dl9 > 0 { if cl_find(d2,dl9,"<table" as *u8)==1 { if cl_find(d2,dl9,"EXPIRED" as *u8)==1 { if cl_find(d2,dl9,"window_bytes" as *u8)==1 { ok9=1 } } } }
  gv_check("T9 page HTML carries table states envelope" as *u8, ok9, ctr)
  // T10 F214 reap: ONLY the provably-expired claim (resC age>ttl) is released; audit note lands
  n = cl_read(journal,q,rcap)
  cx[0]=n
  let r10: i64 = cl_reap(journal,q,cx,"reaper1" as *u8,"t10-orphan-sweep" as *u8)
  n = cl_read(journal,q,rcap)
  cx[0]=n
  var ok10: i64 = 0
  if r10==1 { if cl_res_span_lit(q,cx,"resC" as *u8,sp)==1 {
      let st10: i64 = cl_state(q,cx,sp[0],sp[1],st_out)
      if st10==3 { if cl_find(q,n,"ORPHAN-REAPED by=reaper1" as *u8)==1 { ok10=1 } }
  } }
  gv_check("T10 reap releases only the expired claim with audit note" as *u8, ok10, ctr)
  // T11 NEGATIVE: unexpired claims SURVIVE the reap untouched
  var ok11: i64 = 0
  if cl_res_span_lit(q,cx,"resA" as *u8,sp)==1 {
      let st11a: i64 = cl_state(q,cx,sp[0],sp[1],st_out)
      if st11a==1 { if cl_lit_eq(q,st_out[0],st_out[1],"sess1" as *u8)==1 {
          if cl_res_span_lit(q,cx,"resD" as *u8,sp)==1 {
              let st11d: i64 = cl_state(q,cx,sp[0],sp[1],st_out)
              if st11d==1 { if cl_lit_eq(q,st_out[0],st_out[1],"sess2" as *u8)==1 { ok11=1 } }
          }
      } }
  }
  gv_check("T11 negative unexpired claims survive reap" as *u8, ok11, ctr)
  // T12 idempotent: nothing expired -> reap changes NOTHING (0 reaped, journal byte-identical)
  let nb12: i64 = n
  let r12: i64 = cl_reap(journal,q,cx,"reaper1" as *u8,"t12-rerun" as *u8)
  let n12: i64 = cl_read(journal,q,rcap)
  cx[0]=n12
  var ok12: i64 = 0
  if r12==0 { if n12==nb12 { ok12=1 } }
  gv_check("T12 reap idempotent when nothing expired" as *u8, ok12, ctr)
  // T13 a reaped resource is claimable by a NEW actor (the unblocked-sibling tooth)
  cl_append(journal, -1, "CLAIM" as *u8, "resC" as *u8, "sess9" as *u8, 1000, "post-reap-claim" as *u8)
  let n13: i64 = cl_read(journal,q,rcap)
  cx[0]=n13
  var ok13: i64 = 0
  if cl_res_span_lit(q,cx,"resC" as *u8,sp)==1 {
      let st13: i64 = cl_state(q,cx,sp[0],sp[1],st_out)
      if st13==1 { if cl_lit_eq(q,st_out[0],st_out[1],"sess9" as *u8)==1 { ok13=1 } }
  }
  gv_check("T13 reaped resource claimable by new actor" as *u8, ok13, ctr)
  let rc: i64 = gv_verdict("CLAIMS-GATE" as *u8, ctr, "claim lease + F214 orphan-reap teeth green" as *u8)
  return rc
723}
724
725func main(argc: i64, argv: *i64) -> i64 {
  if argc < 3 { gv_puts("usage: nx_claims {claim <journal> <resource> <actor> <ttl_sec> <note> | beat <journal> <resource> <actor> <note> | release <journal> <resource> <actor> <note> | walk <journal> | state <journal> <resource> | reap <journal> <reaper> <note> | selftest <journal>}\n" as *u8); sys_exit(2); return 2 }
  let verb: *u8 = argv[1] as *u8
  let journal: *u8 = argv[2] as *u8
  let vl: i64 = cl_vlen(verb)
  if cl_lit_eq(verb,0,vl,"selftest" as *u8)==1 { let rc: i64 = cl_selftest(journal); sys_exit(rc); return rc }
  let q: *u8 = sys_mmap(CL_WIN)
  let rcap: i64 = CL_WIN - 8
  let n: i64 = cl_read(journal,q,rcap)
  let cx: *i64 = sys_mmap(64) as *i64
  cx[0]=n
  cx[1]=sys_now_realtime_sec()
  cx[2]=0
  cx[3]=0
  cx[4]=0
  if n >= rcap { cx[4]=1 }
  cx[5]=journal as i64
  if cl_lit_eq(verb,0,vl,"walk" as *u8)==1 {
      let d: *u8 = sys_mmap(CL_OUT)
      let dl: i64 = cl_walk_json(q,cx,d)
      sys_write(1,d,dl)
      sys_exit(0)
      return 0
  }
  if cl_lit_eq(verb,0,vl,"page" as *u8)==1 {
      if argc < 4 { gv_puts("page needs <journal> <outfile>\n" as *u8); sys_exit(2); return 2 }
      let outfile: *u8 = argv[3] as *u8
      let d: *u8 = sys_mmap(CL_OUT)
      let dl: i64 = cl_page_html(q,cx,d)
      let fd: i64 = sys_openat_wr(outfile, 0x1a4)
      if fd < 0 { gv_puts("CLAIMS-PAGE OPEN-FAIL\n" as *u8); sys_exit(1); return 1 }
      sys_write(fd,d,dl)
      sys_close(fd)
      gv_puts("CLAIMS-PAGE bytes=" as *u8)
      gv_num(dl)
      gv_puts("\n" as *u8)
      sys_exit(0)
      return 0
  }
  // seq543/seq552: single-resource STATE probe (additive, rule 19) -- the SAME derivation the
  // beat/release path uses (cl_res_span_lit + cl_state), so holdership judgment stays one copy.
  // Lets nx_seat checkout classify a NOT-HOLDER release honestly (already-free vs live-foreign)
  // without a full walk. Read-only, exit 0 always.
  if cl_lit_eq(verb,0,vl,"state" as *u8)==1 {
      if argc < 4 { gv_puts("state needs <journal> <resource>\n" as *u8); sys_exit(2); return 2 }
      let sres: *u8 = argv[3] as *u8
      let ssp: *i64 = sys_mmap(16) as *i64
      let sso: *i64 = sys_mmap(32) as *i64
      var sv: i64 = -1
      if cl_res_span_lit(q,cx,sres,ssp)==1 { sv = cl_state(q,cx,ssp[0],ssp[1],sso) }
      gv_puts("NX-CLAIMS STATE resource=" as *u8)
      gv_puts(sres)
      gv_puts(" state=" as *u8)
      gv_puts(cl_state_name(sv))
      gv_puts(" holder=" as *u8)
      var svh: i64 = 0
      if sv == 1 { svh = 1 }
      if sv == 2 { svh = 1 }
      if svh == 1 { sys_write(1,(q as i64 + sso[0]) as *u8, sso[1]-sso[0]) }
      if svh == 0 { gv_puts("-" as *u8) }
      gv_puts("\n" as *u8)
      sys_exit(0)
      return 0
  }
  if cl_lit_eq(verb,0,vl,"reap" as *u8)==1 {
      if argc < 5 { gv_puts("reap needs <journal> <reaper> <note>\n" as *u8); sys_exit(2); return 2 }
      let reaper: *u8 = argv[3] as *u8
      let rpnote: *u8 = argv[4] as *u8
      let rk: i64 = cl_reap(journal, q, cx, reaper, rpnote)
      if rk >= 0 { sys_exit(0); return 0 }
      sys_exit(1)
      return 1
  }
  if argc < 5 { gv_puts("claim|beat|release need <journal> <resource> <actor> ...\n" as *u8); sys_exit(2); return 2 }
  let res: *u8 = argv[3] as *u8
  let actor: *u8 = argv[4] as *u8
  let sp: *i64 = sys_mmap(16) as *i64
  let st_out: *i64 = sys_mmap(32) as *i64
  var st: i64 = -1
  if cl_res_span_lit(q,cx,res,sp)==1 { st = cl_state(q,cx,sp[0],sp[1],st_out) }
  if cl_lit_eq(verb,0,vl,"claim" as *u8)==1 {
      if argc < 7 { gv_puts("claim needs <journal> <resource> <actor> <ttl_sec> <note>\n" as *u8); sys_exit(2); return 2 }
      let ttlz: *u8 = argv[5] as *u8
      let ttl: i64 = cl_atoi_z(ttlz)
      let note: *u8 = argv[6] as *u8
      // REFUSE, NEVER SILENTLY SHRINK. The estate banked that law in the memfloor incident, and the
      // 2026-07 "ttl ceiling" recorded 86400 for a 7200000 request -- a SILENT clamp, in a CALLER.
      // A ceiling that lives in one caller is bypassable by every other caller, so the bound belongs
      // HERE, in the organ that owns holdership. Loud + exit 2 so a typo is a usage error a human sees,
      // never a lease quietly rounded down and never an 83-day lock nobody notices for 16 days.
      if ttl > CL_TTL_MAX { gv_puts("NX-CLAIMS BAD-TTL-CEILING requested=" as *u8); gv_num(ttl); gv_puts(" max=" as *u8); gv_num(CL_TTL_MAX); gv_puts(" seconds (a lease whose expiry the lessee sets is not a lease)\n" as *u8); sys_exit(2); return 2 }
      if ttl <= 0 { gv_puts("NX-CLAIMS BAD-TTL (must be positive seconds)\n" as *u8); sys_exit(2); return 2 }
      if st == 1 {
          if cl_lit_eq(q,st_out[0],st_out[1],actor)==0 {
              gv_puts("NX-CLAIMS CONTENDED resource=" as *u8)
              gv_puts(res)
              gv_puts(" holder=" as *u8)
              sys_write(1,(q as i64 + st_out[0]) as *u8, st_out[1]-st_out[0])
              gv_puts("\n" as *u8)
              sys_exit(3)
              return 3
          }
      }
      let rc: i64 = cl_append(journal, -1, "CLAIM" as *u8, res, actor, ttl, note)
      if rc==0 { gv_puts("NX-CLAIMS HELD resource=" as *u8); gv_puts(res); gv_puts(" actor=" as *u8); gv_puts(actor); gv_puts(" ttl=" as *u8); gv_num(ttl); gv_puts("\n" as *u8); sys_exit(0); return 0 }
      gv_puts("append FAILED\n" as *u8)
      sys_exit(1)
      return 1
  }
  // beat | release require an un-released claim whose holder == actor (EXPIRED still owned)
  if argc < 6 { gv_puts("beat|release need <journal> <resource> <actor> <note>\n" as *u8); sys_exit(2); return 2 }
  let note2: *u8 = argv[5] as *u8
  var owner_ok: i64 = 0
  if st == 1 { if cl_lit_eq(q,st_out[0],st_out[1],actor)==1 { owner_ok=1 } }
  if st == 2 { if cl_lit_eq(q,st_out[0],st_out[1],actor)==1 { owner_ok=1 } }
  if owner_ok == 0 {
      gv_puts("NX-CLAIMS NOT-HOLDER resource=" as *u8)
      gv_puts(res)
      gv_puts(" actor=" as *u8)
      gv_puts(actor)
      gv_puts("\n" as *u8)
      sys_exit(3)
      return 3
  }
  if cl_lit_eq(verb,0,vl,"beat" as *u8)==1 {
      let rc: i64 = cl_append(journal, -1, "BEAT" as *u8, res, actor, 0, note2)
      if rc==0 { gv_puts("NX-CLAIMS BEAT resource=" as *u8); gv_puts(res); gv_puts("\n" as *u8); sys_exit(0); return 0 }
      gv_puts("append FAILED\n" as *u8)
      sys_exit(1)
      return 1
  }
  if cl_lit_eq(verb,0,vl,"release" as *u8)==1 {
      let rc: i64 = cl_append(journal, -1, "RELEASE" as *u8, res, actor, 0, note2)
      if rc==0 { gv_puts("NX-CLAIMS RELEASED resource=" as *u8); gv_puts(res); gv_puts("\n" as *u8); sys_exit(0); return 0 }
      gv_puts("append FAILED\n" as *u8)
      sys_exit(1)
      return 1
  }
  gv_puts("unknown verb\n" as *u8)
  sys_exit(2)
  return 2
866}
nx_claims.nx source

`nx_claims.nx` source
