code wiki / _hdl_build / nx_gamebench.nx

nx_gamebench.nx

buildroot/runtime/_hdl_build/nx_gamebench.nx

35002 B490 linesdepth 2pulls 2 transitivereach 0 importersview sourcekind bench
docsdependenciesstructsconstsfunctions

about

nx_gamebench.nx -- THE GAME CAPABILITY BENCHMARK: can the ecosystem EMIT the games we ingested? RULER = the REAL ingested open-source game corpus (knowledge/store/nx_game_catalog.reg, parsed by nx_game_catalog from the banked bobeff catalog) -- NOT a ruler we invented. Each reference TITLE is a real git repo we can read; each declares the CAPABILITY VECTOR it actually needs. We then score OUR organs per capability and COMPUTE (never assert) how much of each title we could emit from the first byte up. Follows the ecosystem_benchmarks.tsv doctrine (name a real external artifact + its bar) and the nx_benchmark_suite_registry doctrine (self-graded = SUSPECT until an external reference is WIRED). HONEST BY CONSTRUCTION: - coverage is COMPUTED from the rows (sum of capability scores / max), not a hand-written number; - a title is WIRED only if we actually read/ran its reference implementation. UNWIRED titles are reported as SELF-GRADED so a high readiness cannot be quoted as parity; - the GAP QUEUE is demand-ranked: a missing capability that N titles need outranks one that 1 needs. That queue IS the build order -- "where are our gaps" answered with arithmetic, not opinion; - every HAVE names an evidence artifact; nx_gamebench_gate liar-kills any that does not exist on disk. Self-contained (imports only nx_syscalls) so it runs on the NAS as an MCP tool. license_tier: ORIGINAL expect_exit: 0

dependencies 1 imports · 0 importers

nx_syscalls.nx nx_gamebench.nx

imports: nx_syscalls.nx

imported by: nobody (leaf or entry point)

call flow from main pre-order; caps 40 nodes / depth 6 declared; ↻ = already shown

main sys_mmap nxa_die sys_write sys_exit nxa_lock_take nxa_lock_addr sys_write ↻ nxa_lock_give nxa_lock_addr ↻ nxa_report_overrun sys_write ↻ nxa_dump_printable sys_write ↻ nxa_dump_sizes sys_write ↻ mka hasbit bit bit ↻ mk bit ↻ hasbit ↻ ocat vstr onum sys_mmap ↻ sys_write ↻

structs

none

consts

20const K_MAGIC_34047689: i64 = 34047689
21const K_MAGIC_33868488: i64 = 33868488
22const K_MAGIC_36540929: i64 = 36540929
23const K_MAGIC_33869512: i64 = 33869512
24const K_MAGIC_262144: i64 = 262144

functions

35func ocat(o: *u8, at: i64, s: *u8) -> i64 { var i: i64=0; var a: i64=at; while s[i]!=(0 as u8){o[a]=s[i]; a=a+1; i=i+1} return a }
called by 1: main
36func onum(o: *u8, at: i64, v: i64) -> i64
called by 1: main calls 1: sys_mmap
46func bit(i: i64) -> i64 { var v: i64=1; var k: i64=0; while k<i { v=v*2; k=k+1 } return v }
called by 3: hasbitmkmka
47func hasbit(mask: i64, i: i64) -> i64 { let b: i64=bit(i); if (mask/b)%2==1 { return 1 } return 0 }
called by 2: mkamain calls 1: bit
49func mk(a: i64,b: i64,c: i64,d: i64,e: i64,f: i64,g: i64,h: i64,i: i64,j: i64) -> i64
called by 1: main calls 1: bit
66func mka(m: i64, id: i64) -> i64 { if hasbit(m,id)==0 { return m+bit(id) } return m }
called by 1: main calls 2: hasbitbit
67func vstr(v: i64) -> *u8 { if v==2 { return "HAVE" as *u8 } if v==1 { return "PARTIAL" as *u8 } return "GAP" as *u8 }
called by 1: main
69func main() -> i64