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

↩ module page · 1482 lines · 81039 B
1// nx_browser_render.nx -- REUSABLE sovereign CSS render core. Holds nx_browser's OS-AGNOSTIC pipeline:
2// br_layout (HTML body -> CSS cascade -> box/flex/float layout -> LayoutTree + computed styles) and
3// br_draw_fb / br_shot_png (paint the laid-out page into an RGBA framebuffer / PNG). NO X11, NO network --
4// pure compute over sys_mmap, so it compiles into the native-Windows GUI PE exactly as into the WSL/X11
5// browser. The window/blit/input + fetch live in the consumers. CSS-on-native-Windows arc R2.
6// NOTE (R3 dedup pending): these fns are still ALSO defined in runtime/_hdl_build/nx_browser.nx; once this
7// organ is proven, nx_browser.nx imports this and drops its copies. license_tier: ORIGINAL
8import "nx_syscalls.nx"
9import "nx_font8x8.nx"
10import "nx_html_tokenizer.nx"
11import "nx_dom_query.nx"
12import "nx_html_entities.nx"
13import "nx_render_html.nx"
14import "nx_css_color_decode.nx"
15import "nx_layout_box.nx"
16import "nx_layout_default_display.nx"
17import "nx_layout_from_dom.nx"
18import "nx_layout_block.nx"
19import "nx_paint_solid_rect.nx"
20import "nx_paint_text.nx"
21import "nx_png_write.nx"
22import "nx_font.nx"          // sovereign stroke-VECTOR font (modern heading typeface) + metrics
23import "nx_aa_raster.nx"     // AA contour rasterizer for the vector glyphs
24
25struct Page {
  buf: *u8,
  tree: *LayoutTree,
  computed: *CssComputedDecl,
  ncomp: i64,
  page_h: i64,
  bhref_off: *i64,           // per box_idx: href byte-offset into buf, or -1
  bhref_len: *i64,
  ok: i64,
  raw: *u8,                  // fetched response body (kept so resize can re-layout WITHOUT re-fetching)
  raw_len: i64,
  bsrc_off: *i64,            // per box_idx: <img src> byte-offset into buf, or -1
  bsrc_len: *i64,
  bimg: *i64,                // per box_idx: decoded RGB (w*h*3) pointer, or 0 (filled by the consumer)
  bimg_w: *i64,              // per box_idx: decoded image width
  bimg_h: *i64,              // per box_idx: decoded image height
  find_ptr: i64,             // FIND-IN-PAGE: search-term bytes (as i64 ptr), 0 = no active find
  find_len: i64,             // search-term length
  vec_headings: i64,         // 1 = paint headings with the sovereign stroke-VECTOR font (modern typeface);
                             //     0 = bitmap (default; native-GUI 60fps stays alloc-free). Set by once-render organs.
  dark_mode: i64,            // 1 = dark reader theme (the OLED look): dark bg + light text default stylesheet.
                             //     Set BEFORE br_layout (it selects the injected default CSS). 0 = light (default).
  bcanvas: *i64              // per box_idx: 1 = <canvas> -- a FIRST-CLASS SOURCELESS render surface (seq103):
                             //     the consumer fills page.bimg[i]/bimg_w/bimg_h each FRAME and repaints; the
                             //     image pass blits the CURRENT buffer at the laid-out box (the game substrate).
50}
51const NX_PAGE_BYTES: i64 = 160
52const NX_CHROME_H: i64 = 44      // browser chrome (toolbar + address bar) height; page viewport is below it
53
54func br_slen(s: *u8) -> i64 { var k: i64=0; while s[k]!=(0 as u8){k=k+1} return k }
55
56// ---- PER-BOX COMPUTED-DECL INDEX (the eagler paint-cliff fix): br_comp_* used to scan ALL ncomp decls
57// per lookup, per box, per ancestor hop -- O(boxes x ancestors x ncomp) exploded on Next.js-scale CSS
58// (layout <20s, paint >170s). br_cidx_build buckets the computed array BY ELEMENT (stable copy = cascade
59// order preserved within each element, so reverse scan = the same last-wins winner), and every br_comp_*
60// then scans only that box's bucket. OFF by default (statics 0) -> gates with hand-built arrays are
61// byte-identical; br_layout switches it off during its run and rebuilds at the end. ----
62static br_cidx_on: i64
63static br_cidx_arr: i64        // *CssComputedDecl grouped copy (alloc once, reused)
64static br_cidx_first: i64      // *i64 per box: bucket start
65static br_cidx_cnt: i64        // *i64 per box: bucket len
66static br_cidx_cur: i64        // *i64 scratch cursor
67static br_cidx_nbox: i64
68static br_cidx_src: i64        // the computed-array pointer the index was built FROM: every window guard
                             // checks it, so querying a DIFFERENT page's array (multi-page gates) falls
                             // back to the full scan instead of reading a stale index (self-validating)
