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

↩ module page · 319 lines · 26431 B
1// nx_cdmap_gate.nx -- referee for nx_cdmap_lib (2026-09-15): the centrality/distinctiveness ruler on planted tables
2// with HAND-WORKED answers (each worked in the comment above its teeth), the tie law, absent and identical players,
3// the code and number parsers, the AXIS REGISTRY (names, permil values, the momentum plot scale), the VIEW conf
4// (cut and cube rows, defaults, an unknown axis REFUSED by name), the ISOMETRIC projection pinned at its corners,
5// and the day spine written to a /tmp fixture dir and read back (never a production path -- the gate-fixture law;
6// the fixture is truncated at SETUP, so a crashed run leaves nothing to misread).
7// Every numeric tooth goes through gv_check_eq so the value published and the value tested are ONE expression.
8// GREEN iff every tooth passes; the exit code carries gv_verdict's verdict. license_tier: ORIGINAL
9import "nx_cdmap_lib.nx"
10import "nx_syscalls.nx"
11import "nx_gate_verdict.nx"
12
13const G_DIR: *u8 = "/tmp/nx_cdmap_gate/"
14const G_DOM: *u8 = "cdgate"
15const G_DOM_NOFILE: *u8 = "cdgate_nofile"
16const G_DOM_BAD: *u8 = "cdgate_bad"
17const G_EPOCH_DAY1: i64 = 1789430400      // 2026-09-15 00:00:00 UTC: a FIXED clock so the fixture reproduces
18const G_HOUR: i64 = 3600
19const G_P2: i64 = 2
20const G_R3: i64 = 3
21const G_R1: i64 = 1
22const G_R2: i64 = 2
23const G_MODE_644: i64 = 420
24const G_NAME_A: *u8 = "A"
25const G_NAME_B: *u8 = "B"
26const G_NAME_Z: *u8 = "Z"
27const G_C_DAY2: i64 = 900
28const G_UNKNOWN_CODE: i64 = 9
29const G_UNKNOWN_STATE: i64 = 7
30const G_ISO_OX: i64 = 380
31const G_ISO_OY: i64 = 300
32const G_ISO_UNIT: i64 = 220
33const G_VIEW_ROWS: *u8 = "# planted view conf\ncut|breadth|depth\ncube|centrality|momentum|breadth\n"
34const G_VIEW_BAD: *u8 = "cut|centrality|bogus\n"
35// THE NOTES fixture: two good rows (a player anchor, a point anchor), three refused (unknown player, malformed anchor,
36// a 121-byte text over CD_NOTE_TEXT_MAX), a comment-free file so the tag test is the only filter
37const G_NOTES_CAP: i64 = 8
38const G_NOTE1_TEXT: *u8 = "Holds every row the field holds"
39const G_LONG_WORD: *u8 = "Distinctivene"
40const G_WRAP_12: i64 = 12
41const G_WRAP_5: i64 = 5
42const G_WRAP_4: i64 = 4
43const G_WRAP_MAX: i64 = 8
44const G_NOTE_ROWS: *u8 = "note|n1|A|Holds every row the field holds|2026-09-15|seat\nnote|n2|at:250,750|Empty corner nobody serves|2026-09-15|seat\nnote|n3|Zed|unknown player|2026-09-15|seat\nnote|n4|at:12|malformed anchor|2026-09-15|seat\nnote|n5|B|xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx|2026-09-15|seat\n"
45
46func g_names(a: *u8, b: *u8) -> *i64 { let n: *i64 = sys_mmap(G_P2 * CD_I64_BYTES) as *i64; n[0] = a as i64; n[1] = b as i64; return n }
47func g_fresh_spine() -> i64 {
  sys_mkdir(G_DIR, CD_DIR_MODE)
  let path: *u8 = sys_mmap(CD_PATH_CAP)
  cd_spine_path(G_DIR, G_DOM, path)
  let fd: i64 = sys_openat_wr(path, G_MODE_644)
  if fd >= 0 { sys_close(fd); return 1 }
  return 0
54}
55func g_read_spine(nb: *i64) -> *u8 { let path: *u8 = sys_mmap(CD_PATH_CAP); cd_spine_path(G_DIR, G_DOM, path); nb[0] = 0; return sys_read_file(path, nb) }
56func g_write_view(dom: *u8, body: *u8) -> i64 {
  sys_mkdir(G_DIR, CD_DIR_MODE)
  let path: *u8 = sys_mmap(CD_PATH_CAP)
  cd_view_path(G_DIR, dom, path)
  let fd: i64 = sys_openat_wr(path, G_MODE_644)
  if fd < 0 { return 0 }
  sys_write(fd, body, cd_slen(body))
  sys_close(fd)
  return 1
65}
66func g_unlink_view(dom: *u8) -> i64 { let path: *u8 = sys_mmap(CD_PATH_CAP); cd_view_path(G_DIR, dom, path); sys_unlinkat(path); return 0 }
67func g_write_notes(dom: *u8, body: *u8) -> i64 {
  sys_mkdir(G_DIR, CD_DIR_MODE)
  let path: *u8 = sys_mmap(CD_PATH_CAP)
  cd_notes_path(G_DIR, dom, path)
  let fd: i64 = sys_openat_wr(path, G_MODE_644)
  if fd < 0 { return 0 }
  sys_write(fd, body, cd_slen(body))
  sys_close(fd)
  return 1
76}
77func g_unlink_notes(dom: *u8) -> i64 { let path: *u8 = sys_mmap(CD_PATH_CAP); cd_notes_path(G_DIR, dom, path); sys_unlinkat(path); return 0 }
78func g_streq(a: *u8, b: *u8) -> i64 { return cd_name_eq_n(a, b, cd_slen(b)) }
79
80func main() -> i64 {
  let ctr: *i64 = gv_ctr()
  gv_head("=== NX-CDMAP GATE -- the centrality/distinctiveness ruler, the axis registry, the views, the projection and the day spine, on planted tables ===" as *u8)
  // T1/T2 worked by hand: A holds rows 0,1,2 (Yes); B holds row 0 (Yes).
  //   hc = [2,1,1] -> mass 4.  C(A) = 1000*(2+1+1)/4 = 1000.  C(B) = 1000*2/4 = 500.
  //   lead(A) = (2-0)+(2-0) = 4 over held 3, rivals 1 -> D(A) = 1000*4/(3*1*3) = 444.  D(B) = 0 (matched on row 0).
  let pts: *i64 = sys_mmap(G_P2 * G_R3 * CD_I64_BYTES) as *i64
  pts[0] = CD_PTS_YES; pts[1] = CD_PTS_YES; pts[2] = CD_PTS_YES
  pts[3] = CD_PTS_YES; pts[4] = CD_PTS_NO; pts[5] = CD_PTS_NO
  let out: *i64 = sys_mmap(G_P2 * CD_W * CD_I64_BYTES) as *i64
  let mass: i64 = cd_compute(pts, G_P2, G_R3, out)
  gv_check_eq("T1-feature-mass-sums-presence" as *u8, mass, 4, ctr)
  gv_check_eq("T1a-centrality-full-holder-reads-1000" as *u8, out[0 * CD_W + CD_R_C], 1000, ctr)
  gv_check_eq("T1b-centrality-common-row-only-reads-500" as *u8, out[1 * CD_W + CD_R_C], 500, ctr)
  gv_check_eq("T2-distinctiveness-two-unmatched-rows-reads-444" as *u8, out[0 * CD_W + CD_R_D], 444, ctr)
  gv_check_eq("T2a-NEG-fully-matched-player-reads-0" as *u8, out[1 * CD_W + CD_R_D], 0, ctr)
  gv_check_eq("T2b-breadth-points-are-depth-weighted" as *u8, out[0 * CD_W + CD_R_BREADTH], 6, ctr)
  gv_check_eq("T2c-held-counts-rows-with-points" as *u8, out[1 * CD_W + CD_R_HELD], 1, ctr)
  // T3: Best over Yes on ONE shared row: lead 1 -> D(A) = 1000*1/(3*1*1) = 333; both fully central.
  //   means: C 1000, D 166 -> A is Aspirational (central, above the D mean), B Mainstream (0 is not above 166).
  let pts3: *i64 = sys_mmap(G_P2 * G_R1 * CD_I64_BYTES) as *i64
  pts3[0] = CD_PTS_BEST; pts3[1] = CD_PTS_YES
  let out3: *i64 = sys_mmap(G_P2 * CD_W * CD_I64_BYTES) as *i64
  cd_compute(pts3, G_P2, G_R1, out3)
  gv_check_eq("T3-best-over-yes-reads-333" as *u8, out3[0 * CD_W + CD_R_D], 333, ctr)
  gv_check_eq("T3a-both-central-on-a-shared-row" as *u8, out3[1 * CD_W + CD_R_C], 1000, ctr)
  let cm3: i64 = cd_mean(out3, G_P2, CD_R_C)
  let dm3: i64 = cd_mean(out3, G_P2, CD_R_D)
  gv_check_eq("T3b-distinctiveness-mean-166" as *u8, dm3, 166, ctr)
  gv_check_eq("T3c-leader-is-aspirational" as *u8, cd_quadrant(out3[0 * CD_W + CD_R_C], out3[0 * CD_W + CD_R_D], cm3, dm3, out3[0 * CD_W + CD_R_HELD]), CD_Q_ASPIRATIONAL, ctr)
  gv_check_eq("T3d-matched-player-is-mainstream" as *u8, cd_quadrant(out3[1 * CD_W + CD_R_C], out3[1 * CD_W + CD_R_D], cm3, dm3, out3[1 * CD_W + CD_R_HELD]), CD_Q_MAINSTREAM, ctr)
  // T4: a player holding nothing: both axes 0, held 0, quadrant ABSENT; the sole holder of two rows: D = 1000*4/(3*1*2) = 666.
  let pts4: *i64 = sys_mmap(G_P2 * G_R2 * CD_I64_BYTES) as *i64
  pts4[0] = CD_PTS_YES; pts4[1] = CD_PTS_YES; pts4[2] = CD_PTS_NO; pts4[3] = CD_PTS_NO
  let out4: *i64 = sys_mmap(G_P2 * CD_W * CD_I64_BYTES) as *i64
  cd_compute(pts4, G_P2, G_R2, out4)
  gv_check_eq("T4-absent-player-centrality-0" as *u8, out4[1 * CD_W + CD_R_C], 0, ctr)
  gv_check_eq("T4a-absent-player-distinctiveness-0-no-division" as *u8, out4[1 * CD_W + CD_R_D], 0, ctr)
  gv_check_eq("T4b-absent-player-quadrant-ABSENT" as *u8, cd_quadrant(0, 0, 500, 333, out4[1 * CD_W + CD_R_HELD]), CD_Q_ABSENT, ctr)
  gv_check_eq("T4c-sole-holder-distinctiveness-666" as *u8, out4[0 * CD_W + CD_R_D], 666, ctr)
  gv_check_eq("T4d-sole-holder-is-unconventional-below-a-high-c-mean" as *u8, cd_quadrant(out4[0 * CD_W + CD_R_C], out4[0 * CD_W + CD_R_D], CD_PERMIL + 1, 0, out4[0 * CD_W + CD_R_HELD]), CD_Q_UNCONVENTIONAL, ctr)
  gv_check_eq("T4e-NEG-peripheral-when-below-both-means" as *u8, cd_quadrant(100, 100, 500, 500, 1), CD_Q_PERIPHERAL, ctr)
  // T5: identical players -> D 0 both, C 1000 both -> the tie law: Mainstream, never Aspirational.
  let pts5: *i64 = sys_mmap(G_P2 * G_R2 * CD_I64_BYTES) as *i64
  pts5[0] = CD_PTS_YES; pts5[1] = CD_PTS_BEST; pts5[2] = CD_PTS_YES; pts5[3] = CD_PTS_BEST
  let out5: *i64 = sys_mmap(G_P2 * CD_W * CD_I64_BYTES) as *i64
  cd_compute(pts5, G_P2, G_R2, out5)
  let cm5: i64 = cd_mean(out5, G_P2, CD_R_C)
  let dm5: i64 = cd_mean(out5, G_P2, CD_R_D)
  gv_check_eq("T5-identical-players-distinctiveness-0" as *u8, out5[0 * CD_W + CD_R_D] + out5[1 * CD_W + CD_R_D], 0, ctr)
  gv_check_eq("T5a-identical-players-tie-law-mainstream" as *u8, cd_quadrant(out5[0 * CD_W + CD_R_C], out5[0 * CD_W + CD_R_D], cm5, dm5, out5[0 * CD_W + CD_R_HELD]), CD_Q_MAINSTREAM, ctr)
  // T6: the code scale and its neg-controls
  gv_check_eq("T6-code-best-3" as *u8, cd_pts(CD_CODE_BEST), CD_PTS_BEST, ctr)
  gv_check_eq("T6a-code-part-1" as *u8, cd_pts(CD_CODE_PART), CD_PTS_PART, ctr)
  gv_check_eq("T6b-NEG-unknown-code-is-No" as *u8, cd_pts(G_UNKNOWN_CODE), CD_PTS_NO, ctr)
  gv_check_eq("T6c-nishi-exceed-3" as *u8, cd_nishi_pts(CD_NISHI_EXCEED), CD_PTS_BEST, ctr)
  gv_check_eq("T6d-NEG-nishi-unknown-state-is-No" as *u8, cd_nishi_pts(G_UNKNOWN_STATE), CD_PTS_NO, ctr)
  // T7: the number parser and the integer square root
  gv_check_eq("T7-atoi-stops-at-non-digit" as *u8, cd_atoi("12x" as *u8), 12, ctr)
  gv_check_eq("T7a-NEG-atoi-empty-is-0" as *u8, cd_atoi("" as *u8), 0, ctr)
  gv_check_eq("T7b-atoi-negative" as *u8, cd_atoi("-5" as *u8), 0 - 5, ctr)
  gv_check_eq("T7c-isqrt-200-is-14" as *u8, cd_isqrt(200), 14, ctr)
  gv_check_eq("T7d-isqrt-1-is-1" as *u8, cd_isqrt(1), 1, ctr)
  gv_check_eq("T7e-NEG-isqrt-0-is-0" as *u8, cd_isqrt(0), 0, ctr)
  // T8: THE AXIS REGISTRY -- names round-trip, an unknown name is NONE, every id has a name
  gv_check_eq("T8-axis-id-depth-is-3" as *u8, cd_axis_id("depth" as *u8, 5), CD_AX_DEPTH, ctr)
  gv_check_eq("T8a-axis-id-momentum-is-4" as *u8, cd_axis_id("momentum" as *u8, 8), CD_AX_MOMENTUM, ctr)
  gv_check_eq("T8b-NEG-unknown-axis-name-is-NONE" as *u8, cd_axis_id("bogus" as *u8, 5), CD_AX_NONE, ctr)
  gv_check_eq("T8c-NEG-prefix-of-a-name-is-NONE" as *u8, cd_axis_id("centralit" as *u8, 9), CD_AX_NONE, ctr)
  gv_check("T8d-every-axis-id-names-itself-back" as *u8, (cd_axis_id(cd_axis_name(CD_AX_C), 10) == CD_AX_C) as i64 * (cd_axis_id(cd_axis_name(CD_AX_D), 15) == CD_AX_D) as i64 * (cd_axis_id(cd_axis_name(CD_AX_BREADTH), 7) == CD_AX_BREADTH) as i64, ctr)
  gv_check("T8e-NEG-an-id-past-the-registry-is-unknown" as *u8, g_streq(cd_axis_name(CD_AX_N), "unknown" as *u8), ctr)
  // T9: axis VALUES on the T1 table (nr 3): A breadth 1000*6/9 = 666, depth 1000*6/(3*3) = 666; B breadth 1000*2/9 = 222, depth 1000*2/3 = 666
  let hist0: *i64 = sys_mmap(G_P2 * CD_HIST_W * CD_I64_BYTES) as *i64
  gv_check_eq("T9-breadth-permil-of-the-whole-matrix" as *u8, cd_axis_value(out, 0, G_R3, hist0, CD_AX_BREADTH), 666, ctr)
  gv_check_eq("T9a-breadth-permil-partial-holder" as *u8, cd_axis_value(out, 1, G_R3, hist0, CD_AX_BREADTH), 222, ctr)
  gv_check_eq("T9b-depth-permil-of-rows-held" as *u8, cd_axis_value(out, 1, G_R3, hist0, CD_AX_DEPTH), 666, ctr)
  gv_check_eq("T9c-centrality-through-the-registry" as *u8, cd_axis_value(out, 1, G_R3, hist0, CD_AX_C), 500, ctr)
  gv_check_eq("T9d-NEG-momentum-unknown-reads-0" as *u8, cd_axis_value(out, 0, G_R3, hist0, CD_AX_MOMENTUM), 0, ctr)
  gv_check_eq("T9e-momentum-unknown-plots-mid-axis" as *u8, cd_axis_plot(out, 0, G_R3, hist0, CD_AX_MOMENTUM), 500, ctr)
  gv_check_eq("T9f-momentum-plot-scale-top" as *u8, cd_mom_plot(1000), 1000, ctr)
  gv_check_eq("T9g-momentum-plot-scale-bottom" as *u8, cd_mom_plot(0 - 1000), 0, ctr)
  gv_check_eq("T9h-NEG-momentum-plot-clamps-past-span" as *u8, cd_mom_plot(2000), 1000, ctr)
  gv_check_eq("T9i-axis-mean-plot-is-the-divider" as *u8, cd_axis_mean_plot(out, G_P2, G_R3, hist0, CD_AX_C), 750, ctr)
  // T10: THE ISOMETRIC PROJECTION at its corners (ox 380, oy 300, unit 220): origin stays; x=1000 -> right 190, down 110; z=1000 -> up 220
  gv_check_eq("T10-iso-origin-x" as *u8, cd_iso_x(G_ISO_OX, 0, 0, G_ISO_UNIT), G_ISO_OX, ctr)
  gv_check_eq("T10a-iso-origin-y" as *u8, cd_iso_y(G_ISO_OY, 0, 0, 0, G_ISO_UNIT), G_ISO_OY, ctr)
  gv_check_eq("T10b-iso-x-axis-end-right" as *u8, cd_iso_x(G_ISO_OX, 1000, 0, G_ISO_UNIT), G_ISO_OX + 190, ctr)
  gv_check_eq("T10c-iso-x-axis-end-down" as *u8, cd_iso_y(G_ISO_OY, 1000, 0, 0, G_ISO_UNIT), G_ISO_OY + 110, ctr)
  gv_check_eq("T10d-iso-y-axis-end-left" as *u8, cd_iso_x(G_ISO_OX, 0, 1000, G_ISO_UNIT), G_ISO_OX - 190, ctr)
  gv_check_eq("T10e-iso-z-lifts-by-a-unit" as *u8, cd_iso_y(G_ISO_OY, 0, 0, 1000, G_ISO_UNIT), G_ISO_OY - 220, ctr)
  gv_check_eq("T10f-iso-far-corner-x-is-origin" as *u8, cd_iso_x(G_ISO_OX, 1000, 1000, G_ISO_UNIT), G_ISO_OX, ctr)
  // T11: THE VIEW CONF -- defaults, a planted conf (last row wins, names resolve), absent file, a refused axis name
  let ids: *i64 = sys_mmap(CD_CUBE_AXES * CD_I64_BYTES) as *i64
  gv_check_eq("T11-default-cut-has-two-axes" as *u8, cd_view_default(CD_VIEW_CUT, ids), 2, ctr)
  gv_check_eq("T11a-default-cut-is-centrality-distinctiveness" as *u8, ids[0] * 10 + ids[1], CD_AX_C * 10 + CD_AX_D, ctr)
  gv_check_eq("T11b-default-cube-third-axis-is-breadth" as *u8, cd_view_default(CD_VIEW_CUBE, ids) * 10 + ids[2], 30 + CD_AX_BREADTH, ctr)
  gv_check("T11c-fixture-view-conf-written" as *u8, g_write_view(G_DOM, G_VIEW_ROWS), ctr)
  gv_check_eq("T11d-planted-cut-parses-two-axes" as *u8, cd_view_conf(G_DIR, G_DOM, CD_VIEW_CUT, ids), 2, ctr)
  gv_check_eq("T11e-planted-cut-is-breadth-depth" as *u8, ids[0] * 10 + ids[1], CD_AX_BREADTH * 10 + CD_AX_DEPTH, ctr)
  gv_check_eq("T11f-planted-cube-parses-three-axes" as *u8, cd_view_conf(G_DIR, G_DOM, CD_VIEW_CUBE, ids), 3, ctr)
  gv_check_eq("T11g-planted-cube-is-centrality-momentum-breadth" as *u8, ids[0] * 100 + ids[1] * 10 + ids[2], CD_AX_C * 100 + CD_AX_MOMENTUM * 10 + CD_AX_BREADTH, ctr)
  gv_check_eq("T11h-NEG-absent-conf-reads-ABSENT" as *u8, cd_view_conf(G_DIR, G_DOM_NOFILE, CD_VIEW_CUT, ids), CD_VIEW_ABSENT, ctr)
  gv_check("T11i-bad-view-conf-written" as *u8, g_write_view(G_DOM_BAD, G_VIEW_BAD), ctr)
  ids[0] = CD_AX_C; ids[1] = CD_AX_D
  gv_check_eq("T11j-NEG-unknown-axis-name-REFUSED" as *u8, cd_view_conf(G_DIR, G_DOM_BAD, CD_VIEW_CUT, ids), CD_VIEW_REFUSED, ctr)
  gv_check_eq("T11k-refused-row-leaves-ids-untouched" as *u8, ids[0] * 10 + ids[1], CD_AX_C * 10 + CD_AX_D, ctr)
  gv_check_eq("T11l-NEG-cube-row-absent-from-bad-conf-reads-ABSENT" as *u8, cd_view_conf(G_DIR, G_DOM_BAD, CD_VIEW_CUBE, ids), CD_VIEW_ABSENT, ctr)
  g_unlink_view(G_DOM); g_unlink_view(G_DOM_BAD)
  // THE SPINE on a fresh /tmp fixture
  gv_check("S0-fixture-spine-truncated-at-setup" as *u8, g_fresh_spine(), ctr)
  let names: *i64 = g_names(G_NAME_A, G_NAME_B)
  let w1: i64 = cd_spine_append(G_DIR, G_DOM, G_EPOCH_DAY1, names, out, G_P2, G_R3)
  gv_check_eq("S1-first-publish-writes-one-row-per-player" as *u8, w1, G_P2, ctr)
  let w1b: i64 = cd_spine_append(G_DIR, G_DOM, G_EPOCH_DAY1 + G_HOUR, names, out, G_P2, G_R3)
  gv_check_eq("S2-NEG-same-day-republish-writes-nothing" as *u8, w1b, 0, ctr)
  let nb: *i64 = sys_mmap(CD_I64_BYTES * 2) as *i64
  let sb: *u8 = g_read_spine(nb)
  gv_check("S2a-spine-readable-after-first-publish" as *u8, ((sb as i64) != 0) as i64, ctr)
  let hist: *i64 = sys_mmap(CD_HIST_W * CD_I64_BYTES) as *i64
  let day1: i64 = cd_day_of(G_EPOCH_DAY1)
  let days1: i64 = cd_spine_history(sb, nb[0], G_NAME_A, day1, hist)
  gv_check_eq("S3-history-day-one-sees-one-day" as *u8, days1, 1, ctr)
  gv_check_eq("S3a-first-day-recorded" as *u8, hist[CD_H_FDAY], day1, ctr)
  gv_check_eq("S3b-NEG-no-previous-day-on-day-one" as *u8, hist[CD_H_PDAY], 0, ctr)
  gv_check_eq("S3c-first-centrality-recorded" as *u8, hist[CD_H_FC], 1000, ctr)
  gv_check_eq("S3d-first-held-recorded" as *u8, hist[CD_H_FH], 3, ctr)
  gv_check_eq("S3e-first-rows-recorded" as *u8, hist[CD_H_FROWS], G_R3, ctr)
  // day two: A's centrality moves to 900; the history must carry day one as previous with the day-one values
  out[0 * CD_W + CD_R_C] = G_C_DAY2
  let w2: i64 = cd_spine_append(G_DIR, G_DOM, G_EPOCH_DAY1 + CD_SECS_PER_DAY, names, out, G_P2, G_R3)
  gv_check_eq("S4-next-day-publish-writes-again" as *u8, w2, G_P2, ctr)
  let sb2: *u8 = g_read_spine(nb)
  let day2: i64 = day1 + 1
  let days2: i64 = cd_spine_history(sb2, nb[0], G_NAME_A, day2, hist)
  gv_check_eq("S5-history-sees-two-days" as *u8, days2, 2, ctr)
  gv_check_eq("S5a-previous-day-is-day-one" as *u8, hist[CD_H_PDAY], day1, ctr)
  gv_check_eq("S5b-previous-centrality-is-day-one-value" as *u8, hist[CD_H_PC], 1000, ctr)
  gv_check_eq("S5c-last-day-is-day-two" as *u8, hist[CD_H_LASTDAY], day2, ctr)
  gv_check_eq("S5d-first-day-unchanged" as *u8, hist[CD_H_FDAY], day1, ctr)
  gv_check_eq("S5e-previous-breadth-points-recorded" as *u8, hist[CD_H_PB], 6, ctr)
  gv_check_eq("S5f-momentum-is-the-c-move" as *u8, cd_momentum(out, 0, hist), G_C_DAY2 - 1000, ctr)
  gv_check_eq("S5g-previous-day-breadth-plots-from-the-spine" as *u8, cd_hist_axis_plot(hist, CD_HIST_WHICH_PREV, CD_AX_BREADTH), 666, ctr)
  gv_check_eq("S5h-first-day-depth-plots-from-the-spine" as *u8, cd_hist_axis_plot(hist, CD_HIST_WHICH_FIRST, CD_AX_DEPTH), 666, ctr)
  let cap: i64 = cd_count_lines(sb2, nb[0])
  let dd: *i64 = sys_mmap((cap + 1) * CD_I64_BYTES) as *i64
  let dr: *i64 = sys_mmap((cap + 1) * CD_I64_BYTES) as *i64
  let dm: *i64 = sys_mmap((cap + 1) * CD_I64_BYTES) as *i64
  let nd: i64 = cd_spine_days(sb2, nb[0], dd, dr, dm, cap)
  gv_check_eq("S6-review-log-lists-two-days" as *u8, nd, 2, ctr)
  gv_check_eq("S6a-each-day-carries-every-player" as *u8, dr[0] + dr[1], G_P2 * 2, ctr)
  gv_check_eq("S6b-each-day-carries-the-matrix-row-count" as *u8, dm[1], G_R3, ctr)
  gv_check_eq("S7-NEG-unknown-player-has-no-history" as *u8, cd_spine_history(sb2, nb[0], G_NAME_Z, day2, hist), 0, ctr)
  gv_check_eq("S8-has-day-finds-day-one" as *u8, cd_spine_has_day(sb2, nb[0], day1), 1, ctr)
  gv_check_eq("S8a-NEG-has-day-misses-day-three" as *u8, cd_spine_has_day(sb2, nb[0], day2 + 1), 0, ctr)
  // S9: THE DAILY TRAIL -- every spine day before today, oldest first, one record per day, plotted by the one axis rule
  let tcap9: i64 = nd + 1
  let trecs: *i64 = sys_mmap(tcap9 * CD_HIST_W * CD_I64_BYTES) as *i64
  let day3: i64 = day2 + 1
  let nt3: i64 = cd_spine_trail(sb2, nb[0], G_NAME_A, day3, trecs, tcap9)
  gv_check_eq("S9-trail-on-day-three-holds-both-past-days" as *u8, nt3, 2, ctr)
  let tr0: *i64 = cd_trail_rec(trecs, 0)
  let tr1: *i64 = cd_trail_rec(trecs, 1)
  gv_check_eq("S9a-trail-is-oldest-first-day-one" as *u8, tr0[CD_H_FDAY], day1, ctr)
  gv_check_eq("S9b-trail-second-record-is-day-two" as *u8, tr1[CD_H_FDAY], day2, ctr)
  gv_check_eq("S9c-trail-day-one-carries-its-own-centrality" as *u8, tr0[CD_H_FC], 1000, ctr)
  gv_check_eq("S9d-trail-day-two-carries-the-moved-centrality" as *u8, tr1[CD_H_FC], G_C_DAY2, ctr)
  gv_check_eq("S9e-trail-day-one-carries-its-held-and-rows" as *u8, tr0[CD_H_FH] * 1000 + tr0[CD_H_FROWS], 3 * 1000 + G_R3, ctr)
  // cross-identity: the trail's day two plots exactly where the history's previous day plots, on every C/D/breadth axis
  let days3: i64 = cd_spine_history(sb2, nb[0], G_NAME_A, day3, hist)
  gv_check_eq("S9f-trail-and-history-agree-on-day-two-centrality-plot" as *u8, cd_hist_axis_plot(tr1, CD_HIST_WHICH_FIRST, CD_AX_C), cd_hist_axis_plot(hist, CD_HIST_WHICH_PREV, CD_AX_C), ctr)
  gv_check_eq("S9g-trail-and-history-agree-on-day-two-breadth-plot" as *u8, cd_hist_axis_plot(tr1, CD_HIST_WHICH_FIRST, CD_AX_BREADTH), cd_hist_axis_plot(hist, CD_HIST_WHICH_PREV, CD_AX_BREADTH), ctr)
  gv_check_eq("S9h-history-on-day-three-sees-two-days" as *u8, days3, 2, ctr)
  gv_check_eq("S9i-on-day-two-the-trail-is-day-one-only" as *u8, cd_spine_trail(sb2, nb[0], G_NAME_A, day2, trecs, tcap9), 1, ctr)
  gv_bite("neg-control-trail-excludes-today a day's own row is never part of its trail, while the next day's trail does hold it" as *u8, (cd_spine_trail(sb2, nb[0], G_NAME_A, day1, trecs, tcap9) == 0) as i64, (cd_spine_trail(sb2, nb[0], G_NAME_A, day2, trecs, tcap9) == 0) as i64, ctr)
  gv_check_eq("S9j-NEG-unknown-player-has-no-trail" as *u8, cd_spine_trail(sb2, nb[0], G_NAME_Z, day3, trecs, tcap9), 0, ctr)
  gv_check_eq("S9k-trail-never-writes-past-its-cap" as *u8, cd_spine_trail(sb2, nb[0], G_NAME_A, day3, trecs, 1), 1, ctr)
  // T12: THE NOTES (DV5) -- planted rows on the same players: two parsed, three refused by name, an absent file, the offsets read back
  gv_check("T12-fixture-notes-written" as *u8, g_write_notes(G_DOM, G_NOTE_ROWS), ctr)
  let nrecs: *i64 = sys_mmap(G_NOTES_CAP * CD_NOTE_W * CD_I64_BYTES) as *i64
  let nbo: *i64 = sys_mmap(CD_I64_BYTES * 2) as *i64
  let nst: *i64 = sys_mmap(CD_NS_W * CD_I64_BYTES) as *i64
  let nn: i64 = cd_notes_load(G_DIR, G_DOM, names, G_P2, nrecs, G_NOTES_CAP, nbo, nst)
  gv_check_eq("T12a-two-notes-parsed" as *u8, nn, 2, ctr)
  gv_check_eq("T12b-five-rows-seen" as *u8, nst[CD_NS_ROWS], 5, ctr)
  gv_check_eq("T12c-NEG-three-rows-refused-unknown-player-malformed-anchor-over-long-text" as *u8, nst[CD_NS_REFUSED], 3, ctr)
  let n0: *i64 = cd_note_rec(nrecs, 0)
  let n1: *i64 = cd_note_rec(nrecs, 1)
  gv_check_eq("T12d-first-note-pins-player-A" as *u8, n0[CD_N_KIND] * 10 + n0[CD_N_PLAYER], CD_NK_PLAYER * 10, ctr)
  gv_check_eq("T12e-second-note-is-a-point" as *u8, n1[CD_N_KIND], CD_NK_AT, ctr)
  gv_check_eq("T12f-point-x-250" as *u8, n1[CD_N_X], 250, ctr)
  gv_check_eq("T12g-point-y-750" as *u8, n1[CD_N_Y], 750, ctr)
  let nbuf: *u8 = nbo[0] as *u8
  gv_check("T12h-text-offsets-read-the-row-text" as *u8, cd_name_eq_n(G_NOTE1_TEXT, (nbuf as i64 + n0[CD_N_TOFF]) as *u8, n0[CD_N_TLEN]), ctr)
  gv_check("T12i-id-read-back" as *u8, cd_name_eq_n("n1" as *u8, (nbuf as i64 + n0[CD_N_IDOFF]) as *u8, n0[CD_N_IDLEN]), ctr)
  gv_check("T12j-by-field-read-to-the-row-end" as *u8, cd_name_eq_n("seat" as *u8, (nbuf as i64 + n0[CD_N_BOFF]) as *u8, n0[CD_N_BLEN]), ctr)
  gv_check("T12k-since-field-read-back" as *u8, cd_name_eq_n("2026-09-15" as *u8, (nbuf as i64 + n1[CD_N_SOFF]) as *u8, n1[CD_N_SLEN]), ctr)
  gv_check_eq("T12l-NEG-absent-notes-file-reads-0-notes-and-0-rows" as *u8, cd_notes_load(G_DIR, G_DOM_NOFILE, names, G_P2, nrecs, G_NOTES_CAP, nbo, nst) * 10 + nst[CD_NS_ROWS], 0, ctr)
  g_unlink_notes(G_DOM)
  // T13: the wrapper -- 31 bytes at 12 per line is 3 lines; at 5 it needs 6 so a 4-line cap REFUSES; a 13-byte word at 12 REFUSES; empty is 0
  let wo: *i64 = sys_mmap(G_WRAP_MAX * CD_I64_BYTES) as *i64
  let wl: *i64 = sys_mmap(G_WRAP_MAX * CD_I64_BYTES) as *i64
  gv_check_eq("T13-wrap-31-bytes-at-12-is-3-lines" as *u8, cd_notes_wrap(G_NOTE1_TEXT, cd_slen(G_NOTE1_TEXT), G_WRAP_12, G_WRAP_MAX, wo, wl), 3, ctr)
  gv_check_eq("T13a-first-line-is-11-bytes-Holds-every" as *u8, wl[0], 11, ctr)
  gv_check("T13b-second-line-is-row-the" as *u8, cd_name_eq_n("row the" as *u8, (G_NOTE1_TEXT as i64 + wo[1]) as *u8, wl[1]), ctr)
  gv_check("T13c-third-line-is-field-holds" as *u8, cd_name_eq_n("field holds" as *u8, (G_NOTE1_TEXT as i64 + wo[2]) as *u8, wl[2]), ctr)
  gv_check_eq("T13d-NEG-more-lines-than-the-cap-REFUSED-never-truncated" as *u8, cd_notes_wrap(G_NOTE1_TEXT, cd_slen(G_NOTE1_TEXT), G_WRAP_5, G_WRAP_4, wo, wl), CD_NOTE_REFUSED, ctr)
  gv_check_eq("T13e-NEG-a-word-longer-than-the-line-REFUSED" as *u8, cd_notes_wrap(G_LONG_WORD, cd_slen(G_LONG_WORD), G_WRAP_12, G_WRAP_MAX, wo, wl), CD_NOTE_REFUSED, ctr)
  gv_check_eq("T13f-empty-text-is-0-lines" as *u8, cd_notes_wrap("" as *u8, 0, G_WRAP_12, G_WRAP_MAX, wo, wl), 0, ctr)
  gv_check_eq("T13g-leading-and-double-spaces-make-no-extra-lines" as *u8, cd_notes_wrap("  a  b " as *u8, 7, G_WRAP_12, G_WRAP_MAX, wo, wl), 1, ctr)
  // T14 (2026-09-17): SUBSTRATE ROWS OFF THE MAP. A planted plan: S1 substrate carrying sym_k, S2 contender carrying
  // sym_f, S3 with no role row carrying sym_n; five matrix symbols including an _ABSENT_-prefixed sym_k and one no
  // rung names. Hand-worked: excluded = 2 (sym_k bare and prefixed), mask 0,1,1,0,1; an empty plan excludes nothing.
  let plan14: *u8 = "rung|S1|kernel|sym_k|text|Organ|1|-\nrungrole|S1|substrate|T1|why\nrung|S2|feature|sym_f|text|Organ|1|-\nrungrole|S2|contender|T1|why\nrung|S3|norole|sym_n|text|Organ|1|-\n" as *u8
  let syms14: *i64 = sys_mmap(5 * CD_I64_BYTES) as *i64
  syms14[0] = "sym_k" as *u8 as i64
  syms14[1] = "sym_f" as *u8 as i64
  syms14[2] = "sym_n" as *u8 as i64
  syms14[3] = "_ABSENT_:sym_k" as *u8 as i64
  syms14[4] = "sym_none" as *u8 as i64
  let mask14: *i64 = sys_mmap(5 * CD_I64_BYTES) as *i64
  let ex14: i64 = cd_substrate_mask(plan14, cd_slen(plan14), syms14, 5, mask14)
  gv_check_eq("T14-substrate-rows-excluded-bare-and-ABSENT-prefixed" as *u8, ex14, 2, ctr)
  gv_check_eq("T14a-substrate-symbol-mask-0" as *u8, mask14[0], 0, ctr)
  gv_check_eq("T14b-contender-symbol-mapped" as *u8, mask14[1], 1, ctr)
  gv_check_eq("T14c-rung-without-role-row-mapped" as *u8, mask14[2], 1, ctr)
  gv_check_eq("T14d-ABSENT-prefixed-substrate-symbol-mask-0" as *u8, mask14[3], 0, ctr)
  gv_check_eq("T14e-symbol-no-rung-names-mapped" as *u8, mask14[4], 1, ctr)
  gv_check_eq("T14f-NEG-empty-plan-excludes-nothing" as *u8, cd_substrate_mask(plan14, 0, syms14, 5, mask14), 0, ctr)
  gv_check_eq("T14g-NEG-a-symbol-that-is-a-prefix-of-the-rung-symbol-is-not-joined" as *u8, cd_sym_is_substrate(plan14, cd_slen(plan14), "sym_" as *u8), 0, ctr)
  gv_kv("substrate_excluded_planted" as *u8, ex14)
  gv_kv("notes_parsed" as *u8, nn)
  gv_kv("notes_refused" as *u8, nst[CD_NS_REFUSED])
  gv_kv("centrality_a_day1" as *u8, 1000)
  gv_kv("distinctiveness_a" as *u8, out[0 * CD_W + CD_R_D])
  gv_kv("distinctiveness_mean_t3" as *u8, dm3)
  gv_kv("axes_registered" as *u8, CD_AX_N)
  gv_kv("spine_bytes" as *u8, nb[0])
  gv_kv("spine_days" as *u8, nd)
  return gv_verdict("nx_cdmap_gate" as *u8, ctr, "the C-D ruler on planted tables with hand-worked answers, the tie law, absent and identical players, the parsers, the axis registry, the view conf, the notes and their wrapper, the isometric projection, and the day spine written twice and read back" as *u8)
319}
nx_cdmap_gate.nx source

`nx_cdmap_gate.nx` source
