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

↩ module page · 237 lines · 15981 B
1// nx_cdmap_referee_gate.nx -- referee for the position map's SECOND RULER (datavis DV2a, 2026-09-15): the SVG scanner on a
2// hand-built figure, the heuristic critic reproducing a hand-worked grade, two PLANTED defects the ruler must fire on
3// (a label on a label, a label on a mark), the api.json reader with absent-key controls, then -- when the SIL-OFL face is
4// on disk -- real advances bounded by what a sans face can measure and the metric critic firing on the same plant, and
5// -- when the live search page is on disk -- the self-grade the emitter published re-derived from its own SVG.
6// The font and the live page are OPTIONAL witnesses, announced through gv_kv, never gv_need: a witness structurally absent
7// on one host must not SKIP the whole gate forever there (measured 2026-09-02 on the browser lane). license_tier: ORIGINAL
8import "nx_cdmap_referee_lib.nx"
9import "nx_syscalls.nx"
10import "nx_gate_verdict.nx"
11
12const G_FONT: i64 = 13
13const G_EXP_N: i64 = 2
14const G_FRAME_X0: i64 = 70
15const G_FRAME_X1: i64 = 730
16const G_FRAME_Y1: i64 = 460
17const G_L0_X: i64 = 201
18const G_L0_BOX_Y: i64 = 208
19const G_TW_NISHI: i64 = 36           // cl_text_w(5, 13)
20const G_TW_MOJEEK: i64 = 43          // cl_text_w(6, 13) = 43.68 floored
21const G_SPREAD_PRISTINE: i64 = 428   // marks 180..483 of 660 (459) and 216..387 of 430 (397), mean 428
22const G_PUB_MM: i64 = 1
23const G_PUB_SPREAD: i64 = 690
24const G_JSON_BYTES: i64 = 512
25const G_CH_QUOTE: i64 = 34
26const G_MIN_EM_PERMIL: i64 = 350     // a sans glyph advance never reads below 0.35 em on average...
27const G_MAX_EM_PERMIL: i64 = 900     // ...nor above 0.90 em; outside this band the ruler is broken, not the font
28const G_NISHI_CHARS: i64 = 5
29const G_CRIT_W: i64 = 6
30const G_FONT_NAS: *u8 = "knowledge/fonts/LiberationSans-Regular.ttf"
31const G_FONT_NAS_BOLD: *u8 = "knowledge/fonts/LiberationSans-Bold.ttf"
32const G_FONT_LAPTOP: *u8 = "web_assets/fonts/LiberationSans-Regular.ttf"
33const G_FONT_LAPTOP_BOLD: *u8 = "web_assets/fonts/LiberationSans-Bold.ttf"
34const G_LIVE_PAGE: *u8 = "sites/nishifamily/compare/search/index.html"
35const G_LIVE_API: *u8 = "sites/nishifamily/compare/search/api.json"
36const G_BLOCK: *u8 = "readability_cut"
37
38const G_FIX_HEAD: *u8 = "<figure><svg class='cdmap' viewBox='0 0 760 520'>\n<rect x='70' y='30' width='660' height='430' rx='6' fill='var(--nx-color-panel)'/>\n<text x='70' y='475' fill='var(--nx-color-mut)' font-size='11'>700</text>\n<circle cx='180' cy='216' r='15' fill='var(--nx-color-accent)'><title>Nishi</title></circle>\n<circle cx='483' cy='387' r='15' fill='rgb(230,159,0)'><title>Mojeek</title></circle>\n"
39const G_FIX_TAIL: *u8 = "</svg></figure>\n"
40const G_LBL_NISHI_OK: *u8 = "<text x='201' y='220' font-size='13' fill='var(--nx-color-fg)' style='paint-order:stroke' font-weight='700'>Nishi</text>\n"
41const G_LBL_NISHI_ONMARK: *u8 = "<text x='170' y='220' font-size='13' fill='var(--nx-color-fg)' style='paint-order:stroke' font-weight='700'>Nishi</text>\n"
42const G_LBL_MOJEEK_ONMARK: *u8 = "<text x='150' y='220' font-size='13' fill='var(--nx-color-fg)' style='paint-order:stroke'>Mojeek</text>\n"
43const G_LBL_MOJEEK_OK: *u8 = "<text x='504' y='391' font-size='13' fill='var(--nx-color-fg)' style='paint-order:stroke'>Mojeek</text>\n"
44const G_LBL_MOJEEK_ONLABEL: *u8 = "<text x='201' y='220' font-size='13' fill='var(--nx-color-fg)' style='paint-order:stroke'>Mojeek</text>\n"
45const G_FIX_BYTES: i64 = 2048
46
47func g_cat(d: *u8, o: i64, s: *u8) -> i64 { var i: i64 = 0; var p: i64 = o; while s[i] != (0 as u8) { d[p] = s[i]; p = p + 1; i = i + 1 } return p }
48func g_fixture(a: *u8, b: *u8) -> *u8 {
  let d: *u8 = sys_mmap(G_FIX_BYTES)
  var o: i64 = g_cat(d, 0, G_FIX_HEAD); o = g_cat(d, o, a); o = g_cat(d, o, b); o = g_cat(d, o, G_FIX_TAIL)
  d[o] = 0 as u8
  return d
53}
54func g_q(d: *u8, o: i64) -> i64 { d[o] = G_CH_QUOTE as u8; return o + 1 }
55func g_jkey(d: *u8, o: i64, k: *u8, v: i64) -> i64 {
  var p: i64 = g_q(d, o); p = g_cat(d, p, k); p = g_q(d, p); p = g_cat(d, p, ":" as *u8); p = gv_catn(d, p, v); return p
57}
58// {"rows_written_today":1,"readability_cut":{...},"readability_cube":{"label_overlaps":2}} assembled at runtime so no
59// double quote has to live in a literal, and so the fixture cannot be mistaken for a published api.json by any scanner
60func g_json(d: *u8) -> i64 {
  var o: i64 = g_cat(d, 0, "{" as *u8)
  o = g_jkey(d, o, "rows_written_today" as *u8, 1); o = g_cat(d, o, "," as *u8)
  o = g_q(d, o); o = g_cat(d, o, G_BLOCK); o = g_q(d, o); o = g_cat(d, o, ":{" as *u8)
  o = g_jkey(d, o, "label_overlaps" as *u8, 0); o = g_cat(d, o, "," as *u8)
  o = g_jkey(d, o, "labels_over_marks" as *u8, 0); o = g_cat(d, o, "," as *u8)
  o = g_jkey(d, o, "off_canvas" as *u8, 0); o = g_cat(d, o, "," as *u8)
  o = g_jkey(d, o, "unresolved" as *u8, 0); o = g_cat(d, o, "," as *u8)
  o = g_jkey(d, o, "mark_overlaps" as *u8, G_PUB_MM); o = g_cat(d, o, "," as *u8)
  o = g_jkey(d, o, "spread_permil" as *u8, G_PUB_SPREAD); o = g_cat(d, o, "," as *u8)
  o = g_jkey(d, o, "defects" as *u8, 0); o = g_cat(d, o, "}," as *u8)
  o = g_q(d, o); o = g_cat(d, o, "readability_cube" as *u8); o = g_q(d, o); o = g_cat(d, o, ":{" as *u8)
  o = g_jkey(d, o, "label_overlaps" as *u8, 2); o = g_cat(d, o, "}}" as *u8)
  d[o] = 0 as u8
  return o
75}
76func g_i64(n: i64) -> *i64 { return sys_mmap(n * CR_I64_BYTES) as *i64 }
77func g_setname(names: *u8, i: i64, s: *u8) -> i64 { let slot: *u8 = cr_name_at(names, i); var k: i64 = 0; while s[k] != (0 as u8) { slot[k] = s[k]; k = k + 1 } slot[k] = 0 as u8; return k }
78// scan a fixture into fresh arrays; returns the label count and leaves everything in the record slots
79func g_scan(fx: *u8, rec: *i64, names: *u8) -> i64 {
  // rec layout: 0 mx, 1 my, 2 mr, 3 lx, 4 ly, 5 lfont, 6 lbold, 7 frame, 8 out, 9 lw, 10 lh, 11 crit (pointers as i64)
  var k: i64 = 0
  while k < 12 { rec[k] = g_i64(CR_MAXN) as i64; k = k + 1 }
  return cr_scan(fx, cr_slen(fx), rec[0] as *i64, rec[1] as *i64, rec[2] as *i64, rec[3] as *i64, rec[4] as *i64, rec[5] as *i64, rec[6] as *i64, names, rec[7] as *i64, rec[8] as *i64)
84}
85func g_grade(rec: *i64, names: *u8, n: i64, fhr: *i64, fhb: *i64) -> *i64 {
  cr_boxes(n, names, rec[5] as *i64, rec[6] as *i64, fhr, fhb, rec[9] as *i64, rec[10] as *i64)
  cr_critic(n, rec[0] as *i64, rec[1] as *i64, rec[2] as *i64, rec[3] as *i64, rec[4] as *i64, rec[9] as *i64, rec[10] as *i64, rec[7] as *i64, rec[11] as *i64)
  return rec[11] as *i64
89}
90func g_load_font(nas: *u8, laptop: *u8) -> *i64 {
  let a: *i64 = tf_load(nas)
  if (a as i64) != 0 { return a }
  return tf_load(laptop)
94}
95
96func main() -> i64 {
  let ctr: *i64 = gv_ctr()
  gv_head("=== NX-CDMAP-REFEREE GATE -- the position map's second ruler: SVG re-derivation, real-font re-measurement, both critics ===" as *u8)
  // ---- T1: the scanner on the pristine fixture
  let fxA: *u8 = g_fixture(G_LBL_NISHI_OK, G_LBL_MOJEEK_OK)
  let recA: *i64 = g_i64(12)
  let namesA: *u8 = sys_mmap(CR_MAXN * CR_NAME_W)
  let nA: i64 = g_scan(fxA, recA, namesA)
  let frA: *i64 = recA[7] as *i64
  let lxA: *i64 = recA[3] as *i64
  let lyA: *i64 = recA[4] as *i64
  let lbA: *i64 = recA[6] as *i64
  let lfA: *i64 = recA[5] as *i64
  gv_check_eq("T1-scan-labels" as *u8, nA, G_EXP_N, ctr)
  gv_check_eq("T1a-scan-marks" as *u8, (recA[8] as *i64)[0], G_EXP_N, ctr)
  gv_check_eq("T1b-frame-x0-from-rect" as *u8, frA[CR_F_X0], G_FRAME_X0, ctr)
  gv_check_eq("T1c-frame-x1-from-rect-width" as *u8, frA[CR_F_X1], G_FRAME_X1, ctr)
  gv_check_eq("T1d-frame-y1-from-rect-height" as *u8, frA[CR_F_Y1], G_FRAME_Y1, ctr)
  gv_check_eq("T1e-label0-x" as *u8, lxA[0], G_L0_X, ctr)
  gv_check_eq("T1f-label0-box-top-is-baseline-minus-12" as *u8, lyA[0], G_L0_BOX_Y, ctr)
  gv_check_eq("T1g-label0-bold-read-from-tag" as *u8, lbA[0], 1, ctr)
  gv_check_eq("T1h-label1-not-bold" as *u8, lbA[1], 0, ctr)
  gv_check_eq("T1i-label0-name" as *u8, cr_streq(cr_name_at(namesA, 0), "Nishi" as *u8), 1, ctr)
  gv_check_eq("T1j-label1-name" as *u8, cr_streq(cr_name_at(namesA, 1), "Mojeek" as *u8), 1, ctr)
  gv_check_eq("T1k-label-font-px" as *u8, lfA[0], G_FONT, ctr)
  gv_check_eq("T1l-NEG-muted-tick-text-is-not-a-label" as *u8, cr_streq(cr_name_at(namesA, 0), "700" as *u8), 0, ctr)
  // ---- T2 + T3: the heuristic ruler reproduces the emitter's widths and grades the pristine figure clean
  let critA: *i64 = g_grade(recA, namesA, nA, 0 as *i64, 0 as *i64)
  let lwA: *i64 = recA[9] as *i64
  gv_check_eq("T2-heuristic-width-Nishi" as *u8, lwA[0], G_TW_NISHI, ctr)
  gv_check_eq("T2a-heuristic-width-Mojeek" as *u8, lwA[1], G_TW_MOJEEK, ctr)
  gv_check_eq("T3-pristine-LL-0" as *u8, critA[CL_C_LL], 0, ctr)
  gv_check_eq("T3a-pristine-LM-0" as *u8, critA[CL_C_LM], 0, ctr)
  gv_check_eq("T3b-pristine-OFF-0" as *u8, critA[CL_C_OFF], 0, ctr)
  gv_check_eq("T3c-pristine-MM-0" as *u8, critA[CL_C_MM], 0, ctr)
  gv_check_eq("T3d-pristine-spread-hand-worked" as *u8, critA[CL_C_SPREAD], G_SPREAD_PRISTINE, ctr)
  gv_check_eq("T3e-pristine-defects-0" as *u8, critA[CL_C_DEFECTS], 0, ctr)
  // ---- T4: a label planted on a label must fire
  let fxB: *u8 = g_fixture(G_LBL_NISHI_OK, G_LBL_MOJEEK_ONLABEL)
  let recB: *i64 = g_i64(12)
  let namesB: *u8 = sys_mmap(CR_MAXN * CR_NAME_W)
  let nB: i64 = g_scan(fxB, recB, namesB)
  let critB: *i64 = g_grade(recB, namesB, nB, 0 as *i64, 0 as *i64)
  gv_check_eq("T4-neg-control-label-on-label-LL-1" as *u8, critB[CL_C_LL], 1, ctr)
  gv_check_eq("T4a-neg-control-label-on-label-defects-1" as *u8, critB[CL_C_DEFECTS], 1, ctr)
  // ---- T5: a label planted on a mark must fire
  let fxC: *u8 = g_fixture(G_LBL_NISHI_OK, G_LBL_MOJEEK_ONMARK)
  let recC: *i64 = g_i64(12)
  let namesC: *u8 = sys_mmap(CR_MAXN * CR_NAME_W)
  let nC: i64 = g_scan(fxC, recC, namesC)
  let critC: *i64 = g_grade(recC, namesC, nC, 0 as *i64, 0 as *i64)
  var lm_fired: i64 = 0
  if critC[CL_C_LM] >= 1 { lm_fired = 1 }
  gv_check("T5-neg-control-label-on-mark-LM-fires" as *u8, lm_fired, ctr)
  gv_check_eq("T5a-neg-control-label-on-mark-LL-still-0" as *u8, critC[CL_C_LL], 0, ctr)
  // a label over its OWN mark is not a defect by design (the placer seats every label beside its own mark and the
  // critic skips that pair), so the plant above is ANOTHER player's label; this control pins the semantics that the
  // first cut of this gate got wrong rather than leaving it implicit
  let fxD: *u8 = g_fixture(G_LBL_NISHI_ONMARK, G_LBL_MOJEEK_OK)
  let recD: *i64 = g_i64(12)
  let namesD: *u8 = sys_mmap(CR_MAXN * CR_NAME_W)
  let nD: i64 = g_scan(fxD, recD, namesD)
  let critD: *i64 = g_grade(recD, namesD, nD, 0 as *i64, 0 as *i64)
  gv_check_eq("T5b-own-mark-overlap-is-not-a-defect-by-design" as *u8, critD[CL_C_LM], 0, ctr)
  // ---- T6: the api.json reader and its absent-key controls
  let jb: *u8 = sys_mmap(G_JSON_BYTES)
  let jn: i64 = g_json(jb)
  gv_check_eq("T6-json-label-overlaps" as *u8, cr_json_int(jb, jn, G_BLOCK, "label_overlaps" as *u8), 0, ctr)
  gv_check_eq("T6a-json-mark-overlaps" as *u8, cr_json_int(jb, jn, G_BLOCK, "mark_overlaps" as *u8), G_PUB_MM, ctr)
  gv_check_eq("T6b-json-spread" as *u8, cr_json_int(jb, jn, G_BLOCK, "spread_permil" as *u8), G_PUB_SPREAD, ctr)
  gv_check_eq("T6c-json-defects" as *u8, cr_json_int(jb, jn, G_BLOCK, "defects" as *u8), 0, ctr)
  gv_check_eq("T6d-NEG-json-absent-key-is-absent" as *u8, cr_json_int(jb, jn, G_BLOCK, "no_such_key" as *u8), CR_ABSENT, ctr)
  gv_check_eq("T6e-NEG-json-absent-block-is-absent" as *u8, cr_json_int(jb, jn, "no_such_block" as *u8, "defects" as *u8), CR_ABSENT, ctr)
  gv_check_eq("T6f-NEG-json-key-of-the-other-block-does-not-leak" as *u8, cr_json_int(jb, jn, G_BLOCK, "label_overlaps" as *u8), 0, ctr)
  // ---- T7: the metric ruler over the real face (OPTIONAL witness, announced)
  let fhr: *i64 = g_load_font(G_FONT_NAS, G_FONT_LAPTOP)
  var fhb: *i64 = g_load_font(G_FONT_NAS_BOLD, G_FONT_LAPTOP_BOLD)
  if (fhb as i64) == 0 { fhb = fhr }
  var font_present: i64 = 0
  var w_nishi: i64 = 0
  var w_marg: i64 = 0
  if (fhr as i64) != 0 {
      font_present = 1
      w_nishi = cr_w_metric(fhr, "Nishi" as *u8, G_FONT)
      w_marg = cr_w_metric(fhr, "Marginalia" as *u8, G_FONT)
      let lo: i64 = G_FONT * G_NISHI_CHARS * G_MIN_EM_PERMIL / CR_PERMIL
      let hi: i64 = G_FONT * G_NISHI_CHARS * G_MAX_EM_PERMIL / CR_PERMIL
      var in_band: i64 = 0
      if w_nishi >= lo { if w_nishi <= hi { in_band = 1 } }
      gv_check("T7-metric-width-Nishi-within-a-sans-band" as *u8, in_band, ctr)
      var wider: i64 = 0
      if w_marg > w_nishi { wider = 1 }
      gv_check("T7a-metric-Marginalia-wider-than-Nishi" as *u8, wider, ctr)
      let critBm: *i64 = g_grade(recB, namesB, nB, fhr, fhb)
      gv_check_eq("T7b-neg-control-metric-ruler-fires-on-the-label-plant" as *u8, critBm[CL_C_LL], 1, ctr)
      let critAm: *i64 = g_grade(recA, namesA, nA, fhr, fhb)
      gv_check_eq("T7c-metric-ruler-pristine-LL-0" as *u8, critAm[CL_C_LL], 0, ctr)
      gv_check_eq("T7d-metric-ruler-pristine-LM-0" as *u8, critAm[CL_C_LM], 0, ctr)
  }
  // ---- T8: the LIVE page's self-grade re-derived from its own SVG (OPTIONAL witness, announced)
  var live_present: i64 = 0
  var live_labels: i64 = 0
  var live_metric_defects: i64 = CR_ABSENT
  var live_pub_defects: i64 = CR_ABSENT
  let pl: *i64 = g_i64(2)
  let ph: *u8 = sys_read_file(G_LIVE_PAGE, pl)
  let jl: *i64 = g_i64(2)
  let pj: *u8 = sys_read_file(G_LIVE_API, jl)
  if (ph as i64) != 0 { if (pj as i64) != 0 {
      let recL: *i64 = g_i64(12)
      let namesL: *u8 = sys_mmap(CR_MAXN * CR_NAME_W)
      var k: i64 = 0
      while k < 12 { recL[k] = g_i64(CR_MAXN) as i64; k = k + 1 }
      let nL: i64 = cr_scan(ph, pl[0], recL[0] as *i64, recL[1] as *i64, recL[2] as *i64, recL[3] as *i64, recL[4] as *i64, recL[5] as *i64, recL[6] as *i64, namesL, recL[7] as *i64, recL[8] as *i64)
      if nL > 0 {
          live_present = 1
          live_labels = nL
          gv_check_eq("T8-live-labels-pair-with-marks" as *u8, nL, (recL[8] as *i64)[0], ctr)
          let critL: *i64 = g_grade(recL, namesL, nL, 0 as *i64, 0 as *i64)
          gv_check_eq("T8a-live-self-grade-LL-reproduced-from-svg" as *u8, critL[CL_C_LL], cr_json_int(pj, jl[0], G_BLOCK, "label_overlaps" as *u8), ctr)
          gv_check_eq("T8b-live-self-grade-LM-reproduced" as *u8, critL[CL_C_LM], cr_json_int(pj, jl[0], G_BLOCK, "labels_over_marks" as *u8), ctr)
          gv_check_eq("T8c-live-self-grade-OFF-reproduced" as *u8, critL[CL_C_OFF], cr_json_int(pj, jl[0], G_BLOCK, "off_canvas" as *u8), ctr)
          gv_check_eq("T8d-live-self-grade-MM-reproduced" as *u8, critL[CL_C_MM], cr_json_int(pj, jl[0], G_BLOCK, "mark_overlaps" as *u8), ctr)
          gv_check_eq("T8e-live-self-grade-spread-reproduced" as *u8, critL[CL_C_SPREAD], cr_json_int(pj, jl[0], G_BLOCK, "spread_permil" as *u8), ctr)
          live_pub_defects = cr_json_int(pj, jl[0], G_BLOCK, "defects" as *u8)
          if font_present == 1 {
              let critLm: *i64 = g_grade(recL, namesL, nL, fhr, fhb)
              live_metric_defects = critLm[CL_C_DEFECTS]
          }
      }
  } }
  gv_values_head()
  gv_kv("font_present" as *u8, font_present)
  gv_kv("nishi_heuristic_w_px" as *u8, G_TW_NISHI)
  gv_kv("nishi_metric_w_px" as *u8, w_nishi)
  gv_kv("marginalia_metric_w_px" as *u8, w_marg)
  gv_kv("live_page_present" as *u8, live_present)
  gv_kv("live_labels" as *u8, live_labels)
  gv_kv("live_published_defects" as *u8, live_pub_defects)
  gv_kv("live_metric_defects" as *u8, live_metric_defects)
  return gv_verdict("nx_cdmap_referee_gate" as *u8, ctr, "the position map's second ruler: the SVG re-derivation, the real-font re-measurement and both critics, with the live page cross-checked when it is on disk" as *u8)
237}
nx_cdmap_referee_gate.nx source

`nx_cdmap_referee_gate.nx` source