71
72func br_cidx_build(tree: *LayoutTree, computed: *CssComputedDecl, ncomp: i64) -> i64 {
  let nbox: i64 = tree.count
  if br_cidx_arr == 0 {
      br_cidx_arr = sys_mmap((NX_CSS_COMPUTED_DECL_BYTES * 262144) as nx_size) as i64
      br_cidx_first = sys_mmap((16384 * 8) as nx_size) as i64
      br_cidx_cnt = sys_mmap((16384 * 8) as nx_size) as i64
      br_cidx_cur = sys_mmap((16384 * 8) as nx_size) as i64
  }
  if nbox > 16384 { br_cidx_on = 0; return 0 }
  if ncomp > 262144 { br_cidx_on = 0; return 0 }
  let ff: *i64 = br_cidx_first as *i64
  let cc: *i64 = br_cidx_cnt as *i64
  let cu: *i64 = br_cidx_cur as *i64
  var i: i64 = 0
  while i < nbox { cc[i] = 0; i = i + 1 }
  var j: i64 = 0
  while j < ncomp {
      let cd: *CssComputedDecl = ((computed as i64) + j * NX_CSS_COMPUTED_DECL_BYTES) as *CssComputedDecl
      let e: i64 = cd.element_idx
      if e >= 0 { if e < nbox { cc[e] = cc[e] + 1 } }
      j = j + 1
  }
  var acc: i64 = 0
  i = 0
  while i < nbox { ff[i] = acc; cu[i] = acc; acc = acc + cc[i]; i = i + 1 }
  // stable grouped copy (struct copy field-by-field; 64B decls)
  let dst0: i64 = br_cidx_arr
  j = 0
  while j < ncomp {
      let cd2: *CssComputedDecl = ((computed as i64) + j * NX_CSS_COMPUTED_DECL_BYTES) as *CssComputedDecl
      let e2: i64 = cd2.element_idx
      if e2 >= 0 { if e2 < nbox {
          let dp: *CssComputedDecl = (dst0 + cu[e2] * NX_CSS_COMPUTED_DECL_BYTES) as *CssComputedDecl
          dp.element_idx = cd2.element_idx
          dp.prop_off = cd2.prop_off
          dp.prop_len = cd2.prop_len
          dp.val_kind = cd2.val_kind
          dp.val_off = cd2.val_off
          dp.val_len = cd2.val_len
          dp.unit_off = cd2.unit_off
          dp.unit_len = cd2.unit_len
          cu[e2] = cu[e2] + 1
      } }
      j = j + 1
  }
  br_cidx_nbox = nbox
  br_cidx_src = computed as i64
  br_cidx_on = 1
  return 0
121}
122func br_comp_int(src: *u8, computed: *CssComputedDecl, ncomp: i64, box_idx: i64, prop: *u8, plen: i64, dflt: i64) -> i64 {
  var base: i64 = computed as i64
  var lo: i64 = 0
  var hi: i64 = ncomp
  if br_cidx_on == 1 { if (computed as i64) == br_cidx_src { if box_idx >= 0 { if box_idx < br_cidx_nbox {
      let ff: *i64 = br_cidx_first as *i64
      let cc: *i64 = br_cidx_cnt as *i64
      base = br_cidx_arr
      lo = ff[box_idx]
      hi = lo + cc[box_idx]
  } } } }
  var j: i64 = hi - 1
  while j >= lo {
      let cd: *CssComputedDecl = (base + j * NX_CSS_COMPUTED_DECL_BYTES) as *CssComputedDecl
      if cd.element_idx == box_idx { if cd.prop_len == plen {
          var ok: i64 = 1; var k: i64 = 0
          while k < plen { if (src[cd.prop_off+k]&0xff) != (prop[k]&0xff) { ok=0; k=plen } else { k=k+1 } }
          if ok == 1 {
              // integer-truncate at the decimal point ("13.5px" is 13, NOT 135 -- the same skip-the-dot
              // digit-accumulator bug fixed in _layout_fontsize_decl_px; measure==paint requires both)
              var v: i64 = 0; var any: i64 = 0; var i: i64 = 0
              while i < cd.val_len {
                  let c: i64 = src[cd.val_off+i]&0xff
                  if c == 46 { i = cd.val_len }
                  else { if c>=48 { if c<=57 { v=v*10+(c-48); any=1 } } i=i+1 }
              }
              if any == 1 { return v }
              return dflt
          }
      } }
      j = j - 1
  }
  return dflt
155}
156func br_comp_color(src: *u8, computed: *CssComputedDecl, ncomp: i64, box_idx: i64, prop: *u8, plen: i64) -> i64 {
  var base: i64 = computed as i64
  var lo: i64 = 0
  var hi: i64 = ncomp
  if br_cidx_on == 1 { if (computed as i64) == br_cidx_src { if box_idx >= 0 { if box_idx < br_cidx_nbox {
      let ff: *i64 = br_cidx_first as *i64
      let cc: *i64 = br_cidx_cnt as *i64
      base = br_cidx_arr
      lo = ff[box_idx]
      hi = lo + cc[box_idx]
  } } } }
  var j: i64 = hi - 1
  while j >= lo {
      let cd: *CssComputedDecl = (base + j * NX_CSS_COMPUTED_DECL_BYTES) as *CssComputedDecl
      if cd.element_idx == box_idx { if cd.prop_len == plen {
          var ok: i64 = 1; var k: i64 = 0
          while k < plen { if (src[cd.prop_off+k]&0xff) != (prop[k]&0xff) { ok=0; k=plen } else { k=k+1 } }
          if ok == 1 {
              let col: *CssColor = (sys_mmap(NX_CSS_COLOR_BYTES as nx_size)) as *CssColor
              var got: i64 = 0
              if cd.val_kind == NX_CSS_VAL_HEXCOLOR { got = nx_css_color_decode(src, cd.val_off, cd.val_len, col) }
              else { if cd.val_kind == NX_CSS_VAL_IDENT { got = nx_css_color_named(src, cd.val_off, cd.val_len, col); if got != 1 { got = nx_css_color_rgb_func(src, cd.val_off, cd.val_len, col) } } }
              if got == 1 { if col.a >= 128 { return (col.r << 16) | (col.g << 8) | col.b } }   // SOLID painter: <50% alpha = tint, not paint (linkedin rgba(0,0,0,0.08) painted BLACK, 2026-07-28)
              return 0 - 1
          }
      } }
      j = j - 1
  }
  return 0 - 1
185}
186
187// INHERITED color resolve (CSS: `color` inherits): walk up the parent chain to the nearest box with a
188// computed color decl. Without this, author colors on body/.doc never reached p/li/td TEXT (the UA sheet
189// only "worked" because it fakes inheritance with explicit p{color}/li{color} rules -- measured 07-09).
190// FONT-SIZE resolver for one element: matches `font-size` (integer-truncating parse) OR the `font`
191// SHORTHAND when the value leads with a size ("15px/1.55 system-ui") -- one bucketed reverse scan across
192// both = last-wins cascade between them. MIRRORS _layout_fontsize_decl_px exactly (measure==paint law).
193// `pct_out[0]` <- 1 when the declared value is a PERCENTAGE; the return is then the percentage
194// number itself, which br_comp_fontsize_inh resolves against the parent. Mirrors the layout-side
195// _layout_fontsize_decl_px signature exactly (measure==paint law: if only one side learned about
196// percentages, every styled run would overflow its reserved box and split mid-word).
197func br_comp_fontsize_own(src: *u8, computed: *CssComputedDecl, ncomp: i64, box_idx: i64, pct_out: *i64) -> i64 {
  var base: i64 = computed as i64
  var lo: i64 = 0
  var hi: i64 = ncomp
  if br_cidx_on == 1 { if (computed as i64) == br_cidx_src { if box_idx >= 0 { if box_idx < br_cidx_nbox {
      let ff: *i64 = br_cidx_first as *i64
      let cc: *i64 = br_cidx_cnt as *i64
      base = br_cidx_arr
      lo = ff[box_idx]
      hi = lo + cc[box_idx]
  } } } }
  var j: i64 = hi - 1
  while j >= lo {
      let cd: *CssComputedDecl = (base + j * NX_CSS_COMPUTED_DECL_BYTES) as *CssComputedDecl
      if cd.element_idx == box_idx {
          if cd.prop_len == 4 { if br_prop_eq(src, cd.prop_off, "font\x00" as *u8, 4) == 1 {
              let c0: i64 = (src[cd.val_off] as i64) & 255
              if c0 >= 48 { if c0 <= 57 {
                  var v4: i64 = 0
                  var j4: i64 = 0
                  var g4: i64 = 1
                  while g4 == 1 {
                      if j4 >= cd.val_len { g4 = 0 }
                      else {
                          let c4: i64 = (src[cd.val_off + j4] as i64) & 255
                          if c4 >= 48 { if c4 <= 57 { v4 = v4 * 10 + (c4 - 48); j4 = j4 + 1 } else { g4 = 0 } } else { g4 = 0 }
                      }
                  }
                  if v4 > 0 { return v4 }
              } }
          } }
          if cd.prop_len == 9 { if br_prop_eq(src, cd.prop_off, "font-size\x00" as *u8, 9) == 1 {
              // ONE value resolver, shared with the measure side (nx_fontsize_value_px lives in
              // nx_layout_block.nx which this file imports): px/%/em/rem/fractions, calc()/keywords
              // dropped (-1) -> fall through to the older cascade decl. measure==paint BY CONSTRUCTION.
              let fv: i64 = nx_fontsize_value_px(src, cd.val_off, cd.val_len, cd.unit_off, cd.unit_len, pct_out)
              if fv >= 0 { return fv }
          } }
      }
      j = j - 1
  }
  return 0 - 1
239}
240// LINE-HEIGHT resolver (paint mirror of _layout_lineheight_decl_px/_layout_lineheight_px -- measure==paint
241// law): `line-height: 1.55` unitless multiplier of fs / `line-height: 24px` / the `font` shorthand's /N.
242// Bucketed reverse scan per element; nearest ancestor with a decl wins. Returns px or -1.
243func br_comp_lineheight_own(src: *u8, computed: *CssComputedDecl, ncomp: i64, box_idx: i64, fs: i64) -> i64 {
  var base: i64 = computed as i64
  var lo: i64 = 0
  var hi: i64 = ncomp
  if br_cidx_on == 1 { if (computed as i64) == br_cidx_src { if box_idx >= 0 { if box_idx < br_cidx_nbox {
      let ff: *i64 = br_cidx_first as *i64
      let cc: *i64 = br_cidx_cnt as *i64
      base = br_cidx_arr
      lo = ff[box_idx]
      hi = lo + cc[box_idx]
  } } } }
  var j: i64 = hi - 1
  while j >= lo {
      let cd: *CssComputedDecl = (base + j * NX_CSS_COMPUTED_DECL_BYTES) as *CssComputedDecl
      if cd.element_idx == box_idx {
          if cd.prop_len == 11 { if br_prop_eq(src, cd.prop_off, "line-height\x00" as *u8, 11) == 1 {
              var nl: i64 = 0
              var ns: i64 = 1
              while ns == 1 {
                  if nl >= cd.val_len { ns = 0 }
                  else {
                      let c: i64 = (src[cd.val_off + nl] as i64) & 255
                      var isn: i64 = 0
                      if c >= 48 { if c <= 57 { isn = 1 } }
                      if c == 46 { isn = 1 }
                      if isn == 1 { nl = nl + 1 } else { ns = 0 }
                  }
              }
              if nl == 0 { return 0 - 1 }
              let q3: i64 = nx_css_number_parse(src, cd.val_off, nl)
              if q3 == NX_CSS_NUMBER_PARSE_ERROR { return 0 - 1 }
              // px unit: DIMENSION tokens carry it in the SEPARATE unit fields (val = digits only);
              // swept spans carry it inline after the digits. Check both. Unitless requires the value
              // to be EXACTLY the number (no trailing unit we don't understand -> miss, not 16x).
              if cd.unit_len == 2 {
                  if ((src[cd.unit_off] as i64) & 255) == 112 { if ((src[cd.unit_off + 1] as i64) & 255) == 120 {
                      return q3 / 1000
                  } }
              }
              if nl + 1 < cd.val_len {
                  if ((src[cd.val_off + nl] as i64) & 255) == 112 { if ((src[cd.val_off + nl + 1] as i64) & 255) == 120 {
                      return q3 / 1000
                  } }
              }
              if cd.unit_len == 0 { if nl == cd.val_len { return (q3 * fs) / 1000 } }
              return 0 - 1
          } }
          if cd.prop_len == 4 { if br_prop_eq(src, cd.prop_off, "font\x00" as *u8, 4) == 1 {
              let c0: i64 = (src[cd.val_off] as i64) & 255
              if c0 >= 48 { if c0 <= 57 {
                  var j2: i64 = 0
                  var sl: i64 = 0 - 1
                  var g: i64 = 1
                  while g == 1 {
                      if j2 >= cd.val_len { g = 0 }
                      else {
                          let cj: i64 = (src[cd.val_off + j2] as i64) & 255
                          if cj == 47 { sl = j2; g = 0 }
                          else { if cj == 32 { g = 0 } else { j2 = j2 + 1 } }
                      }
                  }
                  if sl >= 0 {
                      let vo: i64 = cd.val_off + sl + 1
                      let vmax: i64 = cd.val_len - sl - 1
                      var n2: i64 = 0
                      var g2: i64 = 1
                      while g2 == 1 {
                          if n2 >= vmax { g2 = 0 }
                          else {
                              let c2: i64 = (src[vo + n2] as i64) & 255
                              var isn2: i64 = 0
                              if c2 >= 48 { if c2 <= 57 { isn2 = 1 } }
                              if c2 == 46 { isn2 = 1 }
                              if isn2 == 1 { n2 = n2 + 1 } else { g2 = 0 }
                          }
                      }
                      if n2 > 0 {
                          let q32: i64 = nx_css_number_parse(src, vo, n2)
                          if q32 != NX_CSS_NUMBER_PARSE_ERROR {
                              if n2 + 1 < vmax {
                                  if ((src[vo + n2] as i64) & 255) == 112 { if ((src[vo + n2 + 1] as i64) & 255) == 120 {
                                      return q32 / 1000
                                  } }
                              }
                              return (q32 * fs) / 1000
                          }
                      }
                  }
              } }
          } }
      }
      j = j - 1
  }
  return 0 - 1
337}
338func br_comp_lineheight_px(src: *u8, computed: *CssComputedDecl, ncomp: i64, tree: *LayoutTree, box_idx: i64, fs: i64) -> i64 {
  var cur: i64 = box_idx
  var guard: i64 = 0
  while cur >= 0 {
      if guard > 64 { return 0 - 1 }
      guard = guard + 1
      let v: i64 = br_comp_lineheight_own(src, computed, ncomp, cur, fs)
      if v >= 0 { return v }
      let b: *LayoutBox = ((tree.boxes as i64) + cur * NX_LAYOUT_BOX_BYTES) as *LayoutBox
      cur = b.parent_idx
  }
  return 0 - 1
350}
351// INHERITED font-size: nearest ancestor with a font-size OR font-shorthand decl, else dflt.
352func br_comp_fontsize_inh(src: *u8, computed: *CssComputedDecl, ncomp: i64, tree: *LayoutTree, box_idx: i64, dflt: i64) -> i64 {
  let pct: *i64 = sys_mmap(16) as *i64
  var cur: i64 = box_idx
  var guard: i64 = 0
  while cur >= 0 {
      if guard > 64 { return dflt }
      guard = guard + 1
      pct[0] = 0
      let v: i64 = br_comp_fontsize_own(src, computed, ncomp, cur, pct)
      if v >= 0 {
          if pct[0] == 0 { return v }
          let bp: *LayoutBox = ((tree.boxes as i64) + cur * NX_LAYOUT_BOX_BYTES) as *LayoutBox
          let parent_px: i64 = br_comp_fontsize_inh(src, computed, ncomp, tree, bp.parent_idx, dflt)
          var r: i64 = (parent_px * v) / 100
          if r < 1 { r = 1 }
          return r
      }
      let b: *LayoutBox = ((tree.boxes as i64) + cur * NX_LAYOUT_BOX_BYTES) as *LayoutBox
      cur = b.parent_idx
  }
  return dflt
373}
374func br_comp_color_inh(src: *u8, computed: *CssComputedDecl, ncomp: i64, tree: *LayoutTree, box_idx: i64) -> i64 {
  var cur: i64 = box_idx
  var guard: i64 = 0
  while cur >= 0 {
      if guard > 64 { return 0 - 1 }
      guard = guard + 1
      let c: i64 = br_comp_color(src, computed, ncomp, cur, "color\x00" as *u8, 5)
      if c >= 0 { return c }
      let b: *LayoutBox = ((tree.boxes as i64) + cur * NX_LAYOUT_BOX_BYTES) as *LayoutBox
      cur = b.parent_idx
  }
  return 0 - 1
386}
387
388// background resolve: background-color, else the `background` SHORTHAND's hex value (a single-hex shorthand
389// like background:#eef1f5 tokenizes as HEXCOLOR and decodes; complex shorthands fail closed to -1). bg does
390// NOT inherit in CSS, so no parent walk.
391func br_prop_eq(src: *u8, off: i64, lit: *u8, len: i64) -> i64 {
  var k: i64 = 0
  while k < len { if (src[off+k]&0xff) != (lit[k]&0xff) { return 0 } k=k+1 }
  return 1
395}
396// S21 fix: background must respect CASCADE ORDER across BOTH `background-color` and the `background` shorthand.
397// The old version tried `background-color` first -> the UA sheet's body{background-color:#fff} ALWAYS beat an
398// author body{background:var(--bg)} shorthand -> our dark-theme pages rendered light-text-on-white (invisible).
399// Now: scan from the END (highest cascade) for the LAST decl of EITHER property and decode that.
400func br_comp_bg(src: *u8, computed: *CssComputedDecl, ncomp: i64, box_idx: i64) -> i64 {
  var base: i64 = computed as i64
  var lo: i64 = 0
  var hi: i64 = ncomp
  if br_cidx_on == 1 { if (computed as i64) == br_cidx_src { if box_idx >= 0 { if box_idx < br_cidx_nbox {
      let ff: *i64 = br_cidx_first as *i64
      let cc: *i64 = br_cidx_cnt as *i64
      base = br_cidx_arr
      lo = ff[box_idx]
      hi = lo + cc[box_idx]
  } } } }
  var j: i64 = hi - 1
  while j >= lo {
      let cd: *CssComputedDecl = (base + j * NX_CSS_COMPUTED_DECL_BYTES) as *CssComputedDecl
      if cd.element_idx == box_idx {
          var isbg: i64 = 0
          if cd.prop_len == 16 { if br_prop_eq(src, cd.prop_off, "background-color\x00" as *u8, 16)==1 { isbg=1 } }
          if isbg == 0 { if cd.prop_len == 10 { if br_prop_eq(src, cd.prop_off, "background\x00" as *u8, 10)==1 { isbg=1 } } }
          if isbg == 1 {
              let col: *CssColor = (sys_mmap(NX_CSS_COLOR_BYTES as nx_size)) as *CssColor
              var got: i64 = 0
              if cd.val_kind == NX_CSS_VAL_HEXCOLOR { got = nx_css_color_decode(src, cd.val_off, cd.val_len, col) }
              else { if cd.val_kind == NX_CSS_VAL_IDENT { got = nx_css_color_named(src, cd.val_off, cd.val_len, col); if got != 1 { got = nx_css_color_rgb_func(src, cd.val_off, cd.val_len, col) } } }
              if got == 1 { if col.a >= 128 { return (col.r << 16) | (col.g << 8) | col.b } }   // SOLID painter: <50% alpha = tint, not paint (linkedin rgba(0,0,0,0.08) painted BLACK, 2026-07-28)
              return 0 - 1
          }
      }
      j = j - 1
  }
  return 0 - 1
430}
431
432// `border` SHORTHAND resolve: the computed value is a swept span like "1px solid #cbd5e1" -- parse the
433// leading width int + the #hex color out of the span. Returns the color (wout[0]=width px, clamped 1..8)
434// or -1 when the box has no parseable border. (border-style variants beyond solid paint as solid -- v1.)
435func br_comp_border(src: *u8, computed: *CssComputedDecl, ncomp: i64, box_idx: i64, wout: *i64) -> i64 {
  var base: i64 = computed as i64
  var lo: i64 = 0
  var hi: i64 = ncomp
  if br_cidx_on == 1 { if (computed as i64) == br_cidx_src { if box_idx >= 0 { if box_idx < br_cidx_nbox {
      let ff: *i64 = br_cidx_first as *i64
      let cc: *i64 = br_cidx_cnt as *i64
      base = br_cidx_arr
      lo = ff[box_idx]
      hi = lo + cc[box_idx]
  } } } }
  var j: i64 = hi - 1
  while j >= lo {
      let cd: *CssComputedDecl = (base + j * NX_CSS_COMPUTED_DECL_BYTES) as *CssComputedDecl
      if cd.element_idx == box_idx { if cd.prop_len == 6 {
          let P: *u8 = "border\x00" as *u8
          var ok: i64 = 1
          var k: i64 = 0
          while k < 6 { if (src[cd.prop_off+k]&0xff) != (P[k]&0xff) { ok=0; k=6 } else { k=k+1 } }
          if ok == 1 {
              var wv: i64 = 0
              var i2: i64 = cd.val_off
              let e2: i64 = cd.val_off + cd.val_len
              while i2 < e2 { let ch: i64 = src[i2]&0xff; if ch>=48 { if ch<=57 { wv=wv*10+(ch-48); i2=i2+1 } else { i2=e2 } } else { i2=e2 } }
              if wv <= 0 { wv = 1 }
              if wv > 8 { wv = 8 }
              var hp: i64 = 0 - 1
              var i3: i64 = cd.val_off
              while i3 < e2 { if src[i3]==(35 as u8) { hp=i3; i3=e2 } else { i3=i3+1 } }
              if hp >= 0 {
                  let col: *CssColor = (sys_mmap(NX_CSS_COLOR_BYTES as nx_size)) as *CssColor
                  if nx_css_color_decode(src, hp+1, 6, col) == 1 {
                      wout[0] = wv
                      return (col.r << 16) | (col.g << 8) | col.b
                  }
              }
              return 0 - 1
          }
      } }
      j = j - 1
  }
  return 0 - 1
477}
478
479// Extract elements (tag/id/class) AND per-element href, mirroring rh_extract's chrome-skip EXACTLY (so the
480// element order == the layout box order). ehref_off/ehref_len get the <a href> span, or -1.
481func br_extract(html: *u8, hlen: i64, elements: *CssElement, ehref_off: *i64, ehref_len: *i64, esrc_off: *i64, esrc_len: *i64, maxn: i64) -> i64 {
  let c: *HtmlCursor=sys_mmap(24) as *HtmlCursor; nx_html_cursor_init(c,html,hlen)
  let tok: *HtmlToken=sys_mmap(56) as *HtmlToken
  let ao: *i64=sys_mmap(8) as *i64; let al: *i64=sys_mmap(8) as *i64; let bo: *i64=sys_mmap(8) as *i64; let bl: *i64=sys_mmap(8) as *i64
  let ho: *i64=sys_mmap(8) as *i64; let hl: *i64=sys_mmap(8) as *i64
  var n: i64=0
  var cskip: i64=0
  while 1==1 {
      nx_html_next_token(c,tok)
      if tok.kind==NX_HTML_TOK_EOF { return n }
      if n>=maxn { return n }
      var ie: i64=0
      if cskip > 0 {
          // void START tags never get an END -- exempt from depth (MIRRORS nx_layout_from_dom exactly)
          if tok.kind==NX_HTML_TOK_START_TAG { if _lfd_is_void_tag(html, tok.name_off, tok.name_len) == 0 { cskip = cskip + 1 } }
          if tok.kind==NX_HTML_TOK_END_TAG { cskip = cskip - 1 }
      } else {
          if tok.kind==NX_HTML_TOK_START_TAG {
              if _lfd_is_chrome_start(html, tok.name_off, tok.name_len, tok.src_off, tok.src_len) == 1 { cskip = 1 }
              else { ie = 1 }
          }
          if tok.kind==NX_HTML_TOK_SELF_CLOSING { ie = 1 }
      }
      // RAW-TEXT bodies (script/style/textarea/title) must be consumed with the HTML5 raw-text
      // scanner, EXACTLY as nx_layout_from_dom does -- br_extract was the consumer that forgot.
      // Without this, tag-like text inside a JS string ("<div class=...>") mints PHANTOM elements
      // here that from_dom never boxed, and the positional box<->element pairing in br_layout
      // SKEWS at the first such script: every later box wears the WRONG identity (wrong classes ->
      // wrong widths/heights/colors). Control-probe proven 2026-07-28: one phantom-bearing script
      // before a div shifted even <body> off its own UA padding (x=44 -> 0). The k-map's two
      // walkers must see the SAME element stream, so this mirror is a CORRECTNESS invariant.
      if tok.kind==NX_HTML_TOK_START_TAG {
          if nx_html_is_raw_text_tag(html, tok.name_off, tok.name_len) == 1 {
              let rawtok: *HtmlToken = sys_mmap(56) as *HtmlToken
              nx_html_consume_raw_text(c, ((html as i64) + tok.name_off) as *u8, tok.name_len, rawtok)
              // cursor is left AT the close tag (tokenizer contract) -- the arriving END_TAG token
              // balances cskip naturally, so NO depth fixup here (a fixup would double-decrement).
          }
      }
      if ie==1 {
          let e: *CssElement=((elements as i64)+n*NX_CSS_ELEMENT_BYTES) as *CssElement
          e.src=html; e.tag_off=tok.name_off; e.tag_len=tok.name_len
          if nx_dom_find_attr(html,tok.src_off,tok.src_len,"id\x00" as *u8,ao,al)==1 { e.id_off=ao[0]; e.id_len=al[0] } else { e.id_off=0; e.id_len=0 }
          if nx_dom_find_attr(html,tok.src_off,tok.src_len,"class\x00" as *u8,bo,bl)==1 { e.class_off=bo[0]; e.class_len=bl[0] } else { e.class_off=0; e.class_len=0 }
          ehref_off[n] = 0 - 1; ehref_len[n] = 0 - 1
          if tok.name_len==1 { if (html[tok.name_off]&0xff)==97 {                  // <a>
              if nx_dom_find_attr(html,tok.src_off,tok.src_len,"href\x00" as *u8,ho,hl)==1 { ehref_off[n]=ho[0]; ehref_len[n]=hl[0] }
          } }
          esrc_off[n] = 0 - 1; esrc_len[n] = 0 - 1
          if tok.name_len==3 { if (html[tok.name_off]&0xff)==105 { if (html[tok.name_off+1]&0xff)==109 { if (html[tok.name_off+2]&0xff)==103 {   // <img>
              if nx_dom_find_attr(html,tok.src_off,tok.src_len,"src\x00" as *u8,ho,hl)==1 { esrc_off[n]=ho[0]; esrc_len[n]=hl[0] }
          } } } }
          n=n+1
      }
  }
  return n
537}
538
539// layout-only pass: (re)build the style buffer + lay out page.raw at viewport width `vw`.
540// Split from the fetch so a window RESIZE re-lays-out at the new width with NO network round-trip.
541func br_layout(page: *Page, vw: i64) -> i64 {
  page.ok = 0
  br_cidx_on = 0            // index describes the PREVIOUS layout's array -- off until rebuilt below
  let body: *u8 = page.raw
  let body_len: i64 = page.raw_len
546
  // UA sheet note (07-09): headings + p/li carry NO color -- like real UA sheets they INHERIT body color
  // (br_comp_color_inh), so author header{color:#fff} / body{color:...} reach them. body keeps the default.
  var css: *u8 = "h1{margin-top:30px;margin-bottom:16px;font-size:40px}h2{margin-top:28px;margin-bottom:12px;font-size:28px}h3{margin-top:20px;margin-bottom:8px;font-size:22px}body{background-color:#ffffff;color:#2a2a33;padding-left:44px;padding-right:44px;padding-top:22px}p{margin-top:14px;margin-bottom:14px}ul{padding-left:20px;margin-top:6px;margin-bottom:6px}ol{padding-left:28px;margin-top:6px;margin-bottom:6px}li{margin-bottom:5px}table{display:table}tr{display:flex}th{font-weight:bold;padding-left:4px;padding-right:4px}td{padding-left:4px;padding-right:4px}a{color:#2563eb}b{font-weight:bold}strong{font-weight:bold}i{font-style:italic}em{font-style:italic}.vector-menu-content-list{display:none}.vector-dropdown{display:none}.mw-interlanguage-selector{display:none}.wbc-editpage{display:none}.vector-toc{display:none}.vector-toc-list{display:none}.vector-toc-list-item{display:none}.vector-toc-link{display:none}.vector-page-toolbar{display:none}.infobox{float:right;width:300px;margin-left:8px;background-color:#f7f7fa}.nishi-buyguard{background-color:#fff3cd;color:#332701;padding-left:14px;padding-right:14px;padding-top:8px;padding-bottom:8px;margin-bottom:10px;font-size:18px}\x00"
  // DARK READER THEME (the OLED look): near-black bg + light text; same structure so layout is identical.
  if page.dark_mode == 1 {
      css = "h1{margin-top:30px;margin-bottom:16px;font-size:40px}h2{margin-top:28px;margin-bottom:12px;font-size:28px}h3{margin-top:20px;margin-bottom:8px;font-size:22px}body{background-color:#0e1116;color:#d4dae3;padding-left:44px;padding-right:44px;padding-top:22px}p{margin-top:14px;margin-bottom:14px}ul{padding-left:20px;margin-top:6px;margin-bottom:6px}ol{padding-left:28px;margin-top:6px;margin-bottom:6px}li{margin-bottom:5px}table{display:table}tr{display:flex}th{font-weight:bold;padding-left:4px;padding-right:4px}td{padding-left:4px;padding-right:4px}a{color:#6aa3ff}b{font-weight:bold}strong{font-weight:bold}i{font-style:italic}em{font-style:italic}.vector-menu-content-list{display:none}.vector-dropdown{display:none}.mw-interlanguage-selector{display:none}.wbc-editpage{display:none}.vector-toc{display:none}.vector-toc-list{display:none}.vector-toc-list-item{display:none}.vector-toc-link{display:none}.vector-page-toolbar{display:none}.infobox{float:right;width:300px;margin-left:8px;background-color:#1a1f28}.nishi-buyguard{background-color:#2a2410;color:#ffe08a;padding-left:14px;padding-right:14px;padding-top:8px;padding-bottom:8px;margin-bottom:10px;font-size:18px}\x00"
  }
  let clen: i64 = br_slen(css)
  let STYCAP: i64 = 262144
  let buf: *u8 = sys_mmap(body_len + STYCAP + clen + 16)
  var bi: i64 = 0
  while bi < body_len { buf[bi]=body[bi]; bi=bi+1 }
  // CASCADE ORIGIN ORDER (07-09 root fix): UA defaults FIRST, author <style> AFTER -- the resolvers take
  // the LAST matching decl, so author rules now OVERRIDE the defaults with UA as the fallback (correct CSS
  // origin order). Before this swap the appended defaults silently beat every author color on styled pages
  // (measured: identical palettes with and without author colors -- the dfb probes, 2026-07-09).
  var ci: i64 = 0
  while ci < clen { buf[body_len + ci] = css[ci]; ci=ci+1 }
  let rawsty: *u8 = sys_mmap(STYCAP)
  let rawstylen: i64 = rh_extract_styles(body, body_len, rawsty, STYCAP)
  var stylen: i64 = rh_filter_media(rawsty, 0, rawstylen, ((buf as i64)+body_len+clen) as *u8, STYCAP, vw)
  // STYLED-PAGE UA CORRECTION (2026-07-28): our UA body padding (44px) is a READABILITY choice for
  // unstyled pages; Chrome's real UA default is body margin 8px. On a page that ships author CSS,
  // keeping 44px shifted ALL content right of Chrome (measured: chrome first-ink x=24, ours 68 on
  // styled wikipedia). Inject the Chrome-parity body box AFTER our UA sheet (wins over it) but
  // BEFORE author styles (so the page's own body rules still win over both). +padding-bottom for
  // symmetry; sites that set body padding override all of this normally.
  if stylen > 0 { if stylen + 100 < STYCAP {
      let uafix: *u8 = "body{padding-left:8px;padding-right:8px;padding-top:8px;padding-bottom:8px}\x00" as *u8
      var ufl: i64 = 0
      while uafix[ufl] != (0 as u8) { ufl = ufl + 1 }
      // shift the author block right by ufl and place the fix between UA and author
      var mv: i64 = stylen - 1
      while mv >= 0 { buf[body_len + clen + ufl + mv] = buf[body_len + clen + mv]; mv = mv - 1 }
      var uc: i64 = 0
      while uc < ufl { buf[body_len + clen + uc] = uafix[uc]; uc = uc + 1 }
      stylen = stylen + ufl
  } }
  let total: i64 = body_len + clen + stylen
586
  var VW: i64 = vw
  if VW < 200 { VW = 200 }
  let boxes: *LayoutBox = (sys_mmap(NX_LAYOUT_BOX_BYTES*16384+16)) as *LayoutBox
  let tree: *LayoutTree = (sys_mmap(64)) as *LayoutTree
  nx_layout_tree_init(tree, boxes, 16384)
  let stk: *LayoutFromDomStack = (sys_mmap(NX_LAYOUT_FROM_DOM_STACK_BYTES+8)) as *LayoutFromDomStack
  let sidx: *i64 = (sys_mmap(8*128)) as *i64
  nx_layout_from_dom_stack_init(stk, sidx, 128)
  nx_layout_from_dom(buf, body_len, tree, stk)
596
  let ext: *CssElement = (sys_mmap(NX_CSS_ELEMENT_BYTES*16384 as nx_size)) as *CssElement
  let ehoff: *i64 = sys_mmap(8*16384) as *i64
  let ehlen: *i64 = sys_mmap(8*16384) as *i64
  let esoff: *i64 = sys_mmap(8*16384) as *i64
  let eslen: *i64 = sys_mmap(8*16384) as *i64
  let n_ext: i64 = br_extract(buf, body_len, ext, ehoff, ehlen, esoff, eslen, 16384)
  let boxel: *CssElement = (sys_mmap((NX_CSS_ELEMENT_BYTES*(tree.count+1)) as nx_size)) as *CssElement
  let bhoff: *i64 = sys_mmap(8*(tree.count+1)) as *i64
  let bhlen: *i64 = sys_mmap(8*(tree.count+1)) as *i64
  let bsoff: *i64 = sys_mmap(8*(tree.count+1)) as *i64
  let bslen: *i64 = sys_mmap(8*(tree.count+1)) as *i64
  let bimg: *i64 = sys_mmap(8*(tree.count+1)) as *i64
  let bimw: *i64 = sys_mmap(8*(tree.count+1)) as *i64
  let bimh: *i64 = sys_mmap(8*(tree.count+1)) as *i64
  let bcvs: *i64 = sys_mmap(8*(tree.count+1)) as *i64
  var k: i64 = 0
  var ii: i64 = 0
  while ii < tree.count {
      let b: *LayoutBox = ((tree.boxes as i64)+ii*NX_LAYOUT_BOX_BYTES) as *LayoutBox
      let e: *CssElement = ((boxel as i64)+ii*NX_CSS_ELEMENT_BYTES) as *CssElement
      e.src = buf
      bhoff[ii] = 0 - 1; bhlen[ii] = 0 - 1
      bsoff[ii] = 0 - 1; bslen[ii] = 0 - 1
      bimg[ii] = 0; bimw[ii] = 0; bimh[ii] = 0; bcvs[ii] = 0
      var mapped: i64 = 0
      if rh_is_elem(b.kind)==1 { if b.parent_idx != (0-1) { if k < n_ext {
          let s: *CssElement = ((ext as i64)+k*NX_CSS_ELEMENT_BYTES) as *CssElement
          e.tag_off=s.tag_off; e.tag_len=s.tag_len; e.id_off=s.id_off; e.id_len=s.id_len; e.class_off=s.class_off; e.class_len=s.class_len
          bhoff[ii] = ehoff[k]; bhlen[ii] = ehlen[k]
          bsoff[ii] = esoff[k]; bslen[ii] = eslen[k]
          // <canvas> = sourceless render surface (seq103): match the element's own tag bytes in buf
          if s.tag_len==6 { if (buf[s.tag_off]&0xff)==99 { if (buf[s.tag_off+1]&0xff)==97 { if (buf[s.tag_off+2]&0xff)==110 { if (buf[s.tag_off+3]&0xff)==118 { if (buf[s.tag_off+4]&0xff)==97 { if (buf[s.tag_off+5]&0xff)==115 { bcvs[ii]=1 } } } } } } }
          k=k+1; mapped=1
      } } }
      if mapped==0 { e.tag_off=0; e.tag_len=0; e.id_off=0; e.id_len=0; e.class_off=0; e.class_len=0 }
      ii = ii + 1
  }
634
  let cur: *CssCursor = (sys_mmap(NX_CSS_CURSOR_BYTES) as nx_size) as *CssCursor
  nx_css_cursor_init(cur, buf, total); cur.pos = body_len
  let tok: *CssToken = (sys_mmap(NX_CSS_TOKEN_BYTES) as nx_size) as *CssToken
  let rules: *CssRule = (sys_mmap(NX_CSS_RULE_BYTES*8192 as nx_size)) as *CssRule
  let decls: *CssDeclaration = (sys_mmap(NX_CSS_DECLARATION_BYTES*32768 as nx_size)) as *CssDeclaration
  let st: *CssParseState = (sys_mmap(128) as nx_size) as *CssParseState
  nx_css_parse_state_init(st, cur, tok, rules, 8192, decls, 32768)
  nx_css_parse(st)
  let computed: *CssComputedDecl = (sys_mmap(NX_CSS_COMPUTED_DECL_BYTES*262144 as nx_size)) as *CssComputedDecl
  let cb: *i64 = (sys_mmap(8)) as *i64
  rh_cascade(buf, rules, st.rule_count, decls, st.decl_count, boxel, tree.count, tree, computed, 262144, cb)
  let ncomp: i64 = cb[0]
  rh_promote_display_kinds(tree, computed, ncomp, buf)   // inline + display:flex/grid/block -> BLOCK (sized + painted)
648
  let pbuf: *u8 = sys_mmap(256)
  let ltable: *LayoutPropTable = (sys_mmap(NX_LAYOUT_PROP_TABLE_BYTES)) as *LayoutPropTable
  nx_layout_prop_table_init(ltable, pbuf)
  let resolve: *CssResolveCtx = (sys_mmap(NX_CSS_RESOLVE_CTX_BYTES)) as *CssResolveCtx
  resolve.root_font_size_px = 16; resolve.parent_font_size_px = 16; resolve.parent_dimension_px = VW
  let lctx: *LayoutCtx = (sys_mmap(NX_LAYOUT_CTX_BYTES)) as *LayoutCtx
  nx_layout_ctx_init(lctx, tree, computed, ncomp, buf, VW, resolve)
  lctx.text_measured = 1                            // PROPORTIONAL text: layout measures with the same font metrics the paint draws with
  let page_h: i64 = nx_layout_block_layout(lctx, ltable, 0)
658
  page.buf = buf; page.tree = tree; page.computed = computed; page.ncomp = ncomp
  br_cidx_build(tree, computed, ncomp)   // paint-cliff fix: per-box decl buckets for br_comp_* lookups
  page.page_h = page_h; page.bhref_off = bhoff; page.bhref_len = bhlen; page.ok = 1
  page.bsrc_off = bsoff; page.bsrc_len = bslen; page.bimg = bimg; page.bimg_w = bimw; page.bimg_h = bimh
  page.bcanvas = bcvs
  page.find_ptr = 0; page.find_len = 0
  // MATCH THE DAILY DRIVER (2026-07-27). This was hardcoded 0 = the crude 8x8 BITMAP font for
  // EVERYTHING, while nishi.exe (nishi_gui.nx:530) paints vec_headings=2 = the proportional
  // VECTOR font. So every headless shot taken through this path UNDERSOLD the real browser --
  // it already produced one wrong conclusion in this ecosystem ("body font is THE rock",
  // later DISPROVEN: the vector body font is at Chrome parity). An instrument that does not
  // render what the user sees is a liar; default to what ships.
  // Callers that deliberately want the bitmap font set vec_headings themselves AFTER this
  // call (nx_browser_bg_gate does exactly that at :20/:59/:97), so they are unaffected.
  page.vec_headings = 2
  return 0
675}
676
677// find the next <canvas> box at or after `from` (-1 = none). The canvas CONTRACT (seq103, the game substrate):
678// the consumer renders into its OWN RGB buffer each frame, points page.bimg[idx] (+bimg_w/bimg_h) at it, and
679// repaints (br_draw_fb / br_shot_png); the image pass blits the CURRENT buffer at the box's laid-out position.
680func br_find_canvas(page: *Page, from: i64) -> i64 {
  var i: i64 = from
  if i < 0 { i = 0 }
  while i < page.tree.count { if page.bcanvas[i] == 1 { return i } i = i + 1 }
  return 0 - 1
685}
686
687// paint a heading run with the sovereign stroke-VECTOR font (modern typeface). Word-wraps by the vector
688// metrics within avail_w px, renders each line via font_text -> aa_render -> alpha-blend onto the RGBA fb
689// at (x0,y0), em size = empx px. Vector advances are TIGHTER than the bitmap the layout reserved with, so
690// the run always fits the box (never overflows). Allocation-bearing -> only called on opt-in once-render
691// paths. Returns the drawn width of the FIRST line (for the link underline; headings rarely link).
692// REUSED vector-paint scratch (was sys_mmap PER LINE -> per-box -> gigabytes committed under the PE's
693// VirtualAlloc, hanging the native GUI on a full page). Allocated ONCE, reused across every box + line.
694static bpv_xs: i64
695static bpv_ys: i64
696static bpv_cst: i64
697static bpv_cln: i64
698static bpv_cov: i64
699static bpv_cs2: i64
700static bpv_sn2: i64
701static bpv_np: i64
702static bpv_nc: i64
703// ---- GLYPH-ATLAS FAST PATH (GUI-only, gated by bpv_fast_on) ------------------------------------------
704// Rasterize each (char,size) glyph ONCE into a cached coverage cell, then just alpha-blend the cell per
705// draw. Turns O(glyphs drawn) rasterization into O(unique glyph x size). Pixel-snapped positioning (no
706// sub-pixel phase) -> crisp, ~visually-identical, MUCH faster. The EXACT per-line path (used by the shot /
707// NishiOS / OCR / polish gates) is untouched: they never set bpv_fast_on, so the dispatch below is a no-op
708// for them -> zero gate regression. Only nishi_gui (br_set_fast_vec(1)) opts in.
709static bpv_fast_on: i64
710static bpv_line_adv: i64   // wrapped-line advance override (px at paint scale; 0 = legacy (empx*12)/10+2).
                         // Set by the TEXT paint pass from the CSS line-height so paint fills exactly
                         // the lines layout reserved (measure==paint); single-threaded paint -> safe.
