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

↩ module page · 271 lines · 20051 B
1// nx_browser_bg_gate.nx -- proves the Nishi Browser box painter fills element backgrounds given as rgb() (and
2// the fleet var(--token) that resolves to rgb()), through the REAL browser render path (br_layout + br_draw_fb).
3// ROOT CAUSE this locks: br_comp_bg's `background` SHORTHAND branch was hex-only, so the office chrome
4// (buttons/.fico badges use `background:var(--acc)` -> `background:rgb(...)`) painted NOTHING natively -- the live
5// office rendered monochrome in our own browser while Waterfox was fine. license_tier: ORIGINAL  expect_exit: 0
6import "nx_browser_render.nx"
7
8func p(s: *u8) -> i64 { var n: i64 = 0; while s[n] != (0 as u8) { n = n + 1 } sys_write(1, s, n); return 0 }
9func bg_slen(s: *u8) -> i64 { var n: i64 = 0; while s[n] != (0 as u8) { n = n + 1 } return n }
10// render hlen bytes at viewport render_w; return the accent X-SPAN (maxx-minx) in the hint's y-band. This is
11// the CORRECT overflow metric: at a MULTI-COLUMN width (>=800px, so minmax(230px) makes real ~250px columns),
12// a hint that WRAPS stays within its ~250px column (small x-span); one that OVERFLOWS spans much wider. (My
13// earlier 400px y-span tests were a CALIBRATION ARTIFACT: minmax(230px)@400px = ONE wide column, never repro.)
14func bg_xspan_at(html: *u8, hlen: i64, render_w: i64) -> i64 {
  let page: *Page = sys_mmap(NX_PAGE_BYTES) as *Page
  page.raw = html
  page.raw_len = hlen
  page.dark_mode = 0
  br_layout(page, render_w)
  page.vec_headings = 0
  var H: i64 = page.page_h + NX_CHROME_H + 40
  if H < 120 { H = 120 }
  if H > 4000 { H = 4000 }
  let pxb: *u8 = sys_mmap((render_w * H * 4) as nx_size)
  let fb: *Framebuffer = sys_mmap(NX_FRAMEBUFFER_BYTES as nx_size) as *Framebuffer
  nx_framebuffer_init(fb, pxb, render_w, H)
  nx_framebuffer_clear(fb)
  br_draw_fb(fb, page, render_w, "http://t\x00" as *u8, 8, 1)
  let pxc: *CssColor = sys_mmap(NX_CSS_COLOR_BYTES as nx_size) as *CssColor
  var minx: i64 = 0 - 1
  var maxx: i64 = 0 - 1
  var y: i64 = 0
  while y < H {
      var x: i64 = 0
      while x < render_w {
          nx_framebuffer_get_pixel(fb, x, y, pxc)
          var dr: i64 = (pxc.r as i64) - 41
          if dr < 0 { dr = 0 - dr }
          var dg: i64 = (pxc.g as i64) - 84
          if dg < 0 { dg = 0 - dg }
          var db: i64 = (pxc.b as i64) - 164
          if db < 0 { db = 0 - db }
          if dr <= 14 { if dg <= 14 { if db <= 14 { if minx < 0 { minx = x } if x > maxx { maxx = x } } } }
          x = x + 2
      }
      y = y + 2
  }
  if minx < 0 { return 0 - 1 }
  return maxx - minx
50}
51func bg_accent(html: *u8) -> i64 { return bg_accent_n(html, bg_slen(html)) }
52// render hlen bytes of html through the browser core; return count of ~rgb(41,84,164) accent pixels.
53func bg_accent_n(html: *u8, hlen: i64) -> i64 {
  let page: *Page = sys_mmap(NX_PAGE_BYTES) as *Page
  page.raw = html
  page.raw_len = hlen
  page.dark_mode = 0
  br_layout(page, 400)
  page.vec_headings = 0
  var H: i64 = page.page_h + NX_CHROME_H + 40
  if H < 120 { H = 120 }
  if H > 4000 { H = 4000 }
  let px: *u8 = sys_mmap((400 * H * 4) as nx_size)
  let fb: *Framebuffer = sys_mmap(NX_FRAMEBUFFER_BYTES as nx_size) as *Framebuffer
  nx_framebuffer_init(fb, px, 400, H)
  nx_framebuffer_clear(fb)
  br_draw_fb(fb, page, 400, "http://t\x00" as *u8, 8, 1)
  let pxc: *CssColor = sys_mmap(NX_CSS_COLOR_BYTES as nx_size) as *CssColor
  var acc: i64 = 0
  var y: i64 = 0
  while y < H {
      var x: i64 = 0
      while x < 400 {
          nx_framebuffer_get_pixel(fb, x, y, pxc)
          var dr: i64 = (pxc.r as i64) - 41
          if dr < 0 { dr = 0 - dr }
          var dg: i64 = (pxc.g as i64) - 84
          if dg < 0 { dg = 0 - dg }
          var db: i64 = (pxc.b as i64) - 164
          if db < 0 { db = 0 - db }
          if dr <= 14 { if dg <= 14 { if db <= 14 { acc = acc + 1 } } }
          x = x + 2
      }
      y = y + 2
  }
  return acc
87}
88// render html; return the accent-pixel Y-SPAN (max_y - min_y). Children laid SIDE-BY-SIDE share a row -> small
89// span; STACKED children span many rows -> large span. Discriminates real grid/flex row layout from stacking.
90func bg_yspan(html: *u8) -> i64 {
  let hlen: i64 = bg_slen(html)
  let page: *Page = sys_mmap(NX_PAGE_BYTES) as *Page
  page.raw = html
  page.raw_len = hlen
  page.dark_mode = 0
  br_layout(page, 400)
  page.vec_headings = 0
  var H: i64 = page.page_h + NX_CHROME_H + 40
  if H < 120 { H = 120 }
  if H > 4000 { H = 4000 }
  let pxb: *u8 = sys_mmap((400 * H * 4) as nx_size)
  let fb: *Framebuffer = sys_mmap(NX_FRAMEBUFFER_BYTES as nx_size) as *Framebuffer
  nx_framebuffer_init(fb, pxb, 400, H)
  nx_framebuffer_clear(fb)
  br_draw_fb(fb, page, 400, "http://t\x00" as *u8, 8, 1)
  let pxc: *CssColor = sys_mmap(NX_CSS_COLOR_BYTES as nx_size) as *CssColor
  var miny: i64 = 0 - 1
  var maxy: i64 = 0 - 1
  var y: i64 = 0
  while y < H {
      var x: i64 = 0
      while x < 400 {
          nx_framebuffer_get_pixel(fb, x, y, pxc)
          var dr: i64 = (pxc.r as i64) - 41
          if dr < 0 { dr = 0 - dr }
          var dg: i64 = (pxc.g as i64) - 84
          if dg < 0 { dg = 0 - dg }
          var db: i64 = (pxc.b as i64) - 164
          if db < 0 { db = 0 - db }
          if dr <= 14 { if dg <= 14 { if db <= 14 { if miny < 0 { miny = y } maxy = y } } }
          x = x + 2
      }
      y = y + 2
  }
  if miny < 0 { return 0 - 1 }
  return maxy - miny
127}
128func bg_ck(name: *u8, cond: i64, cnt: i64, pass: *i64, fail: *i64) -> i64 {
  if cond == 1 { p("  PASS " as *u8) } else { p("  FAIL " as *u8) }
  p(name)
  p("  (accent-px=" as *u8)
  var v: i64 = cnt
  let t: *u8 = sys_mmap(16)
  var k: i64 = 0
  if v == 0 { t[0] = 48 as u8; k = 1 }
  while v > 0 { t[k] = (48 + (v % 10)) as u8; v = v / 10; k = k + 1 }
  var z: i64 = 0
  while z < k { let c: *u8 = sys_mmap(2); c[0] = t[k - 1 - z]; sys_write(1, c, 1); z = z + 1 }
  p(")\n" as *u8)
  if cond == 1 { pass[0] = pass[0] + 1; return 1 }
  fail[0] = fail[0] + 1
  return 0
143}
144func main() -> i64 {
  p("=== NX-BROWSER-BG GATE (native element-background painting, rgb() + fleet var tokens) ===\n" as *u8)
  let pass: *i64 = sys_mmap(16) as *i64
  let fail: *i64 = sys_mmap(16) as *i64
  pass[0] = 0
  fail[0] = 0
150
  let a1: i64 = bg_accent("<html><head><style>p{background-color:rgb(41,84,164)}</style></head><body><p>accent fill line accent fill line accent fill line accent</p></body></html>" as *u8)
  bg_ck("T1 background-color:rgb() fills (baseline)" as *u8, (a1 > 0) as i64, a1, pass, fail)
153
  let a2: i64 = bg_accent("<html><head><style>p{background:rgb(41,84,164)}</style></head><body><p>accent fill line accent fill line accent fill line accent</p></body></html>" as *u8)
  bg_ck("T2 background:rgb() SHORTHAND fills (office chrome)" as *u8, (a2 > 0) as i64, a2, pass, fail)
156
  let a3: i64 = bg_accent("<html><head><style>:root{--acc:rgb(41,84,164)}p{background:var(--acc)}</style></head><body><p>accent fill line accent fill line accent fill line accent</p></body></html>" as *u8)
  bg_ck("T3 background:var(--acc) SHORTHAND+token fills (the exact office pattern)" as *u8, (a3 > 0) as i64, a3, pass, fail)
159
  // T4/T5: is the office monochrome render a LAYOUT collapse? accent child inside display:grid / display:flex.
  let a4: i64 = bg_accent("<html><head><style>.g{display:grid}.b{background:rgb(41,84,164);padding-top:20px;padding-bottom:20px}</style></head><body><div class='g'><div class='b'>accent grid child accent grid child accent</div></div></body></html>" as *u8)
  bg_ck("T4 accent child inside display:GRID still fills (office .newrow/.fgrid)" as *u8, (a4 > 0) as i64, a4, pass, fail)
163
  let a5: i64 = bg_accent("<html><head><style>.f{display:flex}.b{background:rgb(41,84,164);padding-top:20px;padding-bottom:20px}</style></head><body><div class='f'><div class='b'>accent flex child accent flex child accent</div></div></body></html>" as *u8)
  bg_ck("T5 accent child inside display:FLEX still fills (office .top/button rows)" as *u8, (a5 > 0) as i64, a5, pass, fail)
166
  // T8 DIAGNOSTIC: display:none on a <textarea> (raw-text el) must hide it + its content -> 0 accent. The
  // office .starter{display:none} textareas were LEAKING their spec text in the native render.
  let a8: i64 = bg_accent("<html><head><style>.starter{display:none;background:rgb(41,84,164);padding-top:20px;padding-bottom:20px}</style></head><body><p>before</p><textarea class='starter'>H hidden spec P should not show</textarea><p>after</p></body></html>" as *u8)
  bg_ck("T8 display:none hides a <textarea> + its raw content (0 accent)" as *u8, (a8 == 0) as i64, a8, pass, fail)
171
  // T8b LOCALIZE: office-exact textarea = class BEFORE a second attr (name), content with a newline.
  let a8b: i64 = bg_accent("<html><head><style>.starter{display:none;background:rgb(41,84,164);padding-top:20px;padding-bottom:20px}</style></head><body><p>before</p><textarea class='starter' name='spec'>H Untitled\nP Start here</textarea><p>after</p></body></html>" as *u8)
  bg_ck("T8b display:none hides textarea with class+name attrs (0 accent)" as *u8, (a8b == 0) as i64, a8b, pass, fail)
175
  // T7 GRID ROW LAYOUT: 4 accent children (~30px tall) in repeat(auto-fit,minmax(80px,1fr)) at 400px = 4
  // columns -> ONE row (y-span ~ one child). The old parser read auto-fit as 1 col -> 4 STACKED rows (y-span
  // ~4x). So a SMALL y-span proves side-by-side. (b children each 30px: side-by-side<=60, stacked>=120.)
  let ys: i64 = bg_yspan("<html><head><style>.g{display:grid;grid-template-columns:repeat(auto-fit,minmax(80px,1fr))}.b{background:rgb(41,84,164);padding-top:14px;padding-bottom:14px}</style></head><body><div class='g'><div class='b'>a</div><div class='b'>b</div><div class='b'>c</div><div class='b'>d</div></div></body></html>" as *u8)
  bg_ck("T7 repeat(auto-fit,minmax()) lays children SIDE-BY-SIDE (small accent y-span)" as *u8, (ys >= 0) as i64 & (ys < 90) as i64, ys, pass, fail)
181
  // T10 DIAGNOSTIC (characterize the tile-hint overflow): a LONG accent-bg paragraph in a ~90px grid column.
  // If text WRAPS to the column width, the bg box is TALL (many lines -> big y-span); if it does NOT wrap, the
  // box is one short line that overflows sideways (small y-span). This measures whether narrow-column block
  // text wraps in the native engine. (~55 chars at ~9px = ~500px; at 90px that's ~6 wrapped lines if wrapping.)
  let yw: i64 = bg_yspan("<html><head><style>.g{display:grid;grid-template-columns:repeat(auto-fit,minmax(90px,1fr))}.b{background:rgb(41,84,164)}</style></head><body><div class='g'><div><p class='b'>headlines bold tables opens in word real formulas sum average</p></div><div>x</div><div>y</div><div>z</div></div></body></html>" as *u8)
  bg_ck("T10 DIAG narrow-column block text wraps (tall bg box, y-span>40)" as *u8, (yw > 40) as i64, yw, pass, fail)
188
  // T10b PIN: office-exact nesting = grid item > <form> > <p> (T10 had the p DIRECTLY in the item). If this
  // does NOT wrap (small y-span) while T10 does, width propagation breaks through the <form> wrapper.
  let ywf: i64 = bg_yspan("<html><head><style>.g{display:grid;grid-template-columns:repeat(auto-fit,minmax(90px,1fr))}.b{background:rgb(41,84,164)}</style></head><body><div class='g'><div><form><p class='b'>headlines bold tables opens in word real formulas sum average</p></form></div><div>x</div><div>y</div><div>z</div></div></body></html>" as *u8)
  bg_ck("T10b DIAG same but nested in <form> wraps too (isolates the form wrapper)" as *u8, (ywf > 40) as i64, ywf, pass, fail)
193
  // (An earlier T10c-T10j maze bisected at 400px and produced a CALIBRATION ARTIFACT: minmax(230px)@400px
  // collapses to ONE wide column, so "office-shape" hints there measured a spurious small y-span. Retired --
  // the CORRECT-width locks are T11/T12/T14/T15 below. The lesson: match the render width to the layout.)
197
  // T11 THE REAL TEST (multi-column width): office tile at 1000px where minmax(230px,1fr) makes a ~250px
  // column. A WRAPPED hint's accent bg stays within its column (x-span < ~260); an OVERFLOWING one spans much
  // wider. This is what my 400px tests structurally could NOT see. (accent-bg on the hint <p>.)
  let of1: *u8 = "<html><head><style>.g{display:grid;grid-template-columns:repeat(auto-fit,minmax(230px,1fr))}.newt{border:1px solid rgb(200,200,200);padding-left:14px;padding-right:14px}.newt h3{display:flex;align-items:center;gap:8px}.b{background:rgb(41,84,164);margin:0}</style></head><body><div class='g'><div class='newt'><h3><span>W</span>New doc</h3><p class='b'>Headlines bold tables opens in word real formulas averages</p></div><div class='newt'>x</div><div class='newt'>y</div></div></body></html>" as *u8
  let xs1: i64 = bg_xspan_at(of1, bg_slen(of1), 1000)
  bg_ck("T11 office hint at 1000px stays within its ~250px column (x-span < 300)" as *u8, (xs1 >= 0) as i64 & (xs1 < 300) as i64, xs1, pass, fail)
204
  // T12 THE REAL NESTING: hint is inside a <form> (grid child > form > p), exactly like of_form emits. If this
  // OVERFLOWS at 1000px while T11 (no form) wraps, width propagation through the <form> at a multi-column
  // width is the bug (my earlier T10b "form OK" was the 400px artifact).
  let of2: *u8 = "<html><head><style>.g{display:grid;grid-template-columns:repeat(auto-fit,minmax(230px,1fr))}.newt{border:1px solid rgb(200,200,200);padding-left:14px;padding-right:14px}.newt h3{display:flex;align-items:center;gap:8px}.b{background:rgb(41,84,164);margin:0}</style></head><body><div class='g'><div class='newt'><h3><span>W</span>New doc</h3><form><input type='hidden' name='spec' value='x'><p class='b'>Headlines bold tables opens in word real formulas averages</p></form></div><div class='newt'>x</div><div class='newt'>y</div></div></body></html>" as *u8
  let xs2: i64 = bg_xspan_at(of2, bg_slen(of2), 1000)
  bg_ck("T12 hint INSIDE <form> at 1000px stays within its column (x-span < 300)" as *u8, (xs2 >= 0) as i64 & (xs2 < 300) as i64, xs2, pass, fail)
211
  // (A T13 tried to measure the REAL 3-tile page's hint x-span, but x-span = maxx-minx conflates CORRECT
  // column-spread (3 hints across 3 columns naturally span ~900px) with a single-hint overflow -- retired as
  // a bad metric. Per-column isolation would be needed to pin the real 3-tile overlap; deferred as a minor rung.)
215
  // T14 the hint carries an inline style='margin:0' attr (real page does). Measured
  // as a SINGLE tile so x-span is one hint. If inline-style parsing mis-sizes the box -> overflow (>300).
  let of4: *u8 = "<html><head><style>.g{display:grid;grid-template-columns:repeat(auto-fit,minmax(230px,1fr));gap:12px}.newt{border:1px solid rgb(200,200,200);padding-left:14px;padding-right:14px}.newt h3{display:flex;align-items:center;gap:8px}.b{background:rgb(41,84,164)}</style></head><body><div class='g'><div class='newt'><h3><span>W</span>New doc</h3><form><input type='hidden' name='spec' value='x'><p class='b' style='margin:0'>Headlines bold tables opens in word real formulas averages</p></form></div></div></body></html>" as *u8
  let xs4: i64 = bg_xspan_at(of4, bg_slen(of4), 1000)
  bg_ck("T14 single tile, inline style='margin:0' hint at 1000px stays column-bounded (x-span < 300)" as *u8, (xs4 >= 0) as i64 & (xs4 < 300) as i64, xs4, pass, fail)
221
  // T15 FULL REAL NESTING DEPTH, single tile: body > main.wrap(max-width) > div.newrow > div.newt > form > p.
  // The real page nests deeper than my shallow synthetics; if width propagation DEGRADES with depth this
  // overflows (>300) -> a REAL engine bug (affects many pages), worth fixing. If it wraps, the office overlap
  // is a real-page-only quirk I could not isolate cheaply.
  let of5: *u8 = "<html><head><style>.wrap{max-width:1200px;margin:0 auto;padding:16px 20px}.newrow{display:grid;grid-template-columns:repeat(auto-fit,minmax(230px,1fr));gap:12px}.newt{border:1px solid rgb(200,200,200);padding:12px 14px}.newt h3{display:flex;align-items:center;gap:8px}.b{background:rgb(41,84,164);margin:0}</style></head><body><main class='wrap'><div class='newrow'><div class='newt'><h3><span>W</span>New doc</h3><form><input type='hidden' name='spec' value='x'><p class='b'>Headlines bold tables opens in word real formulas averages</p></form></div></div></main></body></html>" as *u8
  let xs5: i64 = bg_xspan_at(of5, bg_slen(of5), 1000)
  bg_ck("T15 FULL real nesting depth single tile at 1000px stays column-bounded (x-span < 300)" as *u8, (xs5 >= 0) as i64 & (xs5 < 300) as i64, xs5, pass, fail)
229
  // T16 .fico BADGE (the office fix): a <div class='fico'> (BLOCK kind) flex-item in a display:flex h3 PAINTS
  // its 26x26 accent square. (26x26 at 2px sampling = ~169 cells, minus the white letter -> ~150+; >120 safe.)
  let ficd: *u8 = "<html><head><style>.hd{display:flex;align-items:center;gap:8px}.fico{width:26px;height:26px;background:rgb(41,84,164);display:flex;align-items:center;justify-content:center;color:rgb(255,255,255)}</style></head><body><div class='newt'><h3 class='hd'><div class='fico'>W</div>New doc</h3></div></body></html>" as *u8
  let afd: i64 = bg_accent_n(ficd, bg_slen(ficd))
  bg_ck("T16 <div> badge (office fix) paints its 26x26 accent square (>120)" as *u8, (afd > 120) as i64, afd, pass, fail)
  // T16b ENGINE FIX: a <span> (INLINE tag) with display:flex is now PROMOTED to BLOCK kind after cascade
  // (rh_promote_display_kinds) -> it gets a sized box AND its bg paints. Was 0 before the fix; now paints its
  // 26x26 square like the <div>. This is the foundational fix (box kind from tag ignored CSS display); it also
  // covers any display:flex/grid/block-overridden inline element, not just badges.
  let fics: *u8 = "<html><head><style>.hd{display:flex;align-items:center;gap:8px}.fico{width:26px;height:26px;background:rgb(41,84,164);display:flex;align-items:center;justify-content:center;color:rgb(255,255,255)}</style></head><body><div class='newt'><h3 class='hd'><span class='fico'>W</span>New doc</h3></div></body></html>" as *u8
  let afs: i64 = bg_accent_n(fics, bg_slen(fics))
  bg_ck("T16b ENGINE FIX: <span display:flex> promoted to BLOCK -> badge bg now paints (>120)" as *u8, (afs > 120) as i64, afs, pass, fail)
242
  // T6: the ACTUAL live office HTML (fetched to office_live_snap.html) through the browser core -- if this
  // paints accent, the earlier live-shot 0 was a SHOT-WINDOW artifact, not a render failure. Skips clean if
  // the snapshot file is absent (so the gate stays runnable without a fetch).
  let lp: *i64 = sys_mmap(16) as *i64
  let ohtml: *u8 = sys_read_file("office_live_snap.html\x00" as *u8, lp)
  if lp[0] > 0 {
      let a6: i64 = bg_accent_n(ohtml, lp[0])
      bg_ck("T6 LIVE office HTML paints accent chrome in the browser core" as *u8, (a6 > 0) as i64, a6, pass, fail)
  } else {
      p("  SKIP T6 (no office_live_snap.html)\n" as *u8)
  }
254
  // NOTE: the office's earlier starter-leak (a display:none <textarea> rendering its spec text in the
  // full-page cascade -- a box<->element mapping drift in complex trees with raw-text elements) is now
  // fixed AT SOURCE: of_form emits an <input type=hidden> (correct for a hidden default value; renders
  // nothing in every engine). The underlying engine mapping bug is documented as a named rung.
259
  p("NX-BROWSER-BG-GATE pass=" as *u8)
  var pv: i64 = pass[0]
  let tp: *u8 = sys_mmap(16)
  var pk: i64 = 0
  if pv == 0 { tp[0] = 48 as u8; pk = 1 }
  while pv > 0 { tp[pk] = (48 + (pv % 10)) as u8; pv = pv / 10; pk = pk + 1 }
  var pz: i64 = 0
  while pz < pk { let c3: *u8 = sys_mmap(2); c3[0] = tp[pk - 1 - pz]; sys_write(1, c3, 1); pz = pz + 1 }
  if fail[0] == 0 { p(" fail=0 verdict=GREEN\n" as *u8); sys_exit(0); return 0 }
  p(" fail>0 verdict=RED\n" as *u8); sys_exit(1)
  return 1
271}
nx_browser_bg_gate.nx source

`nx_browser_bg_gate.nx` source
