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

↩ module page · 288 lines · 18995 B
1// nx_ttf_fontlib_gate.nx -- gate for the sovereign TTF font ENGINE LIBRARY (the browser's text renderer).
2// Proves: real load of our emitted nishi_sans.ttf; glyph rasterization with genuine ANTI-ALIASING
3// (intermediate coverage levels -- the visual difference vs the 1-bit 8x8 bitmap); REAL proportional
4// metrics from hmtx ('i' narrower than 'm'); FULL-ASCII coverage incl the NEW punctuation; the
5// per-(char,size) cache returns the identical record; the RGBA framebuffer alpha-blend puts ink on the
6// canvas. NEG: a missing font file refuses to load; an out-of-range char yields no glyph.
7// expect_exit: 0   license_tier: ORIGINAL
8import "nx_ttf_fontlib.nx"
9import "nx_gate_verdict.nx"
10
11func g_puts(s: *u8) -> i64 { var n: i64=0; while s[n]!=(0 as u8){n=n+1} sys_write(1,s,n); return 0 }
12// big-endian u16 writer for the runtime-synthesised cmap fixture (T20)
13func tfg_w16(b: *u8, o: i64, v: i64) -> i64 { b[o] = ((v / 256) % 256) as u8; b[o+1] = (v % 256) as u8; return o + 2 }
14func g_num(v: i64) -> i64 { let b: *u8=sys_mmap(28); var m: i64=v; if m<0{m=0-m;sys_write(1,"-" as *u8,1)} let t: *u8=sys_mmap(28); 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{b[i]=t[k-1-i];i=i+1} sys_write(1,b,k); return 0 }
15
16func main() -> i64 {
  g_puts("TTF-FONTLIB gate: the sovereign font engine library (nishi_sans.ttf full-ASCII -> AA glyphs -> RGBA blend)\n" as *u8)
  var pass: i64=0
  var ttl: i64=0
  let ctr__dry: *i64 = gv_ctr()
21
  // The house-font half needs our emitted web_assets/nishi_sans.ttf. Where it is absent (the NAS serving
  // root carries only web_assets/nishi.ttf) that is a PRECONDITION, not a failure of the engine: the old
  // code exited RED here and so could never reach the professional-face teeth on the one host that
  // publishes. gv_need makes it SKIP, and the Liberation half below runs on its own fixture.
  let fh: *i64 = tf_load("web_assets/nishi_sans.ttf\x00" as *u8)
  var hpresent: i64 = 0
  if fh != (0 as *i64) { hpresent = 1 }
  if gv_need("fixture web_assets/nishi_sans.ttf (our emitted house font, 96 glyphs, 1000 upem)" as *u8, hpresent, ctr__dry) == 1 {
  ttl=ttl+1; g_puts("  T1 loads our emitted nishi_sans.ttf (glyf/loca/head/cmap/hhea/hmtx all found): " as *u8)
  pass=pass+1; g_puts("PASS\n" as *u8)
32
  // 'A' at 32px
  let recA: *i64 = tf_glyph(fh, 65, 32)
  var solid: i64=0
  var mid: i64=0
  if recA != (0 as *i64) {
      let cov: *u8 = recA[0] as *u8
      let cw: i64 = recA[1]
      let chh: i64 = recA[2]
      var i: i64=0
      while i < cw*chh {
          let a: i64 = cov[i] as i64
          if a >= 240 { solid=solid+1 }
          if a >= 24 { if a <= 216 { mid=mid+1 } }
          i=i+1
      }
  }
  ttl=ttl+1; g_puts("  T2 'A'@32px rasterizes (solid pixels " as *u8); g_num(solid); g_puts(" > 60): " as *u8)
  if solid > 60 { pass=pass+1; g_puts("PASS\n" as *u8) } else { g_puts("FAIL\n" as *u8) }
  ttl=ttl+1; g_puts("  T3 GENUINE ANTI-ALIASING (intermediate coverage pixels " as *u8); g_num(mid); g_puts(" > 20; the 1-bit bitmap has 0): " as *u8)
  if mid > 20 { pass=pass+1; g_puts("PASS\n" as *u8) } else { g_puts("FAIL\n" as *u8) }
53
  // proportional metrics from hmtx
  let advi: i64 = tf_char_adv(fh, 105, 32)      // 'i'
  let advm: i64 = tf_char_adv(fh, 109, 32)      // 'm'
  ttl=ttl+1; g_puts("  T4 REAL proportional metrics ('i'=" as *u8); g_num(advi); g_puts("px < 'm'=" as *u8); g_num(advm); g_puts("px): " as *u8)
  if advi > 0 { if advi < advm { pass=pass+1; g_puts("PASS\n" as *u8) } else { g_puts("FAIL\n" as *u8) } } else { g_puts("FAIL\n" as *u8) }
59
  // NEW punctuation present ('.' ',' '(' '?' each rasterize ink)
  var punct_ok: i64=1
  let plist: *i64 = sys_mmap(64) as *i64
  plist[0]=46; plist[1]=44; plist[2]=40; plist[3]=63; plist[4]=58; plist[5]=47
  var pi: i64=0
  while pi<6 {
      let rp: *i64 = tf_glyph(fh, plist[pi], 24)
      var ink: i64=0
      if rp != (0 as *i64) { let cv: *u8=rp[0] as *u8; var q: i64=0; while q<rp[1]*rp[2] { if (cv[q] as i64)>128 { ink=ink+1 } q=q+1 } }
      if ink < 4 { punct_ok=0 }
      pi=pi+1
  }
  ttl=ttl+1; g_puts("  T5 FULL-ASCII punctuation rasterizes (. , ( ? : / all have ink): " as *u8)
  if punct_ok==1 { pass=pass+1; g_puts("PASS\n" as *u8) } else { g_puts("FAIL\n" as *u8) }
74
  // cache identity
  let recA2: *i64 = tf_glyph(fh, 65, 32)
  ttl=ttl+1; g_puts("  T6 per-(char,size) cache returns the identical record: " as *u8)
  if (recA2 as i64) == (recA as i64) { pass=pass+1; g_puts("PASS\n" as *u8) } else { g_puts("FAIL\n" as *u8) }
79
  // RGBA blend draw
  let W: i64=220
  let H: i64=40
  let fb: *Framebuffer = sys_mmap(NX_FRAMEBUFFER_BYTES) as *Framebuffer
  let px: *u8 = sys_mmap(W*H*4+16)
  nx_framebuffer_init(fb, px, W, H)
  var wi: i64=0
  while wi<W*H { px[wi*4]=255 as u8; px[wi*4+1]=255 as u8; px[wi*4+2]=255 as u8; px[wi*4+3]=255 as u8; wi=wi+1 }
  let adv: i64 = tf_draw_text(fh, fb, 4, 4, "Nishi, s-class! (AA)\x00" as *u8, 20, 24, 20, 20, 40, 0)
  var dark: i64=0
  var gray: i64=0
  var k: i64=0
  while k<W*H { let r: i64=px[k*4] as i64; if r<80 { dark=dark+1 } if r>=80 { if r<=200 { gray=gray+1 } } k=k+1 }
  ttl=ttl+1; g_puts("  T7 RGBA alpha-blend draw (advance " as *u8); g_num(adv); g_puts("px, dark " as *u8); g_num(dark); g_puts(" > 150, AA-gray " as *u8); g_num(gray); g_puts(" > 60): " as *u8)
  if adv > 100 { if dark > 150 { if gray > 60 { pass=pass+1; g_puts("PASS\n" as *u8) } else { g_puts("FAIL\n" as *u8) } } else { g_puts("FAIL\n" as *u8) } } else { g_puts("FAIL\n" as *u8) }
95
  // regression guard for the STEM-CLIP bug: 'l' is a pure vertical stem whose ink sits near the RIGHT of
  // its coverage box; the old draw clipped at natural-advance and dropped it. Render "llll" -> must have ink.
  let W2: i64=80
  let H2: i64=30
  let fb2: *Framebuffer = sys_mmap(NX_FRAMEBUFFER_BYTES) as *Framebuffer
  let px2: *u8 = sys_mmap(W2*H2*4+16)
  nx_framebuffer_init(fb2, px2, W2, H2)
  var w2i: i64=0
  while w2i<W2*H2 { px2[w2i*4]=255 as u8; px2[w2i*4+1]=255 as u8; px2[w2i*4+2]=255 as u8; px2[w2i*4+3]=255 as u8; w2i=w2i+1 }
  tf_draw_text(fh, fb2, 4, 4, "illi\x00" as *u8, 4, 20, 0, 0, 0, 18)
  var stemdark: i64=0
  var k2: i64=0
  while k2<W2*H2 { if (px2[k2*4] as i64)<100 { stemdark=stemdark+1 } k2=k2+1 }
  ttl=ttl+1; g_puts("  T8 STEM-CLIP regression: 'illi' stems render (dark " as *u8); g_num(stemdark); g_puts(" > 40): " as *u8)
  if stemdark > 40 { pass=pass+1; g_puts("PASS\n" as *u8) } else { g_puts("FAIL\n" as *u8) }
111
  // NEG: missing file
  let bad: *i64 = tf_load("web_assets/__no_such_font__.ttf\x00" as *u8)
  ttl=ttl+1; g_puts("  T9 NEG: missing font file refuses to load: " as *u8)
  if bad == (0 as *i64) { pass=pass+1; g_puts("PASS\n" as *u8) } else { g_puts("FAIL\n" as *u8) }
  // NEG: out-of-range char
  let recX: *i64 = tf_glyph(fh, 9999, 24)
  ttl=ttl+1; g_puts("  T10 NEG: out-of-range char yields no glyph: " as *u8)
  if recX == (0 as *i64) { pass=pass+1; g_puts("PASS\n" as *u8) } else { g_puts("FAIL\n" as *u8) }
120
  }   // end of the house-font half
  g_puts("TTF-FONTLIB-GATE house-font teeth passed " as *u8); g_num(pass); g_puts("/" as *u8); g_num(ttl); g_puts("\n" as *u8)
  // MIGRATED onto nx_gate_verdict by nx_gate_dry_apply (D001, minimal form): every check
  // row above is untouched, so the PASS/FAIL vector cannot change; only the hand-rolled
  // verdict emission is replaced by the ONE shared base class. Proven by nx_gate_migrate verify.
  ctr__dry[0] = ctr__dry[0] + pass
  ctr__dry[1] = ctr__dry[1] + ttl
128
  // ---- 2026-09-02, BR4 first half (/compare/browser "Real font files + shaping"): the engine reads a
  // PROFESSIONAL face and every metric is READ, never assumed. Liberation Sans (SIL-OFL, 2048 upem,
  // 908 kern pairs, 1,076 composites) is the fixture; absent = SKIP via gv_need, never RED.
  // TWO candidate paths, one fixture: the laptop tree ships it under web_assets/fonts/, the NAS lands it
  // under knowledge/fonts/ (the only durable directory the sovereign write boundary admits), via the
  // pinned mirror knowledge/fetched/cmp_browser_liberation-fonts-ttf-2.1.5.tar.gz and nx_untar.
  var lf: *i64 = tf_load("web_assets/fonts/LiberationSans-Regular.ttf\x00" as *u8)
  if lf == (0 as *i64) { lf = tf_load("knowledge/fonts/LiberationSans-Regular.ttf\x00" as *u8) }
  var lpresent: i64 = 0
  if lf != (0 as *i64) { lpresent = 1 }
  if gv_need("fixture LiberationSans-Regular.ttf under web_assets/fonts/ or knowledge/fonts/ (Liberation Sans 2.1.5, SIL-OFL)" as *u8, lpresent, ctr__dry) == 1 {
      g_puts("  face: upem=" as *u8); g_num(tf_upem(lf)); g_puts(" asc=" as *u8); g_num(tf_asc(lf)); g_puts(" desc=" as *u8); g_num(tf_desc(lf))
      g_puts(" kern_pairs=" as *u8); g_num(tf_kern_count(lf)); g_puts(" glyphs=" as *u8); g_num(tf_nglyphs(lf)); g_puts("\n" as *u8)
      // T11: unitsPerEm is READ from head. The first cut assumed 1000; this face is 2048, so a
      // 1000-assumption would rasterize at half size and halve every advance -- silently.
      var t11: i64 = 0
      if tf_upem(lf) == 2048 { t11 = 1 }
      gv_check("T11-unitsPerEm-READ-from-head-is-2048-not-the-old-assumed-1000" as *u8, t11, ctr__dry)
      // T12: ascender/descender READ from hhea (1854 / -434 in this face; the old code hard-coded 760)
      var t12: i64 = 0
      if tf_asc(lf) == 1854 { if tf_desc(lf) == (0 - 434) { t12 = 1 } }
      gv_check("T12-ascender-descender-READ-from-hhea-1854-and-minus-434" as *u8, t12, ctr__dry)
      // T13: the 1000-em advances reproduce the estate's hand-baked oracle table (font_adv_em_base_oracle,
      // generated from this very file on 2026-07-29): space 277, i 222, m 833, W 943. Two rulers agreeing
      // is what licenses retiring the baked one.
      g_puts("  adv_em1000: space=" as *u8); g_num(tf_adv_em1000(lf, 32)); g_puts(" i=" as *u8); g_num(tf_adv_em1000(lf, 105))
      g_puts(" m=" as *u8); g_num(tf_adv_em1000(lf, 109)); g_puts(" W=" as *u8); g_num(tf_adv_em1000(lf, 87)); g_puts("\n" as *u8)
      var t13: i64 = 0
      if tf_adv_em1000(lf, 32) == 277 { if tf_adv_em1000(lf, 105) == 222 { if tf_adv_em1000(lf, 109) == 833 { if tf_adv_em1000(lf, 87) == 943 { t13 = 1 } } } }
      gv_check("T13-hmtx-1000em-advances-reproduce-the-banked-oracle-table-space277-i222-m833-W943" as *u8, t13, ctr__dry)
      // T14: pair kerning from the kern table: A,V is negative (pulls closer) and equals V,A in this
      // face; the neg control i,i has no pair and reads exactly 0.
      let kav: i64 = tf_kern_em1000(lf, 65, 86)
      let kva: i64 = tf_kern_em1000(lf, 86, 65)
      let kii: i64 = tf_kern_em1000(lf, 105, 105)
      g_puts("  kern_em1000: AV=" as *u8); g_num(kav); g_puts(" VA=" as *u8); g_num(kva); g_puts(" ii=" as *u8); g_num(kii); g_puts("\n" as *u8)
      var t14: i64 = 0
      if kav < 0 { if kav == kva { t14 = 1 } }
      gv_check("T14-kern-table-pair-AV-is-negative-and-equals-VA" as *u8, t14, ctr__dry)
      var t14b: i64 = 0
      if kii == 0 { t14b = 1 }
      gv_check("T14b-neg-control-unkerned-pair-ii-reads-exactly-0" as *u8, t14b, ctr__dry)
      // T15: 'A' at 32px has an ink height of capHeight*32/upem = 1409*32/2048 = 22 rows (+-2). Under
      // the old 1000-upem assumption the outline sampled at twice the scale and the cap would read ~44
      // rows clipped by the cell -- this tooth is what the upem fix changes.
      let recA32: *i64 = tf_glyph(lf, 65, 32)
      var inkrows: i64 = 0
      var lm_A: i64 = 0 - 1
      if recA32 != (0 as *i64) {
          let cov: *u8 = recA32[TF_R_COV] as *u8
          let cw: i64 = recA32[TF_R_CW]
          let chh: i64 = recA32[TF_R_CHH]
          lm_A = recA32[TF_R_LM]
          var ry: i64 = 0
          while ry < chh {
              var any: i64 = 0
              var rx: i64 = 0
              while rx < cw { if (cov[ry*cw+rx] as i64) >= 128 { any = 1 } rx = rx + 1 }
              inkrows = inkrows + any
              ry = ry + 1
          }
      }
      let want_cap: i64 = (1409*32)/2048
      g_puts("  'A'@32px ink rows=" as *u8); g_num(inkrows); g_puts(" want~" as *u8); g_num(want_cap); g_puts("\n" as *u8)
      var t15: i64 = 0
      if inkrows >= want_cap - 2 { if inkrows <= want_cap + 2 { t15 = 1 } }
      gv_check("T15-A-at-32px-ink-height-is-capHeight-scaled-by-the-READ-upem-22rows" as *u8, t15, ctr__dry)
      // T16: COMPOSITE glyph decodes: e-acute (U+00E9) is a composite of 'e' + acute in this face, so its
      // edge count must exceed 'e' alone (which must itself be non-zero).
      let ex0: *i64 = sys_mmap(8*TF_MAXE) as *i64
      let ey0: *i64 = sys_mmap(8*TF_MAXE) as *i64
      let ex1: *i64 = sys_mmap(8*TF_MAXE) as *i64
      let ey1: *i64 = sys_mmap(8*TF_MAXE) as *i64
      let lb: *u8 = lf[TF_H_BUF] as *u8
      let ne_e: i64 = tf_glyph_edges(lb, lf[TF_H_GLYF], lf[TF_H_LOCA], lf[TF_H_LOCFMT], lf[TF_H_NGLYPHS], tf_gid(lf, 101), ex0, ey0, ex1, ey1)
      let ne_ea: i64 = tf_glyph_edges(lb, lf[TF_H_GLYF], lf[TF_H_LOCA], lf[TF_H_LOCFMT], lf[TF_H_NGLYPHS], tf_gid(lf, 233), ex0, ey0, ex1, ey1)
      g_puts("  edges: e=" as *u8); g_num(ne_e); g_puts(" e-acute(composite)=" as *u8); g_num(ne_ea); g_puts("\n" as *u8)
      var t16: i64 = 0
      if ne_e > 0 { if ne_ea > ne_e { t16 = 1 } }
      gv_check("T16-composite-glyph-e-acute-decodes-with-more-edges-than-e-alone" as *u8, t16, ctr__dry)
      // T17: a NEGATIVE left side bearing ('j' xMin=-50 in this face) is carried as a left margin so no
      // ink is clipped; 'A' (xMin>0) carries none -- both directions of the record.
      let recJ: *i64 = tf_glyph(lf, 106, 32)
      var lm_j: i64 = 0 - 1
      if recJ != (0 as *i64) { lm_j = recJ[TF_R_LM] }
      g_puts("  left margin px @32: j=" as *u8); g_num(lm_j); g_puts(" A=" as *u8); g_num(lm_A); g_puts("\n" as *u8)
      var t17: i64 = 0
      if lm_j > 0 { if lm_A == 0 { t17 = 1 } }
      gv_check("T17-negative-lsb-j-carries-a-left-margin-and-A-carries-none" as *u8, t17, ctr__dry)
      // T18: ink wider than the advance ('f' xMax=572 vs aw=569) WIDENS the cell instead of being cut
      let recF: *i64 = tf_glyph(lf, 102, 64)
      var t18: i64 = 0
      if recF != (0 as *i64) { if recF[TF_R_CW] > recF[TF_R_ADV] + 2 { t18 = 1 } }
      gv_check("T18-f-ink-past-its-advance-widens-the-cell-not-clipped" as *u8, t18, ctr__dry)
      // T19: the cell height is DERIVED from (ascender - descender) at the READ upem
      let recW: *i64 = tf_glyph(lf, 87, 32)
      var t19: i64 = 0
      if recW != (0 as *i64) { if recW[TF_R_CHH] == tf_content_px(lf, 32) + 1 { t19 = 1 } }
      gv_check("T19-cell-height-is-ascender-minus-descender-at-the-READ-upem" as *u8, t19, ctr__dry)
  }
  // T20: the cmap format-4 glyphIdArray path (idRangeOffset != 0), which the first cut returned 0 for.
  // Neither fixture uses it, so the subtable is SYNTHESISED at runtime: 2 segments, A..C via a
  // glyphIdArray of [10, 0, 30] with idDelta 5 -> A=15, B=.notdef (0 is NOT offset), C=35; '@' is
  // outside every segment -> 0.
  let syn: *u8 = sys_mmap(64)
  var so: i64 = 0
  so = tfg_w16(syn, so, 4)        // format
  so = tfg_w16(syn, so, 38)       // length
  so = tfg_w16(syn, so, 0)        // language
  so = tfg_w16(syn, so, 4)        // segCountX2 (2 segments)
  so = tfg_w16(syn, so, 4)        // searchRange (unused by the reader)
  so = tfg_w16(syn, so, 1)        // entrySelector
  so = tfg_w16(syn, so, 0)        // rangeShift
  so = tfg_w16(syn, so, 67)       // endCode[0] = 'C'
  so = tfg_w16(syn, so, 65535)    // endCode[1]
  so = tfg_w16(syn, so, 0)        // reservedPad
  so = tfg_w16(syn, so, 65)       // startCode[0] = 'A'
  so = tfg_w16(syn, so, 65535)    // startCode[1]
  so = tfg_w16(syn, so, 5)        // idDelta[0]
  so = tfg_w16(syn, so, 1)        // idDelta[1]
  so = tfg_w16(syn, so, 4)        // idRangeOffset[0] = distance from &idRangeOffset[0] to glyphIdArray[0]
  so = tfg_w16(syn, so, 0)        // idRangeOffset[1]
  so = tfg_w16(syn, so, 10)       // glyphIdArray[0] -> 'A'
  so = tfg_w16(syn, so, 0)        // glyphIdArray[1] -> 'B' = .notdef
  so = tfg_w16(syn, so, 30)       // glyphIdArray[2] -> 'C'
  let gA: i64 = tf_cmap_lookup(syn, 0, 65)
  let gB: i64 = tf_cmap_lookup(syn, 0, 66)
  let gC: i64 = tf_cmap_lookup(syn, 0, 67)
  let gAt: i64 = tf_cmap_lookup(syn, 0, 64)
  g_puts("  synthetic glyphIdArray cmap: A=" as *u8); g_num(gA); g_puts(" B=" as *u8); g_num(gB); g_puts(" C=" as *u8); g_num(gC); g_puts(" @=" as *u8); g_num(gAt); g_puts("\n" as *u8)
  var t20: i64 = 0
  if gA == 15 { if gC == 35 { t20 = 1 } }
  gv_check("T20-cmap-glyphIdArray-path-resolves-A15-C35-with-idDelta-applied" as *u8, t20, ctr__dry)
  var t20b: i64 = 0
  if gB == 0 { if gAt == 0 { t20b = 1 } }
  gv_check("T20b-neg-control-glyphIdArray-zero-is-notdef-unoffset-and-outside-segments-is-0" as *u8, t20b, ctr__dry)
  // T21: a FOREIGN-VENDOR system face (Microsoft Arial, present on the Windows host under WSL) is metric-
  // compatible with Liberation Sans by design: our parser must read BOTH and agree on all 95 ASCII
  // advances. Disagreement on either side means OUR cmap/hmtx read is wrong, not the fonts.
  // NOT a gv_need: a Windows system face exists on the laptop and never on the NAS, so declaring it a
  // precondition would make this gate SKIP forever on the one host that publishes (measured 2026-09-02:
  // 12/12 Liberation teeth PASSED on the NAS and the verdict still read SKIP). An OPTIONAL witness
  // announces itself either way and only counts where it can run.
  let arial: *i64 = tf_load("/mnt/c/Windows/Fonts/arial.ttf\x00" as *u8)
  var apresent: i64 = 0
  if arial != (0 as *i64) { if lpresent == 1 { apresent = 1 } }
  if apresent == 0 { g_puts("  T21 optional cross-vendor witness NOT RUN: no /mnt/c/Windows/Fonts/arial.ttf on this host (laptop-only, by design)\n" as *u8) }
  if apresent == 1 {
      var agree: i64 = 0
      var ac: i64 = 32
      while ac <= 126 { if tf_adv_em1000(arial, ac) == tf_adv_em1000(lf, ac) { agree = agree + 1 } ac = ac + 1 }
      g_puts("  Arial vs Liberation 1000-em advances agree on " as *u8); g_num(agree); g_puts("/95 ASCII chars (upem " as *u8); g_num(tf_upem(arial)); g_puts(")\n" as *u8)
      var t21: i64 = 0
      if agree == 95 { t21 = 1 }
      gv_check("T21-foreign-vendor-Arial-and-Liberation-agree-on-all-95-ASCII-advances-through-our-parser" as *u8, t21, ctr__dry)
  }
  let rc__dry: i64 = gv_verdict("TTF-FONTLIB-GATE" as *u8, ctr__dry, "the engine reads real faces: every metric from the file, none assumed" as *u8)
  sys_exit(rc__dry)
  return rc__dry
288}
nx_ttf_fontlib_gate.nx source

`nx_ttf_fontlib_gate.nx` source
