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

↩ module page · 490 lines · 35002 B
1// nx_gamebench.nx -- THE GAME CAPABILITY BENCHMARK: can the ecosystem EMIT the games we ingested?
2//
3// RULER = the REAL ingested open-source game corpus (knowledge/store/nx_game_catalog.reg, parsed by
4// nx_game_catalog from the banked bobeff catalog) -- NOT a ruler we invented. Each reference TITLE is a
5// real git repo we can read; each declares the CAPABILITY VECTOR it actually needs. We then score OUR
6// organs per capability and COMPUTE (never assert) how much of each title we could emit from the first
7// byte up. Follows the ecosystem_benchmarks.tsv doctrine (name a real external artifact + its bar) and
8// the nx_benchmark_suite_registry doctrine (self-graded = SUSPECT until an external reference is WIRED).
9//
10// HONEST BY CONSTRUCTION:
11//   - coverage is COMPUTED from the rows (sum of capability scores / max), not a hand-written number;
12//   - a title is WIRED only if we actually read/ran its reference implementation. UNWIRED titles are
13//     reported as SELF-GRADED so a high readiness cannot be quoted as parity;
14//   - the GAP QUEUE is demand-ranked: a missing capability that N titles need outranks one that 1 needs.
15//     That queue IS the build order -- "where are our gaps" answered with arithmetic, not opinion;
16//   - every HAVE names an evidence artifact; nx_gamebench_gate liar-kills any that does not exist on disk.
17// Self-contained (imports only nx_syscalls) so it runs on the NAS as an MCP tool.
18// license_tier: ORIGINAL  expect_exit: 0
19import "nx_syscalls.nx"
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
25
26// ---- capability ids (bit index; keep in sync with cap() registration order) ----
27// 0 render-2d-raster        1 render-3d-raster        2 render-fps-camera      3 procgen-world
28// 4 voxel-world-chunked     5 physics-collision       6 entity-component-sim   7 pathfinding-ai
29// 8 turn-based-tactics      9 rpg-stats-progression  10 loot-item-tables      11 inventory-crafting
30// 12 dialogue-tree-branching 13 sprite-compositor-vn 14 text-render-typography 15 save-load-persistence
31// 16 audio-sfx-music        17 input-realtime        18 ui-menus-hud          19 scripting-content-format
32// 20 networking-multiplayer 21 world-sim-factions    22 character-gen-parametric
33// 23 narrative-plot-generator 24 animation-skeletal   25 asset-pipeline-import
34
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 }
36func onum(o: *u8, at: i64, v: i64) -> i64 {
  var a: i64=at; var m: i64=v
  if m==0 { o[a]=48 as u8; return a+1 }
  if m<0 { o[a]=45 as u8; a=a+1; m=0-m }
  let t: *u8 = sys_mmap(32); var k: i64=0
  while m>0 { t[k]=(48+(m%10)) as u8; m=m/10; k=k+1 }
  var q: i64=k-1
  while q>=0 { o[a]=t[q]; a=a+1; q=q-1 }
  return a
45}
46func bit(i: i64) -> i64 { var v: i64=1; var k: i64=0; while k<i { v=v*2; k=k+1 } return v }
47func hasbit(mask: i64, i: i64) -> i64 { let b: i64=bit(i); if (mask/b)%2==1 { return 1 } return 0 }
48// build a capability mask from up to 10 ids; -1 = unused
49func mk(a: i64,b: i64,c: i64,d: i64,e: i64,f: i64,g: i64,h: i64,i: i64,j: i64) -> i64 {
  var m: i64=0
  if a>=0 { m=m+bit(a) }
  if b>=0 { m=m+bit(b) }
  if c>=0 { m=m+bit(c) }
  if d>=0 { m=m+bit(d) }
  if e>=0 { m=m+bit(e) }
  if f>=0 { m=m+bit(f) }
  if g>=0 { m=m+bit(g) }
  if h>=0 { m=m+bit(h) }
  if i>=0 { m=m+bit(i) }
  if j>=0 { m=m+bit(j) }
  return m
62}
63// mka: add ONE capability id to an existing mask, idempotent (no double-count). Lifts the 10-slot
64// mk() ceiling (seq304/354/359: the fixed arity TRUNCATED title capability vectors -- compose
65// mka over mk for slot 11 and beyond; a repeated id cannot double a bit BY CONSTRUCTION).
66func mka(m: i64, id: i64) -> i64 { if hasbit(m,id)==0 { return m+bit(id) } return m }
67func vstr(v: i64) -> *u8 { if v==2 { return "HAVE" as *u8 } if v==1 { return "PARTIAL" as *u8 } return "GAP" as *u8 }
68
69func main() -> i64 {
  let NC: i64 = 26
  let capv:  *i64 = sys_mmap(NC*8) as *i64      // verdict 2=HAVE 1=PARTIAL 0=GAP
  let capnm: *i64 = sys_mmap(NC*8) as *i64      // name ptr
  let capev: *i64 = sys_mmap(NC*8) as *i64      // evidence artifact ptr (0 = none)
  let capdm: *i64 = sys_mmap(NC*8) as *i64      // demand = how many titles require it
75
  // ---- OUR CAPABILITY VERDICTS (each HAVE names an artifact the gate stats on disk) ----
  capnm[0]="render-2d-raster" as i64;         capv[0]=2; capev[0]="knowledge/nx_game_shmup.png" as i64
  // EVIDENCE REPOINTED 2026-07-29 (seq788 residue): nx_gx4_walk_t0/t3.png are ABSENT on the hub --
  // the eaten row prescribed regenerate-or-demote. render-3d now cites gx31_ctl.png (416KB real
  // sovereign body render, GX-31 lane, stat'd with a non-vacuity floor in the gate); fps-camera
  // was PARTIAL (no banked walk frame) until 2026-07-30 -- see its own row note below.
  capnm[1]="render-3d-raster" as i64;         capv[1]=2; capev[1]="knowledge/gx31_ctl.png" as i64
  // flipped PARTIAL->HAVE 2026-07-30: a real first-person walk frame IS re-banked -- the exact
  // condition the PARTIAL note above named. knowledge/nx_wasm_craft_start.png = the native DDA
  // first-person render emitted by nx_wasm_craft_gate (37/37 GREEN this day, render teeth T19/T23
  // prove 307/552 distinct colors at native res = not a decoy; frame regenerated fresh, md5
  // 381f08c91dfc0c26b122063e7898db8c). The SAME organ ships the live playable FPS voxel game at
  // /world/craft (13/13 gameplay probes, 60fps software / 240fps hw). Floor-checked in the bench gate.
  capnm[2]="render-fps-camera" as i64;        capv[2]=2; capev[2]="knowledge/nx_wasm_craft_start.png" as i64
  // 2026-07-30 (T8 auto-scan catch): the row still pointed at RETIRED nx_procgen_terrain.png while
  // T3 had followed the evidence to nx_worldpipe.png on 07-26 -- board and gate now agree.
  capnm[3]="procgen-world" as i64;            capv[3]=2; capev[3]="knowledge/nx_worldpipe.png" as i64
  // flipped PARTIAL->HAVE 2026-07-30: nx_voxchunk (certified part) = REAL Minecraft-class chunked
  // streaming, not the craft fixed volume: deterministic per-chunk regen from (seed,cx,cz), BOUNDED
  // resident set (200-chunk walk, 8 slots, 192 evictions, never exceeded), dirty chunks flushed
  // through nx_gamesave before slot reuse and reloaded FROM DISK (the chunk-corruption class killed),
  // seam-consistent world access, whole-session gs round-trip. Gate 8/8 GREEN laptop AND hub with
  // IDENTICAL golden sigs (7279648573346569843 / 4040566228174888033); MUTATION-PROVEN (dropping the
  // dirty flush drove T2 RED alone -- edits vanished -- while regen/bounds/anti-vacuity held).
  // WIRED 2026-07-30 SAME DAY: /world/craft now STREAMS -- the arena is a sliding window over
  // unbounded absolute-coord terrain with an 8192-slot edit journal (virgin land from the seed,
  // touched land from history). Craft gate 39/39 (T27 streams-past-old-edge, T38 origin 0->320->0
  // regen-identical, T39 edits survive 320 blocks of departure + journal-full refuses loud),
  // MUTATION-PROVEN (overlay off -> T39 RED alone), LIVE 5/5 browser probe (origin slides + returns
  // on production wasm). v5 saves still load. Residual: shift cost is one in-frame strip regen
  // (perf spike class, incremental-regen rung named).
  capnm[4]="voxel-world-chunked" as i64;      capv[4]=2; capev[4]="knowledge/nx_voxchunk_world.sav" as i64
  // flipped PARTIAL->HAVE 2026-07-29: the 07-27 refusal named the exact bar -- swept/continuous
  // collision, slide-along-surface response, velocity/impulse integration (grid occupancy is a
  // floor, not physics) -- and nx_collide2d + nx_collide2d_gate 8/8 GREEN now deliver precisely
  // those three, each as a tooth: T1 swept (400/tick mover stops AT a 4-unit wall), T2 slide
  // (tangent preserved, normal killed), T3 restitution (~e^2 rebound), plus determinism, 10k-tick
  // boundedness, gs_save transparency (GX-9 law), anti-vacuity, and corner two-wall resolution.
  // MUTATION-PROVEN: substituting a discrete endpoint test tunneled the mover 30k units past the
  // wall -> T1/T5 RED at 4/8, then restored to 8/8. Honest residual: this is 2D swept-AABB;
  // Veloren-class 3D rigid-body remains beyond it (the title vector, not this capability, carries that).
  capnm[5]="physics-collision" as i64;        capv[5]=2; capev[5]="knowledge/nx_collide2d_traj.sav" as i64
  // flipped PARTIAL->HAVE 2026-07-20: nx_entity_store (certified part) + nx_entity_store_gate 9/9 GREEN,
  // mutation-proven (disabling the generation check drove T2 RED at 8/9 = stale handles revalidated).
  capnm[6]="entity-component-sim" as i64;     capv[6]=2; capev[6]="knowledge/nx_entity_world.sav" as i64
  capnm[7]="pathfinding-ai" as i64;           capv[7]=2; capev[7]="knowledge/nx_game_td.png" as i64
  capnm[8]="turn-based-tactics" as i64;       capv[8]=2; capev[8]="knowledge/nx_game_tbs.png" as i64
  // flipped PARTIAL->HAVE 2026-07-20: nx_rpgstats (certified part) + nx_rpgstats_gate 8/8 GREEN,
  // mutation-proven (sequential stacking drove T3 RED at 7/8: fwd=110 vs rev=121).
  capnm[9]="rpg-stats-progression" as i64;    capv[9]=2; capev[9]="knowledge/nx_rpgstats_char.sav" as i64
  // flipped GAP->HAVE 2026-07-20: nx_loottable (certified part) + nx_loottable_gate 8/8 GREEN incl
  // 100k-roll tier reachability + distribution within 25 permil. Mutation-proven (an off-by-one in the
  // cumulative scan drove T1 RED at 5/8: a declared tier became unrollable).
  capnm[10]="loot-item-tables" as i64;        capv[10]=2; capev[10]="knowledge/nx_loottable_item.sav" as i64
  capnm[11]="inventory-crafting" as i64;      capv[11]=2; capev[11]="knowledge/nx_game_city.png" as i64
  capnm[12]="dialogue-tree-branching" as i64; capv[12]=2; capev[12]="knowledge/nx_game_adventure.png" as i64
  // flipped PARTIAL->HAVE 2026-07-29 against the RESEARCHED reference bar (never invent a ruler,
  // applied to the build): Ren'Py layeredimage semantics -- attribute GROUPS with one-call exclusive
  // selection -- plus dissolve transitions. nx_vnsprite + nx_vnsprite_gate 10/10 GREEN: z-order,
  // exact integer alpha + color-key, clip canaries, visible+deterministic expression swap, scene
  // state through gs_save, group exclusivity (T9), dissolve exactness (T10). MUTATION-PROVEN:
  // opaque-key substitute drove T2 RED alone at 9/10 while anti-vacuity held. The old evidence
  // (nx_game_gop.png, 542B) was decoy-class and is replaced by a real composed scene.
  // Honest delta declared in the part: Live2D-class mesh-deformed sprites = the animation axis.
  capnm[13]="sprite-compositor-vn" as i64;    capv[13]=2; capev[13]="knowledge/nx_vnsprite_scene.png" as i64
  capnm[14]="text-render-typography" as i64;  capv[14]=2; capev[14]="knowledge/nx_game_shmup.png" as i64
  // flipped PARTIAL->HAVE 2026-07-20: nx_gamesave (certified part) + nx_gamesave_gate 8/8 GREEN,
  // proven non-vacuous by mutation test (disabling the checksum drove T3 RED at 7/8).
  capnm[15]="save-load-persistence" as i64;   capv[15]=2; capev[15]="knowledge/nx_gamesave_t.sav" as i64
  // flipped PARTIAL->HAVE 2026-07-20: BOTH halves now gated. SFX = nx_game_audio_gate 3/3 (pre-existing,
  // re-run GREEN, knowledge/sfx_demo.wav). MUSIC = nx_gamemusic + nx_gamemusic_gate 8/8, mutation-proven
  // (disabling the saturating mix drove T4 RED at 7/8: 30315 samples past the ceiling).
  capnm[16]="audio-sfx-music" as i64;         capv[16]=2; capev[16]="knowledge/nx_gamemusic.wav" as i64
  // RESTORED PARTIAL->HAVE 2026-07-29 same day: the earlier demotion was evidence-loss (gx4_walk_t3
  // gone from hub), not capability loss. Fresh evidence RE-BANKED: nx_input_abstract_gate (the F1102
  // certified input part) ran 9/9 GREEN ON-HUB -- keyboard + canvas-touch routes drive real actions
  // (touch->key 38/40/37 -> action mapping in the receipt), 4-device reach 1000 permil -- and its
  // full output is the receipt artifact below, held to a byte floor by the bench gate.
  capnm[17]="input-realtime" as i64;          capv[17]=2; capev[17]="knowledge/nx_input_gate_receipt.txt" as i64
  capnm[18]="ui-menus-hud" as i64;            capv[18]=2; capev[18]="knowledge/nx_game_tycoon.png" as i64
  capnm[19]="scripting-content-format" as i64; capv[19]=2; capev[19]="knowledge/nx_game_sandbox.png" as i64
  // flipped PARTIAL->HAVE 2026-07-30: nx_netsync (certified part) composes nx_lockstep/nx_rollback's
  // netcode laws onto the REAL certified sim (nx_worldsim) + nx_gamesave snapshots. Gate 9/9 GREEN
  // ON-HUB, mutation-proven (disabling the lockstep barrier drove T2+T3 RED at 7/9: tick ran to 300
  // on phantom inputs, chaos run diverged -- while anti-vacuity held GREEN). Cross-machine
  // deterministic (laptop ck == hub ck 3800522142965852104). T10 added 2026-07-30 SAME DAY: live
  // socket transport PROVEN -- two PROCESSES over loopback TCP exchange nx_net_chan 8B-BE frames,
  // checksums match OVER THE WIRE on laptop AND hub (gate 10/10). Remaining honest gap: WAN/latency
  // behavior and a head-to-head vs GGPO-class incumbents = UNMEASURED (game_parts.tsv row).
  capnm[20]="networking-multiplayer" as i64;  capv[20]=2; capev[20]="knowledge/nx_netsync_session.sav" as i64
  // flipped GAP->HAVE 2026-07-20: nx_worldsim (certified part) + nx_worldsim_gate 8/8 GREEN,
  // mutation-proven (not debiting the source drove T1 RED at 6/8: wealth minted 9750 -> 95137).
  capnm[21]="world-sim-factions" as i64;      capv[21]=2; capev[21]="knowledge/nx_worldsim_world.sav" as i64
  // flipped PARTIAL->HAVE 2026-08-23. This was the board's LAST gap and the ONLY capability row
  // carrying no reason -- and the measurement says why: the generators were LIVE the whole time
  // (nx_body_gen PROMOTED+REGISTERED 77455 B, nx_body_proc 75120 B) while nx_body_proc_gate,
  // nx_bodygen_gate and nx_charactergen_gate were ALL measured ABSENT by nx_catalog. The
  // capability was never missing; the PROOF BINDING IT TO THIS BOARD was. nx_chargen_param_gate
  // (promoted, registered) closes it 7/7 GREEN: N=9 parameter vectors -- N READ from the
  // reference corpus that DEFINES the validity band (rigfloor_msh n_read), because the generated
  // set must express at least the width of the corpus that defines "valid" -- produce 9 DISTINCT
  // characters, every one IN-BAND on the DERIVED floor (tris/parts read from the conf, restated
  // nowhere), 0 duplicate pairs, tris width 110592, and the same vector reproduces BYTE-IDENTICAL.
  // Mutation-proven by its neg-control: a degenerate sweep (one vector repeated) scores 9/9
  // identical and FAILS distinctness -- an identity generator cannot pass. Its own first live run
  // was RED 6/7: the in-band tooth caught the SAMPLER stepping below tris_min (radial=2 ->
  // tris=3072 < 4033), fixed by rounding each end INTO the closed band, never by widening it.
  capnm[22]="character-gen-parametric" as i64; capv[22]=2; capev[22]="knowledge/nx_procgen_human.png" as i64
  // flipped GAP->HAVE 2026-07-20: nx_plotgen (certified part) emits graphs the EXISTING nx_story_vm runs;
  // gate 8/8 GREEN incl 200/200 solvability walked via real sv_choose. Mutation-proven (gating the spine
  // drove T2 RED at 6/8: 200/200 plots UNWINNABLE).
  capnm[23]="narrative-plot-generator" as i64; capv[23]=2; capev[23]="knowledge/nx_plotgen_story.sav" as i64
  capnm[24]="animation-skeletal" as i64;      capv[24]=2; capev[24]="knowledge/nishi_being_walk.glb" as i64
  // seq813 CLOSED 2026-07-29: the old nx_bunny.png was a DECOY (empty render written while the mesh
  // data was absent on the hub; banked as .decoy-bak). REGENERATED FOR REAL the same day: bunny.obj
  // (2.4MB Stanford mesh) synced to knowledge/stdassets/, nx_bunny_gate run ON-HUB GREEN -- EXACT
  // canonical 35947v/69451t, filled=43979, deterministic -- render now 215551B and the bench gate
  // holds it to a non-vacuity byte floor, so a blank can never satisfy this HAVE again.
  capnm[25]="asset-pipeline-import" as i64;   capv[25]=2; capev[25]="knowledge/nx_bunny.png" as i64
195
  // ---- REFERENCE TITLES (rows 0..9 are REAL repos from the ingested corpus; 10..11 are the operator's
  // commercial north-star OUTPUTS, explicitly NOT in the corpus -- marked corpus=0 so they never inflate
  // the corpus number).
  // wired: 0 = self-graded only; 1 = WIRED-PARTS-LOOP (a playable genre loop composed from the certified
  //   parts, per-capability exercise MEASURED by the title's wiring gate and banked as a bitmask in the
  //   wiring artifact payload[0] -- nx_gamebench_gate cross-checks artifact vs board); 2 = reference
  //   implementation run head-to-head (still ZERO of 12 -- wiring is composition proof, NOT parity).
  // SCORING for wired titles: a required capability the wiring did NOT exercise counts at most PARTIAL --
  //   presence elsewhere in the ecosystem is no longer enough once a title is on the measured standard.
  //   That is why wired readiness DROPS below the self-graded 1000s: the drop is the finding.
  let NT: i64 = 12
  let ttnm: *i64 = sys_mmap(NT*8) as *i64
  let ttgn: *i64 = sys_mmap(NT*8) as *i64
  let ttrp: *i64 = sys_mmap(NT*8) as *i64
  let ttmk: *i64 = sys_mmap(NT*8) as *i64
  let ttwr: *i64 = sys_mmap(NT*8) as *i64
  let ttcp: *i64 = sys_mmap(NT*8) as *i64      // 1 = in the ingested corpus
  let ttwm: *i64 = sys_mmap(NT*8) as *i64      // wired: exercised-capability bitmask (from the wiring gate)
  let ttwa: *i64 = sys_mmap(NT*8) as *i64      // wired: wiring artifact path (0 = none)
  var zi: i64 = 0
  while zi < NT { ttwm[zi]=0; ttwa[zi]=0; zi=zi+1 }
217
  // seq304/354/359 FIX 2026-07-29: every real title imports assets, but the 10-slot mk() ceiling had
  // squeezed asset-pipeline-import (bit 25) out of EVERY vector (titles_needing=0 = a truncated ruler).
  // mka() lifts the ceiling; bit 25 is now declared by all 12 titles, so its demand is finally counted.
  ttnm[0]="Doom" as i64; ttgn[0]="First-Person games" as i64; ttrp[0]="https://github.com/id-Software/DOOM" as i64
  ttmk[0]=mka(mk(2,0,6,7,16,17,18,15,19,5),25); ttwr[0]=0; ttcp[0]=1
  ttnm[1]="OpenXcom" as i64; ttgn[1]="Turn-Based strategies" as i64; ttrp[1]="https://github.com/OpenXcom/OpenXcom" as i64
  ttmk[1]=mka(mk(8,9,7,18,15,19,6,16,14,0),25); ttwr[1]=0; ttcp[1]=1
  ttnm[2]="Open Diablo II" as i64; ttgn[2]="Role-Playing games" as i64; ttrp[2]="https://github.com/OpenDiablo2/OpenDiablo2" as i64
  // WIRED 2026-07-20: nx_wire_diablo2_gate 9/9 GREEN, mutation-proven (severing the kill->loot wiring
  // drove the loot tooth RED at 6/9 while the game still played to a win). Exercised: procgen(3),
  // loot(10), rpgstats(9), entity(6), music(16), save(15). NOT exercised: pathfind(7), render-2d(0),
  // input(17), ui(18) -> those score at most PARTIAL for this title now.
  ttmk[2]=mka(mk(10,9,3,7,6,0,16,15,17,18),25); ttwr[2]=1; ttcp[2]=1
  // 2026-08-23 WIRING-QUEUE DRAIN: gate now 14/14 GREEN -- pathfind(7) exercised as click-to-move
  // (pf_astar drives every approach, validated in-loop, 0 violations), input(17) as the F1102
  // edge-caused equip confirm (control run with the script disabled equips NOTHING), and
  // asset-import(25) as the victory-screen render of the canonical Stanford mesh. Exercised =
  // the FULL required vector. Mask is MEASURED by the wiring gate; this constant mirrors it.
  ttwm[2]=K_MAGIC_34047689; ttwa[2]="knowledge/nx_wire_diablo2.sav" as i64
  ttnm[3]="Cataclysm: Dark Days Ahead" as i64; ttgn[3]="Roguelikes" as i64; ttrp[3]="https://github.com/CleverRaven/Cataclysm-DDA" as i64
  ttmk[3]=mka(mk(11,21,3,6,9,15,14,18,7,19),25); ttwr[3]=0; ttcp[3]=1
  ttnm[4]="Veloren" as i64; ttgn[4]="Role-Playing games" as i64; ttrp[4]="https://github.com/veloren/veloren" as i64
  ttmk[4]=mka(mk(4,3,1,20,6,9,24,5,11,16),25); ttwr[4]=0; ttcp[4]=1
  ttnm[5]="Freeciv" as i64; ttgn[5]="Turn-Based strategies" as i64; ttrp[5]="https://github.com/freeciv/freeciv" as i64
  ttmk[5]=mka(mk(8,21,7,18,15,20,19,14,0,-1),25); ttwr[5]=0; ttcp[5]=1
  ttnm[6]="The Battle for Wesnoth" as i64; ttgn[6]="Turn-Based strategies" as i64; ttrp[6]="https://github.com/wesnoth/wesnoth" as i64
  ttmk[6]=mka(mk(8,7,12,18,15,19,16,14,0,-1),25); ttwr[6]=0; ttcp[6]=1
  ttnm[7]="NetHack" as i64; ttgn[7]="Roguelikes" as i64; ttrp[7]="https://github.com/NetHack/NetHack" as i64
  // WIRED 2026-07-20: nx_wire_nethack_gate 9/9 GREEN, mutation-proven (a save that "forgets a field"
  // drove the transparency tooth RED at 8/9 with 26/26 checksum mismatches while anti-vacuity held).
  // 2026-08-23 WIRING-QUEUE DRAIN: gate now 12/12 GREEN -- text-render(14) exercised as the
  // state-bound status line with EXACT font-table-derived ink accounting, and asset-import(25)
  // as the victory-screen render of the canonical Stanford mesh through the certified OBJ chain.
  // Exercised = the FULL required vector: procgen(3), entity(6), pathfind(7), rpgstats(9),
  // inventory(11), text-render(14), save(15), ui(18), asset-import(25). Mask is MEASURED by the
  // wiring gate and banked in the artifact; this constant only mirrors it for the cross-check.
  ttmk[7]=mka(mk(3,11,9,6,14,15,7,18,-1,-1),25); ttwr[7]=1; ttcp[7]=1
  ttwm[7]=K_MAGIC_33868488; ttwa[7]="knowledge/nx_wire_nethack.sav" as i64
  ttnm[8]="Dungeon Crawl Stone Soup" as i64; ttgn[8]="Roguelikes" as i64; ttrp[8]="https://github.com/crawl/crawl" as i64
  // WIRED 2026-08-23 (4th title): nx_wire_crawl_gate 13/13 -- NetHack's proven roguelike loop
  // (procgen/entity/pathfind/rpgstats/inventory/text-render/save/ui/asset-import) PLUS the loot
  // part exactly as the d2 wiring exercises it: every kill rolls lt_roll, audited in-loop, and
  // tier>=2 drops are CAUSAL (they feed the ration ledger, which the conservation tooth then
  // balances WITH the inflow). Exercised = the FULL required vector: mask 33868488+1024=33869512.
  // Mask is MEASURED by the wiring gate into the artifact; this constant only mirrors it.
  ttmk[8]=mka(mk(3,10,9,11,6,14,15,7,18,-1),25); ttwr[8]=1; ttcp[8]=1
  ttwm[8]=K_MAGIC_33869512; ttwa[8]="knowledge/nx_wire_crawl.sav" as i64
  ttnm[9]="Endless Sky" as i64; ttgn[9]="Adventure games" as i64; ttrp[9]="https://github.com/endless-sky/endless-sky" as i64
  // WIRED 2026-07-20: nx_wire_endlesssky_gate 9/9 GREEN, mutation-proven (MINTING a mission reward
  // instead of transferring it drove the conservation tooth RED at 8/9 -- 1950 phantom credits caught
  // exactly -- while the game still won). Exercised: worldsim(21), dialogue(12), content-format(19),
  // rpgstats(9), music(16), save(15). NOT exercised: render-2d(0), ui(18) -> at most PARTIAL now.
  ttmk[9]=mka(mk(21,12,0,15,18,19,16,9,-1,-1),25); ttwr[9]=1; ttcp[9]=1
  // 2026-08-23 WIRING-QUEUE DRAIN: asset-import(25) exercised as the victory-hangar render of
  // the canonical Stanford mesh through the certified OBJ chain -- gate 12/12 GREEN, mask MEASURED.
  ttwm[9]=K_MAGIC_36540929; ttwa[9]="knowledge/nx_wire_endlesssky.sav" as i64
  // north-star OUTPUTS named by the operator -- commercial, NOT ingested, NOT in the corpus average
  ttnm[10]="Monster Girl Island (north-star output)" as i64; ttgn[10]="Visual Novel / 3D VN" as i64
  ttrp[10]="commercial-steam-title-NOT-in-corpus" as i64
  ttmk[10]=mka(mk(12,13,22,24,1,16,15,18,23,-1),25); ttwr[10]=0; ttcp[10]=0
  ttnm[11]="Strive: Conquest (north-star output)" as i64; ttgn[11]="World-sim VN / management" as i64
  ttrp[11]="commercial-title-NOT-in-corpus" as i64
  ttmk[11]=mka(mk(21,9,12,11,23,15,18,14,13,-1),25); ttwr[11]=0; ttcp[11]=0
281
  // ---- COMPUTE: demand per capability, readiness per title, corpus mean ----
  var ci: i64 = 0
  while ci < NC { capdm[ci]=0; ci=ci+1 }
  let trd: *i64 = sys_mmap(NT*8) as *i64
  let texc: *i64 = sys_mmap(NT*8) as *i64      // caps exercised by the wiring (wired titles only)
  let treq: *i64 = sys_mmap(NT*8) as *i64      // caps required
  var ti: i64 = 0
  var corpus_sum: i64 = 0; var corpus_n: i64 = 0
  var wired_n: i64 = 0
  var refrun_n: i64 = 0
  while ti < NT {
      var got: i64 = 0; var need: i64 = 0; var exc: i64 = 0
      ci = 0
      while ci < NC {
          if hasbit(ttmk[ti], ci)==1 {
              need = need + 1
              capdm[ci] = capdm[ci] + 1
              var sc: i64 = capv[ci]
              if ttwr[ti]>=1 {
                  // measured standard: a capability this title's wiring did NOT exercise scores
                  // at most PARTIAL, however good it looks elsewhere on the board.
                  if hasbit(ttwm[ti], ci)==1 { exc = exc + 1 }
                  if hasbit(ttwm[ti], ci)==0 { if sc>1 { sc=1 } }
              }
              got = got + sc
          }
          ci = ci + 1
      }
      var r: i64 = 0
      if need > 0 { r = (got*1000)/(need*2) }
      trd[ti] = r
      texc[ti] = exc
      treq[ti] = need
      if ttcp[ti]==1 { corpus_sum = corpus_sum + r; corpus_n = corpus_n + 1 }
      if ttwr[ti]>=1 { wired_n = wired_n + 1 }
      if ttwr[ti]==2 { refrun_n = refrun_n + 1 }
      ti = ti + 1
  }
  var corpus_mean: i64 = 0
  if corpus_n > 0 { corpus_mean = corpus_sum / corpus_n }
322
  // capability coverage (all caps, unweighted) + demand-weighted coverage
  var csum: i64 = 0; var dsum: i64 = 0; var dmax: i64 = 0
  var nhave: i64 = 0; var npart: i64 = 0; var ngap: i64 = 0
  ci = 0
  while ci < NC {
      csum = csum + capv[ci]
      dsum = dsum + capv[ci]*capdm[ci]
      dmax = dmax + 2*capdm[ci]
      if capv[ci]==2 { nhave=nhave+1 }
      if capv[ci]==1 { npart=npart+1 }
      if capv[ci]==0 { ngap=ngap+1 }
      ci = ci + 1
  }
  let cap_cov: i64 = (csum*1000)/(NC*2)
  var dem_cov: i64 = 0
  if dmax > 0 { dem_cov = (dsum*1000)/dmax }
339
  // ---- EMIT JSON ----
  let jb: *u8 = sys_mmap(K_MAGIC_262144)
  var j: i64 = 0
  j = ocat(jb, j, "{\x22v\x22:1,\x22domain\x22:\x22gamebench\x22,\x22title\x22:\x22Game Capability Benchmark -- can we EMIT the games we ingested?\x22" as *u8)
  j = ocat(jb, j, ",\x22ruler\x22:{\x22source\x22:\x22knowledge/store/nx_game_catalog.reg (parsed by nx_game_catalog from the banked bobeff open-source-games catalog)\x22" as *u8)
  j = ocat(jb, j, ",\x22corpus_rows\x22:144,\x22corpus_genres\x22:17,\x22doctrine\x22:\x22never invent a ruler -- every reference title is a real readable git repo\x22}" as *u8)
346
  // capabilities
  j = ocat(jb, j, ",\x22capabilities\x22:[" as *u8)
  ci = 0
  while ci < NC {
      if ci>0 { j = ocat(jb, j, "," as *u8) }
      j = ocat(jb, j, "{\x22cap\x22:\x22" as *u8); j = ocat(jb, j, capnm[ci] as *u8)
      j = ocat(jb, j, "\x22,\x22verdict\x22:\x22" as *u8); j = ocat(jb, j, vstr(capv[ci]))
      j = ocat(jb, j, "\x22,\x22titles_needing\x22:" as *u8); j = onum(jb, j, capdm[ci])
      j = ocat(jb, j, ",\x22artifact\x22:\x22" as *u8)
      if capev[ci]!=0 { j = ocat(jb, j, capev[ci] as *u8) }
      j = ocat(jb, j, "\x22}" as *u8)
      ci = ci + 1
  }
  j = ocat(jb, j, "]" as *u8)
361
  // titles
  j = ocat(jb, j, ",\x22titles\x22:[" as *u8)
  ti = 0
  while ti < NT {
      if ti>0 { j = ocat(jb, j, "," as *u8) }
      j = ocat(jb, j, "{\x22title\x22:\x22" as *u8); j = ocat(jb, j, ttnm[ti] as *u8)
      j = ocat(jb, j, "\x22,\x22genre\x22:\x22" as *u8); j = ocat(jb, j, ttgn[ti] as *u8)
      j = ocat(jb, j, "\x22,\x22repo\x22:\x22" as *u8); j = ocat(jb, j, ttrp[ti] as *u8)
      j = ocat(jb, j, "\x22,\x22in_corpus\x22:" as *u8); j = onum(jb, j, ttcp[ti])
      j = ocat(jb, j, ",\x22emit_readiness_permil\x22:" as *u8); j = onum(jb, j, trd[ti])
      j = ocat(jb, j, ",\x22grading\x22:\x22" as *u8)
      if ttwr[ti]==2 { j = ocat(jb, j, "WIRED-reference-run" as *u8) }
      if ttwr[ti]==1 { j = ocat(jb, j, "WIRED-PARTS-LOOP-MEASURED" as *u8) }
      if ttwr[ti]==0 { j = ocat(jb, j, "SELF-GRADED-SUSPECT" as *u8) }
      j = ocat(jb, j, "\x22" as *u8)
      if ttwr[ti]>=1 {
          j = ocat(jb, j, ",\x22caps_exercised\x22:" as *u8); j = onum(jb, j, texc[ti])
          j = ocat(jb, j, ",\x22caps_required\x22:" as *u8); j = onum(jb, j, treq[ti])
          j = ocat(jb, j, ",\x22wiring_artifact\x22:\x22" as *u8)
          if ttwa[ti]!=0 { j = ocat(jb, j, ttwa[ti] as *u8) }
          j = ocat(jb, j, "\x22" as *u8)
      }
      j = ocat(jb, j, "}" as *u8)
      ti = ti + 1
  }
  j = ocat(jb, j, "]" as *u8)
388
  // demand-ranked gap queue = the build order
  j = ocat(jb, j, ",\x22gap_queue\x22:[" as *u8)
  let used: *i64 = sys_mmap(NC*8) as *i64
  ci = 0
  while ci < NC { used[ci]=0; ci=ci+1 }
  var emitted: i64 = 0
  var rounds: i64 = 0
  while rounds < NC {
      var best: i64 = 0-1; var bestscore: i64 = 0-1
      ci = 0
      while ci < NC {
          if used[ci]==0 {
              if capv[ci] < 2 {
                  // rank: demand first, then severity (GAP outranks PARTIAL at equal demand)
                  var sc: i64 = capdm[ci]*10
                  if capv[ci]==0 { sc = sc + 5 }
                  if sc > bestscore { bestscore = sc; best = ci }
              }
          }
          ci = ci + 1
      }
      if best >= 0 {
          used[best] = 1
          if emitted>0 { j = ocat(jb, j, "," as *u8) }
          j = ocat(jb, j, "{\x22rank\x22:" as *u8); j = onum(jb, j, emitted+1)
          j = ocat(jb, j, ",\x22cap\x22:\x22" as *u8); j = ocat(jb, j, capnm[best] as *u8)
          j = ocat(jb, j, "\x22,\x22verdict\x22:\x22" as *u8); j = ocat(jb, j, vstr(capv[best]))
          j = ocat(jb, j, "\x22,\x22titles_blocked\x22:" as *u8); j = onum(jb, j, capdm[best])
          j = ocat(jb, j, "}" as *u8)
          emitted = emitted + 1
      }
      rounds = rounds + 1
  }
  j = ocat(jb, j, "]" as *u8)
423
  // WIRING QUEUE (new with the measured standard): for every capability, how many WIRED titles
  // require it but did NOT exercise it in their loop. This is the demand-ranked list of what to wire
  // NEXT -- computed, never asserted. (A cap can be HAVE globally and still top this queue.)
  let wdm: *i64 = sys_mmap(NC*8) as *i64
  ci = 0
  while ci < NC { wdm[ci]=0; ci=ci+1 }
  ti = 0
  while ti < NT {
      if ttwr[ti]>=1 {
          ci = 0
          while ci < NC {
              if hasbit(ttmk[ti], ci)==1 { if hasbit(ttwm[ti], ci)==0 { wdm[ci]=wdm[ci]+1 } }
              ci = ci + 1
          }
      }
      ti = ti + 1
  }
  j = ocat(jb, j, ",\x22wiring_queue\x22:[" as *u8)
  let wused: *i64 = sys_mmap(NC*8) as *i64
  ci = 0
  while ci < NC { wused[ci]=0; ci=ci+1 }
  var wemit: i64 = 0
  var wrounds: i64 = 0
  while wrounds < NC {
      var wbest: i64 = 0-1
      var wbsc: i64 = 0
      ci = 0
      while ci < NC {
          if wused[ci]==0 { if wdm[ci]>wbsc { wbsc=wdm[ci]; wbest=ci } }
          ci = ci + 1
      }
      if wbest >= 0 {
          wused[wbest]=1
          if wemit>0 { j = ocat(jb, j, "," as *u8) }
          j = ocat(jb, j, "{\x22rank\x22:" as *u8); j = onum(jb, j, wemit+1)
          j = ocat(jb, j, ",\x22cap\x22:\x22" as *u8); j = ocat(jb, j, capnm[wbest] as *u8)
          j = ocat(jb, j, "\x22,\x22wired_titles_not_exercising\x22:" as *u8); j = onum(jb, j, wdm[wbest])
          j = ocat(jb, j, "}" as *u8)
          wemit = wemit + 1
      }
      wrounds = wrounds + 1
  }
  j = ocat(jb, j, "]" as *u8)
467
  // computed scores
  j = ocat(jb, j, ",\x22capability_coverage_permil\x22:" as *u8); j = onum(jb, j, cap_cov)
  j = ocat(jb, j, ",\x22demand_weighted_coverage_permil\x22:" as *u8); j = onum(jb, j, dem_cov)
  j = ocat(jb, j, ",\x22corpus_emit_readiness_permil\x22:" as *u8); j = onum(jb, j, corpus_mean)
  j = ocat(jb, j, ",\x22have\x22:" as *u8); j = onum(jb, j, nhave)
  j = ocat(jb, j, ",\x22partial\x22:" as *u8); j = onum(jb, j, npart)
  j = ocat(jb, j, ",\x22gap\x22:" as *u8); j = onum(jb, j, ngap)
  j = ocat(jb, j, ",\x22capabilities_total\x22:" as *u8); j = onum(jb, j, NC)
  j = ocat(jb, j, ",\x22titles_total\x22:" as *u8); j = onum(jb, j, NT)
  j = ocat(jb, j, ",\x22titles_wired\x22:" as *u8); j = onum(jb, j, wired_n)
  j = ocat(jb, j, ",\x22titles_reference_run\x22:" as *u8); j = onum(jb, j, refrun_n)
479
  // honesty block -- the deflation, stated in-band
  j = ocat(jb, j, ",\x22honest\x22:\x22Two grading standards now coexist. WIRED-PARTS-LOOP-MEASURED titles ran an actual playable genre loop composed from the certified parts; each exercised capability is proven by a gate tooth (12/14/12/13-tooth gates, all GREEN, mutation-proven) and banked as a bitmask in the wiring artifact, and every required-but-unexercised capability scores at most PARTIAL -- which is why wired readiness DROPPED below the self-graded 1000s (the drop is the finding, not a regression). Unwired titles remain SELF-GRADED and SUSPECT: presence of a part elsewhere is NOT proof it composes for that title. And wiring is still NOT parity: 0 of 12 reference implementations have been run head-to-head.\x22" as *u8)
  j = ocat(jb, j, ",\x22ruler_gaps\x22:[\x22the ingested corpus still has NO visual-novel genre rows: adult-VN reference titles are now measured on the separate nx_vsbench adult board, but the nx_game_catalog.reg VN ingest itself remains open (seq1252, residual of seq295)\x22,\x22no Minecraft-class chunked-voxel reference in the corpus (Veloren is the nearest); Minetest/Luanti is absent\x22,\x22corpus is 144 parsed rows over 17 genres, not the full upstream catalog\x22]" as *u8)
  j = ocat(jb, j, ",\x22north_star\x22:{\x22outputs\x22:[\x22Monster Girl Island -- 3D VN: parametric characters + branching narrative + skeletal animation\x22,\x22Strive: Conquest -- persistent faction/economy world-sim wrapped in a VN shell\x22],\x22recombinator\x22:\x22emit a game by COMPOSING certified parts (knowledge/registry/game_parts.tsv doctrine: build each part to exceed ONCE, compose forever) -- the atlas pattern applied to games\x22}" as *u8)
  j = ocat(jb, j, ",\x22method\x22:\x22verdict scores HAVE=2 PARTIAL=1 GAP=0. title readiness = sum(scores of required caps)*1000/(2*count). demand-weighted coverage weights each capability by how many titles need it. gap_queue ranks by titles_blocked, GAP breaking ties above PARTIAL.\x22" as *u8)
  j = ocat(jb, j, ",\x22gate\x22:\x22nx_gamebench_gate (liar-kill: every HAVE must name an artifact that exists on disk; a fabricated capability must score GAP)\x22}" as *u8)
486
  sys_write(1, jb, j)
  sys_write(1, "\n" as *u8, 1)
  return 0
490}
nx_gamebench.nx source

`nx_gamebench.nx` source