713static atk: i64      // hash keys (ch*100000+empx), -1 = empty slot
714static atcov: i64    // per-slot coverage buffer ptr
715static atgw: i64     // per-slot cell width  (px)
716static atgh: i64     // per-slot cell height (px)
717static atmg: i64     // per-slot left margin (px) baked into the cell
718static atcap: i64
719func br_set_fast_vec(v: i64) -> i64 { bpv_fast_on = v; return 0 }
720func bpv_atlas_init() -> i64 {
  if bpv_xs == 0 {
      bpv_xs = sys_mmap(8*200000) as i64; bpv_ys = sys_mmap(8*200000) as i64
      bpv_cst = sys_mmap(8*20000) as i64; bpv_cln = sys_mmap(8*20000) as i64
      bpv_cov = sys_mmap(4194304) as i64
      bpv_cs2 = sys_mmap(8*16) as i64; bpv_sn2 = sys_mmap(8*16) as i64
      bpv_np = sys_mmap(16) as i64; bpv_nc = sys_mmap(16) as i64
  }
  if atk == 0 {
      atcap = 8192
      atk = sys_mmap(8*atcap) as i64; atcov = sys_mmap(8*atcap) as i64
      atgw = sys_mmap(8*atcap) as i64; atgh = sys_mmap(8*atcap) as i64; atmg = sys_mmap(8*atcap) as i64
      let ka: *i64 = atk as *i64; var z: i64 = 0
      while z < atcap { ka[z] = 0 - 1; z = z + 1 }
  }
  return 0
736}
737// get-or-build the cached coverage cell for (ch,empx). out[0]=covptr out[1]=gw out[2]=gh out[3]=leftmargin_px
738func bpv_cell(ch: i64, empx: i64, cs: *i64, sn: *i64, out: *i64) -> i64 {
  let ka: *i64 = atk as *i64
  let key: i64 = ch * 100000 + empx
  var h: i64 = key % atcap
  if h < 0 { h = 0 - h }
  var probes: i64 = 0
  while probes < atcap {
      let cova: *i64 = atcov as *i64; let gwa: *i64 = atgw as *i64; let gha: *i64 = atgh as *i64; let mga: *i64 = atmg as *i64
      if ka[h] == key { out[0]=cova[h]; out[1]=gwa[h]; out[2]=gha[h]; out[3]=mga[h]; return 0 }
      if ka[h] == (0 - 1) {
          let ss: i64 = 3
          let S: i64 = empx * ss
          let mgn: i64 = 4
          let adv: i64 = font_vec_adv_px2(ch, empx)
          var gw: i64 = adv + 2*mgn
          if gw < empx + 2*mgn { gw = empx + 2*mgn }
          let gh: i64 = empx + (empx*35)/100 + 2
          let xs: *i64 = bpv_xs as *i64; let ys: *i64 = bpv_ys as *i64
          let cstart: *i64 = bpv_cst as *i64; let clen: *i64 = bpv_cln as *i64
          let np: *i64 = bpv_np as *i64; np[0]=0
          let nc: *i64 = bpv_nc as *i64; nc[0]=0
          font_emit(ch, xs, ys, cstart, clen, np, nc, cs, sn, mgn*ss, 2*ss, S)
          let cov: *u8 = sys_mmap(gw*gh + 16)
          var zi: i64 = 0
          while zi < gw*gh { cov[zi]=0 as u8; zi=zi+1 }
          aa_render(xs, ys, cstart, clen, nc[0], cov, gw, gh, ss)
          ka[h]=key; cova[h]=cov as i64; gwa[h]=gw; gha[h]=gh; mga[h]=mgn
          out[0]=cov as i64; out[1]=gw; out[2]=gh; out[3]=mgn
          return 0
      }
      h = h + 1; if h >= atcap { h = 0 }
      probes = probes + 1
  }
  out[0]=0; return 1
772}
773// alpha-blend a coverage cell onto the RGBA framebuffer (matches br_paint_vec's blend exactly)
774func bpv_blit_rgba(fb: *Framebuffer, ox: i64, oy: i64, cov: *u8, gw: i64, gh: i64, cr: i64, cg: i64, cb: i64) -> i64 {
  let fw: i64 = fb.width; let fh: i64 = fb.height; let pxb: *u8 = fb.pixels
  var y: i64 = 0
  while y < gh {
      let fyr: i64 = oy + y
      if fyr >= 0 { if fyr < fh {
          var x: i64 = 0
          while x < gw {
              let a: i64 = cov[y*gw + x] & 0xff
              if a > 0 {
                  let fxr: i64 = ox + x
                  if fxr >= 0 { if fxr < fw {
                      let o: i64 = (fyr*fw + fxr) * 4
                      let ia: i64 = 255 - a
                      pxb[o]   = (((pxb[o]   as i64)*ia + cr*a)/255) as u8
                      pxb[o+1] = (((pxb[o+1] as i64)*ia + cg*a)/255) as u8
                      pxb[o+2] = (((pxb[o+2] as i64)*ia + cb*a)/255) as u8
                      pxb[o+3] = 255 as u8
                  } }
              }
              x = x + 1
          }
      } }
      y = y + 1
  }
  return 0
800}
801func br_paint_vec_atlas(fb: *Framebuffer, x0: i64, y0: i64, text: *u8, text_len: i64, empx: i64, color: *CssColor, avail_w: i64) -> i64 {
  bpv_atlas_init()
  let cs: *i64 = bpv_cs2 as *i64
  let sn: *i64 = bpv_sn2 as *i64
  font_trig_init(cs, sn)
  let cr: i64 = color.r & 255
  let cg: i64 = color.g & 255
  let cb: i64 = color.b & 255
  var lineh: i64 = (empx * 12) / 10 + 2
  if bpv_line_adv >= 8 { lineh = bpv_line_adv }   // CSS line-height (already paint-scaled by the caller)
  var aw: i64 = avail_w
  if aw < empx { aw = empx }
  let cell: *i64 = sys_mmap(64) as *i64
  var pos: i64 = 0
  var li: i64 = 0
  var w1: i64 = 0
  while pos < text_len {
      var e: i64 = font_vec_next_break_px(text, text_len, aw, pos, empx)
      if e <= pos { e = text_len }
      let basey: i64 = y0 + li * lineh
      var penpx: i64 = x0
      var k: i64 = pos
      while k < e {
          let ch: i64 = text[k] & 0xff
          bpv_cell(ch, empx, cs, sn, cell)
          let covp: i64 = cell[0]
          let shp: i64 = (((((font_sp_shift_disp(ch) * font_ws()) / 100) * font_wdth()) / 100) * empx) / 1000
          if covp != 0 { bpv_blit_rgba(fb, penpx + shp - cell[3], basey, covp as *u8, cell[1], cell[2], cr, cg, cb) }
          penpx = penpx + font_vec_adv_px2(ch, empx)
          k = k + 1
      }
      if li == 0 { w1 = penpx - x0 }
      pos = e
      li = li + 1
      if li > 40 { pos = text_len }
  }
  return w1
838}
839func br_paint_vec(fb: *Framebuffer, x0: i64, y0: i64, text: *u8, text_len: i64, empx: i64, color: *CssColor, avail_w: i64) -> i64 {
  if bpv_fast_on == 1 { return br_paint_vec_atlas(fb, x0, y0, text, text_len, empx, color, avail_w) }
  let ss: i64 = 3
  let S: i64 = empx * ss
  if bpv_xs == 0 {
      bpv_xs = sys_mmap(8*200000) as i64
      bpv_ys = sys_mmap(8*200000) as i64
      bpv_cst = sys_mmap(8*20000) as i64
      bpv_cln = sys_mmap(8*20000) as i64
      bpv_cov = sys_mmap(4194304) as i64
      bpv_cs2 = sys_mmap(8*16) as i64
      bpv_sn2 = sys_mmap(8*16) as i64
      bpv_np = sys_mmap(16) as i64
      bpv_nc = sys_mmap(16) as i64
  }
  let cs: *i64 = bpv_cs2 as *i64
  let sn: *i64 = bpv_sn2 as *i64
  font_trig_init(cs, sn)
  let fw: i64 = fb.width
  let fh: i64 = fb.height
  let pxb: *u8 = fb.pixels
  let cr: i64 = color.r & 255
  let cg: i64 = color.g & 255
  let cb: i64 = color.b & 255
  let lineh: i64 = (empx * 12) / 10 + 2                     // ~1.2em line height
  var aw: i64 = avail_w
  if aw < empx { aw = empx }
  var pos: i64 = 0
  var li: i64 = 0
  var w1: i64 = 0
  while pos < text_len {
      var e: i64 = font_vec_next_break_px(text, text_len, aw, pos, empx)
      if e <= pos { e = text_len }
      // render this line [pos,e) into a coverage buffer sized to its width x (em band)
      let lw: i64 = font_vec_text_w_px(text, pos, e, empx) + empx
      let GH: i64 = empx + (empx*35)/100                    // ascender..descender band
      var GW: i64 = lw
      if GW < empx { GW = empx }
      if GW > fw { GW = fw }
      let xs: *i64 = bpv_xs as *i64                  // reused (was sys_mmap per line)
      let ys: *i64 = bpv_ys as *i64
      let cstart: *i64 = bpv_cst as *i64
      let clen: *i64 = bpv_cln as *i64
      let np: *i64 = bpv_np as *i64; np[0]=0
      let nc: *i64 = bpv_nc as *i64; nc[0]=0
      font_text(((text as i64)+pos) as *u8, e-pos, xs, ys, cstart, clen, np, nc, cs, sn, 2*ss, 2*ss, S)
      if GW*GH > 4194288 { GW = 4194288 / GH }       // clamp to the reused cov buffer (4 MB) -- defensive
      let cov: *u8 = bpv_cov as *u8
      var zi: i64 = 0
      while zi < GW*GH { cov[zi]=0 as u8; zi=zi+1 }
      aa_render(xs, ys, cstart, clen, nc[0], cov, GW, GH, ss)
      // alpha-blend coverage onto the RGBA fb
      let basey: i64 = y0 + li * lineh
      var gy: i64 = 0
      while gy < GH {
          let fyr: i64 = basey + gy
          if fyr >= 0 { if fyr < fh {
              var gx: i64 = 0
              while gx < GW {
                  let a: i64 = cov[gy*GW+gx] & 0xff
                  if a > 0 {
                      let fxr: i64 = x0 + gx
                      if fxr >= 0 { if fxr < fw {
                          let o: i64 = (fyr*fw+fxr)*4
                          let ia: i64 = 255 - a
                          pxb[o]   = (((pxb[o] as i64)*ia + cr*a)/255) as u8
                          pxb[o+1] = (((pxb[o+1] as i64)*ia + cg*a)/255) as u8
                          pxb[o+2] = (((pxb[o+2] as i64)*ia + cb*a)/255) as u8
                          pxb[o+3] = 255 as u8
                      } }
                  }
                  gx = gx + 1
              }
          } }
          gy = gy + 1
      }
      if li == 0 { w1 = lw }
      pos = e
      li = li + 1
      if li > 40 { pos = text_len }
  }
  return w1
921}
922// vector metrics in absolute px (em size empx), for the paint's own wrap
923func font_vec_adv_px2(ch: i64, empx: i64) -> i64 { return (font_adv_em(ch) * empx) / 1000 }
924func font_vec_text_w_px(text: *u8, start: i64, end: i64, empx: i64) -> i64 {
  var w: i64 = 0
  var i: i64 = start
  while i < end { w = w + font_vec_adv_px2(text[i] & 0xff, empx); i = i + 1 }
  return w
929}
930func font_vec_next_break_px(text: *u8, len: i64, avail_px: i64, start: i64, empx: i64) -> i64 {
  if start >= len { return len }
  var w: i64 = 0
  var i: i64 = start
  var brk: i64 = 0 - 1
  while i < len {
      w = w + font_vec_adv_px2(text[i] & 0xff, empx)
      if w > avail_px {
          if brk > start { return brk + 1 }
          if i > start { return i }
          return start + 1
      }
      if (text[i] & 0xff) == 32 { brk = i }
      i = i + 1
  }
  return len
946}
947
948// FIND-IN-PAGE (Ctrl+F, a universally-expected browser feature): case-insensitive search of the laid-out
949// text for `term`. Sets page.find_ptr/find_len so br_draw_fb_at highlights every matching text box; returns
950// the match count and, via yb, the page-y of the FIRST match (for scroll-to). A term absent from the page
951// returns 0 (highlights nothing). Matching is per-text-box substring (the layout already split text into
952// boxes at inline boundaries) -- the same units the render + hit-test use.
953func br_ci(a: i64) -> i64 { if a >= 65 { if a <= 90 { return a + 32 } } return a }
954func br_box_has_term(buf: *u8, off: i64, len: i64, term: *u8, tlen: i64) -> i64 {
  if tlen <= 0 { return 0 }
  var i: i64 = 0
  while i + tlen <= len {
      var j: i64 = 0
      var ok: i64 = 1
      while j < tlen { if br_ci(buf[off+i+j]&0xff) != br_ci(term[j]&0xff) { ok=0; j=tlen } else { j=j+1 } }
      if ok == 1 { return 1 }
      i = i + 1
  }
  return 0
965}
966func br_find(page: *Page, term: *u8, tlen: i64, yb: *i64) -> i64 {
  page.find_ptr = term as i64
  page.find_len = tlen
  yb[0] = 0 - 1
  if tlen <= 0 { page.find_ptr = 0; return 0 }
  let tree: *LayoutTree = page.tree
  var matches: i64 = 0
  var i: i64 = 0
  while i < tree.count {
      let b: *LayoutBox = ((tree.boxes as i64) + i * NX_LAYOUT_BOX_BYTES) as *LayoutBox
      if b.kind == NX_LAYOUT_BOX_TEXT { if b.text_len > 0 {
          if br_box_has_term(page.buf, b.text_off, b.text_len, term, tlen) == 1 {
              matches = matches + 1
              if yb[0] < 0 { yb[0] = b.y }
          }
      } }
      i = i + 1
  }
  if matches == 0 { page.find_ptr = 0 }        // nothing to highlight
  return matches
986}
987
988func br_color_from_int(c: i64) -> *CssColor {
  let col: *CssColor = sys_mmap(NX_CSS_COLOR_BYTES) as *CssColor
  col.r = (c >> 16) & 0xff
  col.g = (c >> 8) & 0xff
  col.b = c & 0xff
  col.a = 255
  return col
995}
996
997func br_bit(ft8: *u8, go: i64, col: i64, row: i64) -> i64 {
  if col < 0 { return 0 }
  if col > 7 { return 0 }
  if row < 0 { return 0 }
  if row > 7 { return 0 }
  if ((ft8[go + row] >> col) & 1) == 1 { return 255 }
  return 0
1004}
1005// bilinear coverage of glyph `go` at bit-space (fx256,fy256) in 1/256 fixed point (bit centers on integers)
1006func br_glyph_cov(ft8: *u8, go: i64, fx256: i64, fy256: i64) -> i64 {
  let x0: i64 = fx256 >> 8
  let y0: i64 = fy256 >> 8
  let fxr: i64 = fx256 & 255
  let fyr: i64 = fy256 & 255
  let v00: i64 = br_bit(ft8, go, x0,   y0)
  let v10: i64 = br_bit(ft8, go, x0+1, y0)
  let v01: i64 = br_bit(ft8, go, x0,   y0+1)
  let v11: i64 = br_bit(ft8, go, x0+1, y0+1)
  let top: i64 = v00*(256-fxr) + v10*fxr
  let bot: i64 = v01*(256-fxr) + v11*fxr
  return (top*(256-fyr) + bot*fyr) >> 16
1018}
1019// SHARPEN the raw bilinear coverage: solidify stroke interiors (>= BR_HI -> 255, keeps thin 1-bit stems
1020// crisp = legibility) while KEEPING the outer edge ramp as intermediate gray (= anti-aliasing). This is
1021// the knob that makes both the OCR judge (legibility) AND the polish census (AA) happy at once.
1022const BR_LO: i64 = 40
1023const BR_HI: i64 = 165
1024func br_sharpen(c: i64) -> i64 {
  if c <= BR_LO { return 0 }
  if c >= BR_HI { return 255 }
  return ((c - BR_LO) * 255) / (BR_HI - BR_LO)
1028}
1029// coverage for one output pixel: INTERIOR pixels (nearest bit + its 4 orthogonal neighbors all set) stay
1030// SOLID 255 -- pixel-exact, no resample shift, so legibility is preserved; only EDGE pixels take the
1031// sharpened bilinear ramp = anti-aliasing. This is what holds 984 OCR AND closes the polish gap.
1032func br_cov_hybrid(ft8: *u8, go: i64, fx256: i64, fy256: i64) -> i64 {
  let cc: i64 = (fx256 + 128) >> 8            // nearest bit col
  let rr: i64 = (fy256 + 128) >> 8            // nearest bit row
  if br_bit(ft8, go, cc, rr) == 255 {
      if br_bit(ft8, go, cc-1, rr) == 255 { if br_bit(ft8, go, cc+1, rr) == 255 {
          if br_bit(ft8, go, cc, rr-1) == 255 { if br_bit(ft8, go, cc, rr+1) == 255 {
              return 255
          } }
      } }
  }
  return br_sharpen(br_glyph_cov(ft8, go, fx256, fy256))
1043}
1044
1045// PROPORTIONAL + ANTI-ALIASED bitmap text: bilinear coverage of the glyph field (smooth edges) + a
1046// sharpening curve (solid interiors), alpha-blended onto the RGBA framebuffer. Closes the polish gap vs
1047// Chrome AND holds the 984 legibility. Pen advance = font8x8_adv (measured-layout SSOT), layout truthful.
1048func br_paint_text2x(fb: *Framebuffer, x: i64, y: i64, text: *u8, text_len: i64, color: *CssColor, scale: i64) -> i64 {
  let ft8: *u8 = font8x8_table()
  let blk: i64 = scale
  let GH: i64 = 8 * blk                                       // glyph render height in px
  let fw: i64 = fb.width
  let fh: i64 = fb.height
  let pxb: *u8 = fb.pixels
  let cr: i64 = color.r & 255
  let cg: i64 = color.g & 255
  let cb: i64 = color.b & 255
  var pen: i64 = x
  var i: i64 = 0
  while i < text_len {
      let ch: i64 = text[i] & 0xff
      if ch > 0x20 { if ch <= 0x7E {
          let go: i64 = (ch - 0x20) * 8
          let iw: i64 = font8x8_ink_w(ft8, ch)               // ink columns (proportional)
          var GW: i64 = iw * blk
          if GW < blk { GW = blk }
          let sxn: i64 = (iw * 256) / GW                     // bit-cols per output px * 256
          let syn: i64 = (8 * 256) / GH                      // bit-rows per output px * 256
          var oy: i64 = 0
          while oy < GH {
              let fy256: i64 = ((oy * 2 + 1) * syn) / 2 - 128    // (oy+0.5)*syn - 0.5 bit
              let fyr: i64 = y + oy
              if fyr >= 0 { if fyr < fh {
                  var ox: i64 = 0
                  while ox < GW {
                      let fx256: i64 = ((ox * 2 + 1) * sxn) / 2 - 128
                      let a: i64 = br_cov_hybrid(ft8, go, fx256, fy256)
                      if a > 0 {
                          let fxr: i64 = pen + ox
                          if fxr >= 0 { if fxr < fw {
                              let o: i64 = (fyr * fw + fxr) * 4
                              let ia: i64 = 255 - a
                              pxb[o]   = (((pxb[o] as i64) * ia + cr * a) / 255) as u8
                              pxb[o+1] = (((pxb[o+1] as i64) * ia + cg * a) / 255) as u8
                              pxb[o+2] = (((pxb[o+2] as i64) * ia + cb * a) / 255) as u8
                              pxb[o+3] = 255 as u8
                          } }
                      }
                      ox = ox + 1
                  }
              } }
              oy = oy + 1
          }
      } }
      pen = pen + font8x8_adv(ft8, ch) * blk
      i = i + 1
  }
  return pen - x
1099}
1100
1101// Blit a decoded RGB image (src = w*h*3, row-major) into the RGBA framebuffer at (dx,dy), nearest-neighbor
1102// scaled to boxW x boxH, clipped to fb bounds. The missing image-paint primitive (nx_paint_solid_rect does
1103// solid fills; this does image copy). A=255 (opaque). RGB source because nx_img_to_rgb/JPEG emit w*h*3.
1104func br_blit_rgb(fb: *Framebuffer, dx: i64, dy: i64, boxW: i64, boxH: i64, src: *u8, sw: i64, sh: i64) -> i64 {
  if boxW <= 0 { return 0 }
  if boxH <= 0 { return 0 }
  if sw <= 0 { return 0 }
  if sh <= 0 { return 0 }
  let fw: i64 = fb.width
  let fh: i64 = fb.height
  let px: *u8 = fb.pixels
  var ty: i64 = 0
  while ty < boxH {
      let py: i64 = dy + ty
      if py >= 0 { if py < fh {
          let sy: i64 = (ty * sh) / boxH
          var tx: i64 = 0
          while tx < boxW {
              let pxx: i64 = dx + tx
              if pxx >= 0 { if pxx < fw {
                  let sx: i64 = (tx * sw) / boxW
                  let so: i64 = (sy * sw + sx) * 3
                  let dof: i64 = (py * fw + pxx) * 4
                  px[dof + 0] = src[so + 0]
                  px[dof + 1] = src[so + 1]
                  px[dof + 2] = src[so + 2]
                  px[dof + 3] = 255 as u8
              } }
              tx = tx + 1
          }
      } }
      ty = ty + 1
  }
  return 0
1135}
1136
1137// OFF-SCREEN render: rasterize the laid-out page into an in-memory RGBA framebuffer (no X server). Uses the
1138// 5x7 bitmap-font paint primitives (for verifying colors/layout/chrome). The same fn the GUI calls to paint.
1139// draw with a vertical SCROLL offset (page-space px): content shifts up by scroll_y, chrome stays fixed.
1140// br_draw_fb delegates with scroll 0, so existing callers (incl the parallel-owned GUI) are unaffected.
1141func br_draw_fb_at(fb: *Framebuffer, page: *Page, win_w: i64, cur_url: *u8, ulen: i64, scale: i64, scroll_y: i64) -> i64 {
  let tree: *LayoutTree = page.tree
  let src: *u8 = page.buf
  let computed: *CssComputedDecl = page.computed
  let ncomp: i64 = page.ncomp
  let fdec: *u8 = sys_mmap(1100)                   // reused per text box: decode HTML entities before painting
  var base_bg: i64 = 0x00FFFFFF
  if page.dark_mode == 1 { base_bg = 0x000E1116 }  // dark base so uncovered margin areas match the theme
  // CSS BACKGROUND PROPAGATION (SPEC semantics): the canvas takes the background of the ROOT elements
  // ONLY -- html/body (boxes 0..1) -- exactly like Chrome. The first version scanned ALL blocks for the
  // first non-white bg; the top-20 suite caught it painting google.com's whole canvas dark off a banner
  // div (coarse parity 0.0%). var() bgs on body resolve through cx_expand, so /experiential's dark body
  // still propagates. Gated on dark_mode==0 (explicit reader theme keeps its base).
  if page.dark_mode == 0 {
      // walk the ROOT CHAIN: from the parentless root, descend while the current box has exactly ONE
      // full-width BLOCK child (html -> wrapper -> body in our tree); the first background on that chain
      // is the canvas (spec: html/body propagate). A box with SIBLING blocks (google's banner divs) ends
      // the chain -- content never propagates. (The first-non-white-anywhere version painted google's
      // canvas dark off a banner; the parentless-root-only version missed body at depth 2 -- both caught
      // by the top-20 suite + the /experiential void-luma regression check.)
      var cur: i64 = 0 - 1
      var cbi: i64 = 0
      while cbi < tree.count {
          if cur < 0 {
              let cb0: *LayoutBox = ((tree.boxes as i64) + cbi * NX_LAYOUT_BOX_BYTES) as *LayoutBox
              if cb0.kind == NX_LAYOUT_BOX_BLOCK { if cb0.parent_idx < 0 { cur = cbi } }
          }
          cbi = cbi + 1
      }
      var hops: i64 = 0
      while cur >= 0 {
          if hops >= 6 { cur = 0 - 1 }
          else {
              hops = hops + 1
              let cb: *LayoutBox = ((tree.boxes as i64) + cur * NX_LAYOUT_BOX_BYTES) as *LayoutBox
              let cbg: i64 = br_comp_bg(src, computed, ncomp, cur)
              if cbg >= 0 { if cbg != 0x00FFFFFF { base_bg = cbg; cur = 0 - 1 } }
              if cur >= 0 {
                  // exactly one full-width BLOCK child continues the chain
                  var only: i64 = 0 - 1
                  var nfull: i64 = 0
                  var ci: i64 = cb.first_child_idx
                  var guard: i64 = 0
                  while ci >= 0 {
                      if guard >= 4096 { ci = 0 - 1 }
                      else {
                          guard = guard + 1
                          let cc: *LayoutBox = ((tree.boxes as i64) + ci * NX_LAYOUT_BOX_BYTES) as *LayoutBox
                          if cc.kind == NX_LAYOUT_BOX_BLOCK { if cc.w == cb.w { nfull = nfull + 1; only = ci } }
                          ci = cc.next_sibling_idx
                      }
                  }
                  if nfull == 1 { cur = only } else { cur = 0 - 1 }
              }
          }
      }
  }
  nx_paint_solid_rect(fb, 0, 0, win_w * scale, fb.height, br_color_from_int(base_bg))
  var i: i64 = 0
  let bwp: *i64 = sys_mmap(16) as *i64             // border width out-slot (hoisted: no mmap in the loop)
  while i < tree.count {
      let b: *LayoutBox = ((tree.boxes as i64) + i * NX_LAYOUT_BOX_BYTES) as *LayoutBox
      var _pbx: i64 = 0
      if b.kind == NX_LAYOUT_BOX_BLOCK { _pbx = 1 }
      if b.kind == NX_LAYOUT_BOX_INLINE_BLOCK { _pbx = 1 }   // atomic inline-block (chips/tags/buttons) now paint bg+border
      if _pbx == 1 { if b.w > 0 { if b.h > 0 {
          let bg: i64 = br_comp_bg(src, computed, ncomp, i)
          if bg >= 0 { if bg != 0x00FFFFFF { nx_paint_solid_rect(fb, b.x * scale, (b.y - scroll_y + NX_CHROME_H) * scale, b.w * scale, b.h * scale, br_color_from_int(bg)) } }
          // CSS borders (the `border` shorthand): stroke the 4 edges -- tables/cards get real lines
          let bc: i64 = br_comp_border(src, computed, ncomp, i, bwp)
          if bc >= 0 {
              let bw2: i64 = bwp[0]
              nx_paint_solid_rect(fb, b.x * scale, (b.y - scroll_y + NX_CHROME_H) * scale, b.w * scale, bw2 * scale, br_color_from_int(bc))
              nx_paint_solid_rect(fb, b.x * scale, (b.y - scroll_y + NX_CHROME_H + b.h - bw2) * scale, b.w * scale, bw2 * scale, br_color_from_int(bc))
              nx_paint_solid_rect(fb, b.x * scale, (b.y - scroll_y + NX_CHROME_H) * scale, bw2 * scale, b.h * scale, br_color_from_int(bc))
              nx_paint_solid_rect(fb, (b.x + b.w - bw2) * scale, (b.y - scroll_y + NX_CHROME_H) * scale, bw2 * scale, b.h * scale, br_color_from_int(bc))
          }
      } } }
      i = i + 1
  }
  // FIND-IN-PAGE highlight pass: a yellow band behind every text box matching the active search term
  // (drawn under the text so the glyphs stay readable). Only runs when a find is active.
  if page.find_ptr != 0 {
      let fterm: *u8 = page.find_ptr as *u8
      i = 0
      while i < tree.count {
          let b: *LayoutBox = ((tree.boxes as i64) + i * NX_LAYOUT_BOX_BYTES) as *LayoutBox
          if b.kind == NX_LAYOUT_BOX_TEXT { if b.text_len * b.h > 0 {   // h==0 = never laid out (hidden subtree) -> no highlight
              if br_box_has_term(src, b.text_off, b.text_len, fterm, page.find_len) == 1 {
                  var hw: i64 = b.w
                  if hw < 8 { hw = 8 }
                  nx_paint_solid_rect(fb, b.x * scale, (b.y - scroll_y + NX_CHROME_H) * scale, hw * scale, 17 * scale, br_color_from_int(0x00FFE066))
              }
          } }
          i = i + 1
      }
  }
  i = 0
  while i < tree.count {
      let b: *LayoutBox = ((tree.boxes as i64) + i * NX_LAYOUT_BOX_BYTES) as *LayoutBox
      let syt: i64 = (b.y - scroll_y + NX_CHROME_H) * scale       // VIEWPORT CULL: off-screen text boxes skip the
      var vis: i64 = 1                                            // expensive vector/bitmap raster (fb.height = full
      if syt > fb.height { vis = 0 }                             // page for the shot path -> renders all; = 720 for
      if syt + (b.h + 80) * scale < 0 { vis = 0 }                // the GUI -> only ~visible boxes -> fast + no hang)
      if vis == 1 {
      // NEVER-LAID GUARD (seq1130): a text box under a display:none ancestor is never reached by
      // _layout_block_recurse -- it keeps x=0,y=0,w=0,h=0 from tree init. Painting it wraps the run
      // at the w=0 minimum and stacks every hidden run at the origin = the "blob rail". Layout is the
      // only writer of b.h and always sets it > 0 for a placed text box, so h==0 means NOT LAID OUT.
      // text_len*h > 0 == (text_len > 0 AND h > 0) for the non-negative fields.
      if b.kind == NX_LAYOUT_BOX_TEXT { if b.text_len * b.h > 0 {
          let par: i64 = b.parent_idx
          var col: i64 = br_comp_color_inh(src, computed, ncomp, tree, par)   // CSS-inherited color
          if col < 0 { col = 0 }
          var nn: i64 = b.text_len
          if nn > 960 { nn = 960 }
          let dn0: i64 = nx_html_decode_entities(src, b.text_off, nn, fdec, 1024)
          let dn: i64 = nx_fold_ascii(fdec, 0, dn0, fdec, 1024)   // UTF-8 -> renderable ASCII (accents->base, curly->straight, mdash->-): real pages render in the vector font. Identity for ASCII -> gate pages byte-unchanged.
          let fs: i64 = br_comp_fontsize_inh(src, computed, ncomp, tree, par, 16)   // PROPORTIONAL: size text by the INHERITED cascade incl the `font` shorthand (same rule as layout -> measure==paint)
          let lh_run: i64 = br_comp_lineheight_px(src, computed, ncomp, tree, par, fs)   // CSS line-height (same resolver rule as layout)
          var tscale: i64 = 1
          if fs >= 24 { tscale = 2 }                  // MUST match _layout_scale_for_px (24/36 buckets)
          if fs >= 36 { tscale = 3 }                  // so painted glyph size == the layout's reserved metrics
          // VECTOR TEXT: opt-in; any run (headings AND body -- vector is now OCR-legible to 14px, proven by
          // nx_vecfont_body_bench's size ladder) whose chars all have vector glyphs is painted with the
          // proportional stroke font instead of the bitmap monospace (the "typewriter" body). empx = the
          // cascade font-size x paint scale (exact). Vector is proportional+tighter than the bitmap the
          // layout reserved -> fits the box. vec_headings==2 forces body-too; ==1 keeps headings-only.
          var did_vec: i64 = 0
          var vec_ok: i64 = 0
          if page.vec_headings == 1 { if tscale >= 2 { vec_ok = 1 } }
          if page.vec_headings == 2 { vec_ok = 1 }
          if vec_ok == 1 {
              var run_ok: i64 = font_run_has(fdec, dn)
              if bpv_fast_on == 1 { run_ok = font_run_has_ext(fdec, dn) }   // GUI/atlas covers % [ ] ; " = + too
              if run_ok == 1 {
                  let empx: i64 = fs * scale
                  // HALF-LEADING: CSS centers the glyph line inside the line box; without this, text
                  // sits at box top and every line lands ~leading/2 higher than Chrome.
                  var hl: i64 = 0
                  if lh_run >= 8 {
                      let gl: i64 = (fs * 12) / 10 + 2
                      if lh_run > gl { hl = (lh_run - gl) / 2 }
                  }
                  if lh_run >= 8 { bpv_line_adv = lh_run * scale } else { bpv_line_adv = 0 }
                  br_paint_vec(fb, (b.x + 4) * scale, (b.y + hl - scroll_y + NX_CHROME_H) * scale, fdec, dn, empx, br_color_from_int(col), b.w * scale)
                  bpv_line_adv = 0
                  did_vec = 1
              }
          }
          if did_vec == 0 {
          // WORD-WRAP long runs by MEASURED advances -- the SAME font8x8_next_break the measured layout
          // reserved lines with, over the same avail budget (b.w/tscale in 1x units), so painted lines
          // exactly fill the reserved box. Short runs take the single-line path unchanged.
          let wtab: *u8 = font8x8_table()
          var avail_u: i64 = b.w / tscale
          if avail_u < 4 { avail_u = 4 }
          var lhadv: i64 = 17 * tscale
          if lh_run >= 8 { lhadv = lh_run }            // CSS line-height: advance wrapped lines exactly as layout reserved
          var hl2: i64 = 0
          if lhadv > 17 * tscale { hl2 = (lhadv - 17 * tscale) / 2 }   // half-leading (center in the line box)
          var pos: i64 = 0
          var li: i64 = 0
          var w1: i64 = 0                              // drawn width of the first line (underline = text width)
          while pos < dn {
              var e: i64 = font8x8_next_break(wtab, fdec, dn, avail_u, pos)
              if e <= pos { e = dn }
              let dw: i64 = br_paint_text2x(fb, (b.x + 4) * scale, (b.y + hl2 - scroll_y + NX_CHROME_H + 1 + li * lhadv) * scale, ((fdec as i64)+pos) as *u8, e - pos, br_color_from_int(col), tscale * scale)
              if li == 0 { w1 = dw }
              pos = e
              li = li + 1
              if li > 60 { pos = dn }
          }
          var is_link: i64 = 0
          if col == 0x2563eb { is_link = 1 }           // light-theme link blue
          if col == 0x6aa3ff { is_link = 1 }           // dark-theme link blue
          if is_link == 1 { nx_paint_solid_rect(fb, (b.x + 4) * scale, (b.y - scroll_y + NX_CHROME_H + 1 + 14 * tscale) * scale, w1, tscale * scale, br_color_from_int(col)) }   // underline links (drawn-text width)
          }
      } } }
      i = i + 1
  }
  // IMAGE pass: blit decoded <img> pixels (the consumer fills page.bimg via fetch+decode) at each img
  // box's laid-out position. ADDITIVE -- the layout algorithm is untouched; images paint over the flow.
  i = 0
  while i < tree.count {
      let ib: *LayoutBox = ((tree.boxes as i64) + i * NX_LAYOUT_BOX_BYTES) as *LayoutBox
      let ip: i64 = page.bimg[i]
      if ip != 0 {
          let iw: i64 = page.bimg_w[i]
          let ih: i64 = page.bimg_h[i]
          var dw: i64 = iw
          // HIDDEN-SUBTREE GUARD, CORRECTED (2026-07-29). The seq1130 rule "h<=0 ⇒ never laid ⇒
          // don't paint" is right for TEXT but WRONG for <img>: an image with no CSS width/height
          // legitimately has h=0 until its intrinsic size is known (only after fetch+decode), so
          // that guard silently killed 100% of images on every page (measured: imgsrc=11,
          // imgsrc_laid=0). Ask the RIGHT question instead — is the image's CONTAINER laid out? A
          // hidden subtree has a 0-height PARENT; a not-yet-sized <img> sits inside a laid parent.
          if ib.h <= 0 {
              var par_laid: i64 = 0
              if ib.parent_idx >= 0 {
                  let ipb: *LayoutBox = ((tree.boxes as i64) + ib.parent_idx * NX_LAYOUT_BOX_BYTES) as *LayoutBox
                  if ipb.h > 0 { par_laid = 1 }
              }
              if par_laid == 0 { dw = 0 }
          }
          let avail: i64 = win_w - ib.x - 8
          if dw > avail { dw = avail }                        // cap to viewport width
          var dh: i64 = ih
          if dw < iw { if iw > 0 { dh = ih * dw / iw } }      // preserve aspect on downscale
          if dw > 0 { if dh > 0 {
              br_blit_rgb(fb, ib.x * scale, (ib.y - scroll_y + NX_CHROME_H) * scale, dw * scale, dh * scale, ip as *u8, iw, ih)
          } }
      }
      i = i + 1
  }
  // chrome (all coords * scale) -- Chrome-palette grays, same geometry (hit-tests unchanged). Dark theme
  // swaps the palette (near-black toolbar + light glyphs) so the whole browser is coherent in dark mode.
  var c_bar: i64 = 0x00F1F3F4
  var c_edge: i64 = 0x00DADCE0
  var c_btn: i64 = 0x00F6F8FA
  var c_field: i64 = 0x00FFFFFF
  var c_ink: i64 = 0x00202124
  if page.dark_mode == 1 { c_bar=0x001A1F28; c_edge=0x00303845; c_btn=0x00232833; c_field=0x000E1116; c_ink=0x00D4DAE3 }
  nx_paint_solid_rect(fb, 0, 0, win_w * scale, NX_CHROME_H * scale, br_color_from_int(c_bar))
  nx_paint_solid_rect(fb, 0, (NX_CHROME_H - 1) * scale, win_w * scale, scale, br_color_from_int(c_edge))
  nx_paint_solid_rect(fb, 8 * scale, 8 * scale, 30 * scale, 28 * scale, br_color_from_int(c_btn))
  nx_paint_solid_rect(fb, 44 * scale, 8 * scale, 30 * scale, 28 * scale, br_color_from_int(c_btn))
  nx_paint_solid_rect(fb, 80 * scale, 8 * scale, 30 * scale, 28 * scale, br_color_from_int(c_btn))
  br_paint_text2x(fb, 18 * scale, 16 * scale, "<\x00" as *u8, 1, br_color_from_int(c_ink), scale)
  br_paint_text2x(fb, 54 * scale, 16 * scale, ">\x00" as *u8, 1, br_color_from_int(c_ink), scale)
  br_paint_text2x(fb, 90 * scale, 16 * scale, "R\x00" as *u8, 1, br_color_from_int(c_ink), scale)
  let bx: i64 = 118
  nx_paint_solid_rect(fb, bx * scale, 8 * scale, (win_w - bx - 10) * scale, 28 * scale, br_color_from_int(c_field))
  var un: i64 = ulen
  if un > 110 { un = 110 }
  br_paint_text2x(fb, (bx + 6) * scale, 14 * scale, cur_url, un, br_color_from_int(c_ink), scale)
  return 0
1378}
1379
1380// the un-scrolled draw every existing caller uses (delegates; page top at the viewport top).
1381func br_draw_fb(fb: *Framebuffer, page: *Page, win_w: i64, cur_url: *u8, ulen: i64, scale: i64) -> i64 {
  return br_draw_fb_at(fb, page, win_w, cur_url, ulen, scale, 0)
1383}
1384
1385// render the laid-out page to a 1000xSH RGBA framebuffer and write it as a PNG at `path`
1386// FULL-PAGE SHOT (2026-07-27). SH was hardcoded 1000 = ONE SCREENFUL, while Chrome's
1387// --screenshot captures the WHOLE document. Comparing the two graded Nishi on ~21% of a
1388// page against Chrome on 100% of it -- so the only honest fixes are to raise Nishi to
1389// Chrome's behaviour (this) or to cripple the oracle (never). Capture the full laid-out
1390// height, clamped: floor 1000 (an empty/short page still yields a normal-looking shot),
1391// ceiling 20000 (a runaway page_h can't ask for a gigabyte framebuffer).
1392func br_shot_png(page: *Page, cur_url: *u8, ulen: i64, path: *u8) -> i64 {
  let SW: i64 = 1000
  var SH: i64 = page.page_h
  if SH < 1000 { SH = 1000 }
  if SH > 20000 { SH = 20000 }
  let fb: *Framebuffer = sys_mmap(NX_FRAMEBUFFER_BYTES) as *Framebuffer
  let px: *u8 = sys_mmap(SW * SH * 4 + 64)
  nx_framebuffer_init(fb, px, SW, SH)
  br_draw_fb(fb, page, SW, cur_url, ulen, 1)
  let rgb: *u8 = sys_mmap(SW * SH * 3 + 64)
  var p: i64 = 0
  while p < SW * SH {
      rgb[p * 3 + 0] = px[p * 4 + 0]
      rgb[p * 3 + 1] = px[p * 4 + 1]
      rgb[p * 3 + 2] = px[p * 4 + 2]
      p = p + 1
  }
  nx_png_write_rgb(path, rgb, SW, SH)
  return 0
1411}
1412
1413// hit-test: find a box with an href whose rect contains doc-point (dx,dy). 1 + sets off/len, else 0.
1414// CONTAINER ANCHORS (2026-07-03): an <a> wrapping block children (e.g. a card link: <a><h3>..</h3>
1415// <p>..</p></a>) lays out with a ZERO own-rect -- its geometry lives in its DESCENDANT boxes. Such
1416// links were dead to clicks (found by nx_aw_browser_gate on the real andelinwest pages). For an href
1417// box with no height, hit-test the UNION of its descendants' rects instead. Purely additive: boxes
1418// with real rects behave exactly as before; zero-rect href boxes previously matched NOTHING.
1419func br_hit_link(page: *Page, dx: i64, dy: i64, off: *i64, len: *i64) -> i64 {
  let tree: *LayoutTree = page.tree
  var i: i64 = 0
  while i < tree.count {
      if page.bhref_off[i] >= 0 {
          let b: *LayoutBox = ((tree.boxes as i64) + i * NX_LAYOUT_BOX_BYTES) as *LayoutBox
          var bx: i64 = b.x
          var by: i64 = b.y
          var bw: i64 = b.w
          var bh: i64 = b.h
          if bh <= 0 {
              // SIBLING-SPAN effective rect: the layout FLATTENS a container anchor's children to
              // its SIBLINGS (observed: card content boxes follow the zero-rect anchor box under
              // the same parent). Union the rects of the boxes AFTER i while they stay inside i's
              // parent's subtree, stopping at the next href-carrying box (= the next link).
              let par: i64 = b.parent_idx
              var x0: i64 = 0
              var y0: i64 = 0
              var x1: i64 = 0
              var y1: i64 = 0
              var any: i64 = 0
              var j: i64 = i + 1
              var span: i64 = 1
              while span == 1 {
                  if j >= tree.count { span = 0 }
                  else { if page.bhref_off[j] >= 0 { span = 0 }
                  else {
                      let cb: *LayoutBox = ((tree.boxes as i64) + j * NX_LAYOUT_BOX_BYTES) as *LayoutBox
                      // is j inside par's subtree? (bounded parent-chain walk, cycle-safe)
                      var p: i64 = cb.parent_idx
                      var hop: i64 = 0
                      var inside: i64 = 0
                      while hop < 64 {
                          if p == (0 - 1) { hop = 64 }
                          else { if p == par { inside = 1; hop = 64 }
                          else { let pb: *LayoutBox = ((tree.boxes as i64) + p * NX_LAYOUT_BOX_BYTES) as *LayoutBox; p = pb.parent_idx; hop = hop + 1 } }
                      }
                      if inside == 0 { span = 0 }
                      else {
                          if cb.w > 0 { if cb.h > 0 {
                              if any == 0 { x0 = cb.x; y0 = cb.y; x1 = cb.x + cb.w; y1 = cb.y + cb.h; any = 1 }
                              else {
                                  if cb.x < x0 { x0 = cb.x }
                                  if cb.y < y0 { y0 = cb.y }
                                  if cb.x + cb.w > x1 { x1 = cb.x + cb.w }
                                  if cb.y + cb.h > y1 { y1 = cb.y + cb.h }
                              }
                          } }
                          j = j + 1
                      }
                  } }
              }
              if any == 1 { bx = x0; by = y0; bw = x1 - x0; bh = y1 - y0 }
          }
          var hitw: i64 = bw                              // layout metric now matches the 9px render font, so b.w is the true width
          if hitw < 12 { hitw = 12 }
          if dx >= bx { if dx < bx + hitw { if dy >= by { if dy < by + bh {
              off[0] = page.bhref_off[i]; len[0] = page.bhref_len[i]; return 1
          } } } }
      }
      i = i + 1
  }
  return 0
1482}
nx_browser_render.nx source

`nx_browser_render.nx` source
