code wiki / (root) / nx_layout_block.nx
`nx_layout_block.nx` source

↩ module page · 2503 lines · 124638 B
1// nx_layout_block.nx -- normal-flow block layout for the Nishi
2// browser. Phase 3 second primitive of NISHI_BROWSER_ROADMAP. Walks
3// a LayoutBox tree (from nx_layout_box, shipped previously) top-down,
4// queries each box's CssComputedDecl slice (from nx_css_apply, Phase 2)
5// for width / height / margin / padding, and assigns concrete
6// (x, y, w, h) integer pixels.
7//
8// Subset implemented:
9//   - BLOCK boxes only (INLINE / INLINE_BLOCK handled by nx_layout_inline,
10//     queued)
11//   - Normal flow ONLY (no positioned / float / grid / flex)
12//   - content-box sizing (CSS default; box-sizing: border-box is
13//     Phase 3b queued)
14//   - Per-box style queries via nx_css_lookup_property + value
15//     decode via nx_css_dimension_to_px
16//   - margin-top, margin-bottom, padding-top, padding-bottom
17//     (horizontal margin/padding deferred to Phase 3b -- horizontal
18//     layout currently sets w = parent.content_w for all blocks)
19//   - Explicit width / height declarations consume cascade value;
20//     auto height = sum of children heights
21//
22// What it does NOT handle (Phase 3b queued):
23//   - margin / padding on left / right axes
24//   - margin collapse between adjacent block siblings
25//   - border-top / border-bottom contribution to height
26//   - width: auto with horizontal centering via margin: auto
27//   - min-width / max-width / min-height / max-height
28//   - height: percentage of parent (needs parent.h resolved first)
29//   - INLINE child layout (inline boxes inside block context)
30//   - float / clear
31//   - positioned (relative / absolute / fixed / sticky)
32//   - overflow / scroll
33//
34// Per cardinal feedback-honest-perf-verdict-no-aspirational-claims:
35// gap list is EXACT.
36//
37// genealogy_id: w3c_css_box_model_module_level_3_normal_flow +
38//               substrate_browser_phase_3_block_layout
39// lineage_id:   nishi_browser_layout_block_v1
40//
41// nx_safety_envelope:
42//   intended_use:       "Block layout normal flow -- browser layout"
43//   sil_target:         SIL1
44//   evidence:           [W3C_CSS_Box_Model_canonical_basis,
45//                        bounded_tree_walk,
46//                        integer_px_arithmetic_no_FP]
47//   verdict:            NOT_YET_EVALUATED
48
49import "nx_syscalls.nx"
50import "nx_text_wrap.nx"
51import "nx_font8x8.nx"     // measured-text mode: proportional advances from the font's metrics SSOT
52import "nx_font.nx"        // VECTOR metrics (font_adv_em): opt-in vec-measure mode so layout reserves the
                         // SAME widths the vector paint draws (S21: bitmap-reserve vs vector-draw drift
                         // put gaps around every styled inline span/link)
55import "nx_css_tokenize.nx"
56import "nx_css_parse.nx"
57import "nx_css_selector_match.nx"
58import "nx_css_apply.nx"
59import "nx_css_number_parse.nx"
60import "nx_css_dimension_to_px.nx"
61import "nx_layout_box.nx"
62const NX_MAGIC_100000: i64 = 100000
63const NX_MAGIC_37795: i64 = 37795
64const NX_MAGIC_10000: i64 = 10000
65const NX_MAGIC_65536: i64 = 65536
66const NX_MAGIC_1000000000: i64 = 1000000000
67const NX_MAGIC_4096: i64 = 4096
68
69// Layout context bundle. Caller-supplied; pointers shared across the
70// recursive walk so signatures stay under the nxc2 16-arg parser
71// limit per [[feedback-nishilang-16-arg-function-limit]].
72struct LayoutCtx {
  tree: *LayoutTree,
  computed: *CssComputedDecl,
  n_computed: i64,
  src: *u8,
  viewport_w: i64,
  resolve_ctx: *CssResolveCtx,
  text_measured: i64,            // 1 = PROPORTIONAL text sizing/wrap (font8x8 measured advances); 0 = legacy 9px cells
  font_tab: i64                  // cached font8x8_table() when text_measured=1 (as i64; 0 = lazily filled)
81}
82
83const NX_LAYOUT_CTX_BYTES: i64 = 64
84
85// Property names live in a small caller-supplied byte buffer so the
86// cascade lookups can byte-equal them. Offsets are fixed by
87// _layout_property_table_init below.
88struct LayoutPropTable {
  src: *u8,
  width_off: i64,
  width_len: i64,
  height_off: i64,
  height_len: i64,
  margin_top_off: i64,
  margin_top_len: i64,
  margin_bottom_off: i64,
  margin_bottom_len: i64,
  margin_left_off: i64,
  margin_left_len: i64,
  margin_right_off: i64,
  margin_right_len: i64,
  padding_top_off: i64,
  padding_top_len: i64,
  padding_bottom_off: i64,
  padding_bottom_len: i64,
  padding_left_off: i64,
  padding_left_len: i64,
  padding_right_off: i64,
  padding_right_len: i64
110}
111
112const NX_LAYOUT_PROP_TABLE_BYTES: i64 = 168
113
114// ---- helpers ----
115
116func _layout_put_byte(buf: *u8, i: i64, v: i64) -> i64 {
  buf[i] = v as u8
  return 0
119}
120
121// Bundle the canonical property name bytes into the table.  The
122// table's `src` buffer must be at least 64 bytes.
123func nx_layout_prop_table_init(t: *LayoutPropTable, buf: *u8) -> i64 {
  t.src = buf
  // "width"           offset 0   len 5
  _layout_put_byte(buf, 0, 119)
  _layout_put_byte(buf, 1, 105)
  _layout_put_byte(buf, 2, 100)
  _layout_put_byte(buf, 3, 116)
  _layout_put_byte(buf, 4, 104)
  t.width_off = 0
  t.width_len = 5
  // "height"          offset 5   len 6
  _layout_put_byte(buf, 5, 104)
  _layout_put_byte(buf, 6, 101)
  _layout_put_byte(buf, 7, 105)
  _layout_put_byte(buf, 8, 103)
  _layout_put_byte(buf, 9, 104)
  _layout_put_byte(buf, 10, 116)
  t.height_off = 5
  t.height_len = 6
  // "margin-top"      offset 11  len 10
  _layout_put_byte(buf, 11, 109)
  _layout_put_byte(buf, 12, 97)
  _layout_put_byte(buf, 13, 114)
  _layout_put_byte(buf, 14, 103)
  _layout_put_byte(buf, 15, 105)
  _layout_put_byte(buf, 16, 110)
  _layout_put_byte(buf, 17, 45)
  _layout_put_byte(buf, 18, 116)
  _layout_put_byte(buf, 19, 111)
  _layout_put_byte(buf, 20, 112)
  t.margin_top_off = 11
  t.margin_top_len = 10
  // "margin-bottom"   offset 21  len 13
  _layout_put_byte(buf, 21, 109)
  _layout_put_byte(buf, 22, 97)
  _layout_put_byte(buf, 23, 114)
  _layout_put_byte(buf, 24, 103)
  _layout_put_byte(buf, 25, 105)
  _layout_put_byte(buf, 26, 110)
  _layout_put_byte(buf, 27, 45)
  _layout_put_byte(buf, 28, 98)
  _layout_put_byte(buf, 29, 111)
  _layout_put_byte(buf, 30, 116)
  _layout_put_byte(buf, 31, 116)
  _layout_put_byte(buf, 32, 111)
  _layout_put_byte(buf, 33, 109)
  t.margin_bottom_off = 21
  t.margin_bottom_len = 13
  // "padding-top"     offset 34  len 11
  _layout_put_byte(buf, 34, 112)
  _layout_put_byte(buf, 35, 97)
  _layout_put_byte(buf, 36, 100)
  _layout_put_byte(buf, 37, 100)
  _layout_put_byte(buf, 38, 105)
  _layout_put_byte(buf, 39, 110)
  _layout_put_byte(buf, 40, 103)
  _layout_put_byte(buf, 41, 45)
  _layout_put_byte(buf, 42, 116)
  _layout_put_byte(buf, 43, 111)
  _layout_put_byte(buf, 44, 112)
  t.padding_top_off = 34
  t.padding_top_len = 11
  // "padding-bottom"  offset 45  len 14
  _layout_put_byte(buf, 45, 112)
  _layout_put_byte(buf, 46, 97)
  _layout_put_byte(buf, 47, 100)
  _layout_put_byte(buf, 48, 100)
  _layout_put_byte(buf, 49, 105)
  _layout_put_byte(buf, 50, 110)
  _layout_put_byte(buf, 51, 103)
  _layout_put_byte(buf, 52, 45)
  _layout_put_byte(buf, 53, 98)
  _layout_put_byte(buf, 54, 111)
  _layout_put_byte(buf, 55, 116)
  _layout_put_byte(buf, 56, 116)
  _layout_put_byte(buf, 57, 111)
  _layout_put_byte(buf, 58, 109)
  t.padding_bottom_off = 45
  t.padding_bottom_len = 14
  // "margin-left"     offset 59  len 11
  _layout_put_byte(buf, 59, 109)
  _layout_put_byte(buf, 60, 97)
  _layout_put_byte(buf, 61, 114)
  _layout_put_byte(buf, 62, 103)
  _layout_put_byte(buf, 63, 105)
  _layout_put_byte(buf, 64, 110)
  _layout_put_byte(buf, 65, 45)
  _layout_put_byte(buf, 66, 108)
  _layout_put_byte(buf, 67, 101)
  _layout_put_byte(buf, 68, 102)
  _layout_put_byte(buf, 69, 116)
  t.margin_left_off = 59
  t.margin_left_len = 11
  // "margin-right"    offset 70  len 12
  _layout_put_byte(buf, 70, 109)
  _layout_put_byte(buf, 71, 97)
  _layout_put_byte(buf, 72, 114)
  _layout_put_byte(buf, 73, 103)
  _layout_put_byte(buf, 74, 105)
  _layout_put_byte(buf, 75, 110)
  _layout_put_byte(buf, 76, 45)
  _layout_put_byte(buf, 77, 114)
  _layout_put_byte(buf, 78, 105)
  _layout_put_byte(buf, 79, 103)
  _layout_put_byte(buf, 80, 104)
  _layout_put_byte(buf, 81, 116)
  t.margin_right_off = 70
  t.margin_right_len = 12
  // "padding-left"    offset 82  len 12
  _layout_put_byte(buf, 82, 112)
  _layout_put_byte(buf, 83, 97)
  _layout_put_byte(buf, 84, 100)
  _layout_put_byte(buf, 85, 100)
  _layout_put_byte(buf, 86, 105)
  _layout_put_byte(buf, 87, 110)
  _layout_put_byte(buf, 88, 103)
  _layout_put_byte(buf, 89, 45)
  _layout_put_byte(buf, 90, 108)
  _layout_put_byte(buf, 91, 101)
  _layout_put_byte(buf, 92, 102)
  _layout_put_byte(buf, 93, 116)
  t.padding_left_off = 82
  t.padding_left_len = 12
  // "padding-right"   offset 94  len 13
  _layout_put_byte(buf, 94, 112)
  _layout_put_byte(buf, 95, 97)
  _layout_put_byte(buf, 96, 100)
  _layout_put_byte(buf, 97, 100)
  _layout_put_byte(buf, 98, 105)
  _layout_put_byte(buf, 99, 110)
  _layout_put_byte(buf, 100, 103)
  _layout_put_byte(buf, 101, 45)
  _layout_put_byte(buf, 102, 114)
  _layout_put_byte(buf, 103, 105)
  _layout_put_byte(buf, 104, 103)
  _layout_put_byte(buf, 105, 104)
  _layout_put_byte(buf, 106, 116)
  t.padding_right_off = 94
  t.padding_right_len = 13
  return 0
263}
264
265// Look up a property for the box at `box_idx` and resolve its
266// dimension value to integer px. Returns -1 if the property is not
267// in the cascade (caller substitutes default).
268//
269// Note: nx_css_lookup_property uses the caller's `src` buffer for
270// byte-equality. We pass the CASCADE source buffer (where decl
271// property names live) -- but the lookup compares against the
272// `prop_*` arguments which point into the LayoutPropTable buffer.
273// To make this byte-equal work, the table buffer's bytes must match
274// the cascade buffer's property-name bytes for the queried names.
275// The smoke fixture arranges for property names to be co-located in
276// the same buffer; production integration ensures the same.
277func _layout_lookup_px(ctx: *LayoutCtx, table_src: *u8,
                     box_idx: i64,
                     prop_off: i64, prop_len: i64) -> i64 {
  // Walk computed array in reverse for source-order winner.
  var i: i64 = ctx.n_computed - 1
  while i >= 0 {
      let cd: *CssComputedDecl = (ctx.computed as *u8 + (i as nx_size) * (NX_CSS_COMPUTED_DECL_BYTES as nx_size)) as *CssComputedDecl
      if cd.element_idx == box_idx {
          if cd.prop_len == prop_len {
              var same: i64 = 1
              var k: i64 = 0
              while k < prop_len {
                  let ca: i64 = (ctx.src[cd.prop_off + k] as i64) & 255
                  let cb: i64 = (table_src[prop_off + k] as i64) & 255
                  if ca != cb {
                      same = 0
                      k = prop_len
                  } else {
                      k = k + 1
                  }
              }
              if same == 1 {
                  if cd.val_kind == NX_CSS_VAL_DIMENSION {
                      return nx_css_dimension_to_px(ctx.src,
                          cd.val_off, cd.val_len,
                          cd.unit_off, cd.unit_len, ctx.resolve_ctx)
                  }
                  return -1
              }
          }
      }
      i = i - 1
  }
  return -1
311}
312
313// HEIGHT-specific lookup: a PERCENTAGE height against a parent whose height is not explicit is AUTO
314// (CSS 2.1 s10.5). The generic lookup resolves every % against resolve_ctx.parent_dimension_px -- which
315// br_layout seeds with the VIEWPORT WIDTH -- so wikipedia's `html,body{height:100%}` manufactured
316// ~1,050px-tall mostly-empty containers at the top of every styled page = the CSS-on first-screen VOID
317// (region x-ray, 2026-07-28: boxes 0/1/35/39 all h=1024..1052 from height:100%). We never track a
318// definite parent height, so %-height == auto, always.
319func _layout_lookup_height_px(ctx: *LayoutCtx, table_src: *u8,
                            box_idx: i64,
                            prop_off: i64, prop_len: i64) -> i64 {
  var i: i64 = ctx.n_computed - 1
  while i >= 0 {
      let cd: *CssComputedDecl = (ctx.computed as *u8 + (i as nx_size) * (NX_CSS_COMPUTED_DECL_BYTES as nx_size)) as *CssComputedDecl
      if cd.element_idx == box_idx {
          if cd.prop_len == prop_len {
              var same: i64 = 1
              var k: i64 = 0
              while k < prop_len {
                  let ca: i64 = (ctx.src[cd.prop_off + k] as i64) & 255
                  let cb: i64 = (table_src[prop_off + k] as i64) & 255
                  if ca != cb { same = 0; k = prop_len } else { k = k + 1 }
              }
              if same == 1 {
                  if cd.unit_len == 1 { if (ctx.src[cd.unit_off] & 0xff) == 37 { return -1 } }   // % -> auto
                  if cd.val_kind == NX_CSS_VAL_DIMENSION {
                      let hv: i64 = nx_css_dimension_to_px(ctx.src,
                          cd.val_off, cd.val_len,
                          cd.unit_off, cd.unit_len, ctx.resolve_ctx)
                      // SANITY (linkedin 2^62 y-leak, 2026-07-28): dimension_to_px overflowed to
                      // ~i64-max on an exotic height value; that height became align-items'
                      // cross_size and shifted "Join now" to y=2^62 (off-page forever). An absurd
                      // computed height is INVALID per CSS -> treated as auto, never propagated.
                      if hv > NX_MAGIC_100000 { return -1 }
                      if hv < 0 { return -1 }
                      return hv
                  }
                  return -1
              }
          }
      }
      i = i - 1
  }
  return -1
355}
356
357// "Unspecified" sentinel for margins -- distinct from a real negative margin (now a valid value). 2^30;
358// no real margin px reaches it. _layout_lookup_px returns -1 for not-found, which would collide with a
359// genuine -1px, so margins use this dedicated lookup instead.
360const NX_MARGIN_UNSET: i64 = 1073741824
361
362// Like _layout_lookup_px but for MARGINS: returns the resolved px (POSITIVE OR NEGATIVE), or
363// NX_MARGIN_UNSET when the property is absent / not a dimension (e.g. `auto`). Negative margins are a
364// valid value (box overlap), so -- unlike width/padding -- the caller must NOT clamp them to 0.
365func _layout_margin_px(ctx: *LayoutCtx, table_src: *u8, box_idx: i64, prop_off: i64, prop_len: i64) -> i64 {
  var i: i64 = ctx.n_computed - 1
  while i >= 0 {
      let cd: *CssComputedDecl = (ctx.computed as *u8 + (i as nx_size) * (NX_CSS_COMPUTED_DECL_BYTES as nx_size)) as *CssComputedDecl
      if cd.element_idx == box_idx {
          if cd.prop_len == prop_len {
              var same: i64 = 1
              var k: i64 = 0
              while k < prop_len {
                  let ca: i64 = (ctx.src[cd.prop_off + k] as i64) & 255
                  let cb: i64 = (table_src[prop_off + k] as i64) & 255
                  if ca != cb { same = 0; k = prop_len } else { k = k + 1 }
              }
              if same == 1 {
                  if cd.val_kind == NX_CSS_VAL_DIMENSION {
                      return nx_css_dimension_to_px(ctx.src, cd.val_off, cd.val_len, cd.unit_off, cd.unit_len, ctx.resolve_ctx)
                  }
                  return NX_MARGIN_UNSET
              }
          }
      }
      i = i - 1
  }
  return NX_MARGIN_UNSET
389}
390
391// CSS box-model side resolver with SHORTHAND support (`padding: a b c d` / `margin: a b c d`) -- the S21
392// height-axis rung: real pages set the box model almost entirely through shorthands (th,td{padding:8px
393// 12px}, h2{margin:1.6em 0 .5em}), which the longhand-only lookups above can't see, so we rendered ~40%
394// denser than Chrome. ONE reverse scan matches EITHER the side's longhand OR the shorthand -- the LAST
395// declaration in cascade order wins between them (the same origin-order law as br_comp_bg: the UA sheet's
396// p{margin-top:14px} longhand must LOSE to a LATER author p{margin:10px 0 30px} shorthand, and vice
397// versa). side: 0=top 1=right 2=bottom 3=left. Token units: px / em / rem in Q3 fractional math (".5em"
398// at 16px = 8) + bare 0; %/auto/unknown -> miss (the declaration still SHADOWS earlier ones, per cascade).
399func _layout_boxside_px(ctx: *LayoutCtx, table_src: *u8, box_idx: i64, lh_off: i64, lh_len: i64, pname: *u8, pnlen: i64, side: i64, miss: i64) -> i64 {
  var i: i64 = ctx.n_computed - 1
  while i >= 0 {
      let cd: *CssComputedDecl = (ctx.computed as *u8 + (i as nx_size) * (NX_CSS_COMPUTED_DECL_BYTES as nx_size)) as *CssComputedDecl
      if cd.element_idx == box_idx {
          // the side's LONGHAND (name bytes from the prop table)
          if cd.prop_len == lh_len {
              var samel: i64 = 1
              var kl: i64 = 0
              while kl < lh_len {
                  if ((ctx.src[cd.prop_off + kl] as i64) & 255) != ((table_src[lh_off + kl] as i64) & 255) { samel = 0; kl = lh_len } else { kl = kl + 1 }
              }
              if samel == 1 {
                  if cd.val_kind == NX_CSS_VAL_DIMENSION {
                      return nx_css_dimension_to_px(ctx.src, cd.val_off, cd.val_len, cd.unit_off, cd.unit_len, ctx.resolve_ctx)
                  }
                  return miss
              }
          }
          // the SHORTHAND
          if cd.prop_len == pnlen {
              var same: i64 = 1
              var k: i64 = 0
              while k < pnlen {
                  if ((ctx.src[cd.prop_off + k] as i64) & 255) != ((pname[k] as i64) & 255) { same = 0; k = pnlen } else { k = k + 1 }
              }
              if same == 1 {
                  // tokenize the raw value span on spaces -> up to 4 (off,len) pairs
                  let toff: *i64 = sys_mmap(64) as *i64
                  let tlen: *i64 = sys_mmap(64) as *i64
                  var ntok: i64 = 0
                  var over: i64 = 0
                  var p: i64 = cd.val_off
                  let e: i64 = cd.val_off + cd.val_len
                  var scanning: i64 = 1
                  while scanning == 1 {
                      var sk: i64 = 1
                      while sk == 1 {
                          if p >= e { sk = 0 }
                          else { if ((ctx.src[p] as i64) & 255) == 32 { p = p + 1 } else { sk = 0 } }
                      }
                      if p >= e { scanning = 0 }
                      else {
                          var q: i64 = p
                          var sc: i64 = 1
                          while sc == 1 {
                              if q >= e { sc = 0 }
                              else { if ((ctx.src[q] as i64) & 255) != 32 { q = q + 1 } else { sc = 0 } }
                          }
                          if ntok < 4 { toff[ntok] = p; tlen[ntok] = q - p; ntok = ntok + 1 }
                          else { over = 1; scanning = 0 }
                          p = q
                      }
                  }
                  if ntok < 1 { return miss }
                  if over == 1 { return miss }
                  // CSS side mapping: 1 val -> all; 2 -> [vertical, horizontal]; 3 -> [top, horiz, bottom]; 4 -> [t r b l]
                  var idx: i64 = 0
                  if ntok == 2 { if side == 1 { idx = 1 } if side == 3 { idx = 1 } }
                  if ntok == 3 { if side == 1 { idx = 1 } if side == 3 { idx = 1 } if side == 2 { idx = 2 } }
                  if ntok == 4 { idx = side }
                  let to: i64 = toff[idx]
                  let tl: i64 = tlen[idx]
                  // split token into number span + unit span ('-', digits, '.' = number)
                  var nl: i64 = 0
                  var ns: i64 = 1
                  while ns == 1 {
                      if nl >= tl { ns = 0 }
                      else {
                          let c: i64 = (ctx.src[to + nl] as i64) & 255
                          var isnum: i64 = 0
                          if c >= 48 { if c <= 57 { isnum = 1 } }
                          if c == 46 { isnum = 1 }
                          if c == 45 { if nl == 0 { isnum = 1 } }
                          if isnum == 1 { nl = nl + 1 } else { ns = 0 }
                      }
                  }
                  if nl == 0 { return miss }
                  let q3: i64 = nx_css_number_parse(ctx.src, to, nl)
                  if q3 == NX_CSS_NUMBER_PARSE_ERROR { return miss }
                  let ul: i64 = tl - nl
                  if ul == 0 {
                      if q3 == 0 { return 0 }
                      return miss
                  }
                  if ul == 2 {
                      let u0: i64 = (ctx.src[to+nl] as i64) & 255
                      let u1: i64 = (ctx.src[to+nl+1] as i64) & 255
                      if u0 == 112 { if u1 == 120 { return q3 / 1000 } }                       // px
                      if u0 == 101 { if u1 == 109 {                                            // em
                          let fs: i64 = _layout_fontsize_inherited(ctx, box_idx)
                          return (q3 * fs) / 1000
                      } }
                      return miss
                  }
                  if ul == 3 {
                      let r0: i64 = (ctx.src[to+nl] as i64) & 255
                      let r1: i64 = (ctx.src[to+nl+1] as i64) & 255
                      let r2: i64 = (ctx.src[to+nl+2] as i64) & 255
                      if r0 == 114 { if r1 == 101 { if r2 == 109 {                             // rem
                          return (q3 * ctx.resolve_ctx.root_font_size_px) / 1000
                      } } }
                  }
                  return miss
              }
          }
      }
      i = i - 1
  }
  return miss
509}
510
511// ---- inline formatting context (line-box flow) ----
512// Inline-level children (INLINE/INLINE_BLOCK boxes + TEXT runs) flow horizontally on a line and
513// wrap when the pen exceeds the available width, instead of each consuming a full-width block line.
514// This is what makes paragraph prose read like prose rather than one-fragment-per-line. v1 wraps at
515// inline-box / text-node boundaries (word-level wrap inside a single long run is a queued
516// refinement) and advances each line by a fixed NX_INLINE_LINE_H (no baseline alignment yet).
517struct InlinePen {
  pen_x: i64,
  pen_y: i64,
  line_h: i64,
  avail_w: i64,
  origin_x: i64,
  origin_y: i64,
  table: i64                 // *LayoutPropTable stashed as i64: box-model reads for atomic inline-block
525}
526const NX_INLINE_PEN_BYTES: i64 = 56
527const NX_INLINE_GLYPH_W: i64 = 9     // matches the live browser's 9x15 X font advance (was 6 = paint_text cell; 6 made 9px text overflow its boxes ~1.5x)
528const NX_INLINE_LINE_H: i64 = 17     // matches the 9x15 font height (15px) + 2px leading; was 10
529
530// Find a computed `font-size` (DIMENSION, e.g. "32px") for element_idx; return px or -1. Local
531// "font-size" literal (prop_len==9) -> no LayoutPropTable change. Numeric run parsed (unit separate).
532// ALSO matches the `font` SHORTHAND when its value LEADS with a size ("15px/1.55 system-ui") -- one
533// reverse scan across both properties = correct last-wins cascade between them. The paint side
534// (br_comp_fontsize_inh) implements the IDENTICAL rule so measure==paint holds.
535// Declared font-size for an element, in px, or -1 if none is declared.
536// `pct_out[0]` is set to 1 when the declared value was a PERCENTAGE, in which case the
537// returned number is the percentage itself (e.g. 100 for "100%") and the caller must
538// resolve it against the parent's computed size. Sole caller: _layout_fontsize_inherited.
539// FONT-SIZE VALUE RESOLVER (seq1150, 2026-07-28) -- shared by the measure resolver below AND the
540// paint mirror br_comp_fontsize_own (nx_browser_render imports this file; ONE implementation, both
541// sides, measure==paint by construction). Returns px >= 0, or -1 = UNEVALUABLE (calc()/keywords --
542// CSS drops such a decl; caller falls through to the older cascade decl / inherit). pct_out[0]=1
543// means the return value is a PERCENT of the parent's size (the % and em cases).
544//   "15px"/"15"   -> 15          "13.5px" -> 13 (TRUNCATE: the fontsize_frac gate's contract)
545//   "100%"        -> pct 100     "0.875rem" -> 14 (x16, rounded -- was digit-scanned to ZERO,
546//   "0.875em"     -> pct 87       the fs=0 root behind the vec-measure w=0 column class)
547//   "0"           -> 0 (legit icon-text hide)      "calc(...)"/"small" -> -1 (drop)
548func _lb_lc(b: i64) -> i64 { if b >= 65 { if b <= 90 { return b + 32 } } return b }
549func nx_fontsize_value_px(src: *u8, voff: i64, vlen: i64, uoff: i64, ulen: i64, pct_out: *i64) -> i64 {
  if vlen <= 0 { return 0 - 1 }
  let c0: i64 = src[voff] & 0xff
  var lead_ok: i64 = 0
  if c0 >= 48 { if c0 <= 57 { lead_ok = 1 } }
  if c0 == 46 { lead_ok = 1 }
  if lead_ok == 0 { return 0 - 1 }
  // integer + up to 3 fraction digits -> thousandths (q3)
  var ip: i64 = 0
  var j: i64 = 0
  var go: i64 = 1
  while go == 1 {
      if j >= vlen { go = 0 }
      else {
          let c: i64 = src[voff + j] & 0xff
          if c >= 48 { if c <= 57 { ip = ip * 10 + (c - 48); j = j + 1 } else { go = 0 } } else { go = 0 }
      }
  }
  var fr: i64 = 0
  if j < vlen { if (src[voff + j] & 0xff) == 46 {
      j = j + 1
      var fd: i64 = 0
      var g2: i64 = 1
      while g2 == 1 {
          if j >= vlen { g2 = 0 }
          else {
              let c2: i64 = src[voff + j] & 0xff
              if c2 >= 48 { if c2 <= 57 {
                  if fd == 0 { fr = fr + (c2 - 48) * 100 }
                  if fd == 1 { fr = fr + (c2 - 48) * 10 }
                  if fd == 2 { fr = fr + (c2 - 48) }
                  fd = fd + 1
                  j = j + 1
              } else { g2 = 0 } } else { g2 = 0 }
          }
      }
  } }
  let q3: i64 = ip * 1000 + fr
  // unit: from unit_off/unit_len (DIMENSION tokens carry it separately) with an in-value '%' fallback
  var ispct: i64 = 0
  if ulen == 1 { if (src[uoff] & 0xff) == 37 { ispct = 1 } }
  var us: i64 = 0
  while us < vlen { if (src[voff + us] & 0xff) == 37 { ispct = 1; us = vlen } else { us = us + 1 } }
  if ispct == 1 { pct_out[0] = 1; return q3 / 1000 }
  if ulen == 2 { if (src[uoff] & 0xff) == 101 { if (src[uoff+1] & 0xff) == 109 {   // em -> % of parent
      pct_out[0] = 1
      return (q3 * 100 + 500) / 1000     // ROUND: 0.875em -> 88% -> 14px of 16 (truncating gave 13)
  } } }
  if ulen == 3 { if (src[uoff] & 0xff) == 114 { if (src[uoff+1] & 0xff) == 101 { if (src[uoff+2] & 0xff) == 109 {   // rem -> x16 rounded
      return (q3 * 16 + 500) / 1000
  } } } }
  // ABSOLUTE CSS UNITS (CSS Values §5: 1in = 96px = 72pt = 6pc = 2.54cm = 25.4mm). `pt` is NOT
  // legacy trivia -- news.ycombinator.com sizes its entire page in pt (`font-size:10pt`), and
  // treating 10pt as 10px instead of 13.3px pushed every run under the OCR legibility cliff:
  // measured recall 438 -> 0 with author CSS on (region x-ray, 2026-07-28). Unit-less values and
  // px fall through to the q3 rounding below.
  if ulen == 2 {
      let u0: i64 = _lb_lc(src[uoff] & 0xff)
      let u1: i64 = _lb_lc(src[uoff+1] & 0xff)
      if u0 == 112 { if u1 == 116 { return (q3 * 4 / 3 + 500) / 1000 } }        // pt = 4/3 px
      if u0 == 112 { if u1 == 99 { return (q3 * 16 + 500) / 1000 } }            // pc = 16px
      if u0 == 105 { if u1 == 110 { return (q3 * 96 + 500) / 1000 } }           // in = 96px
      if u0 == 99  { if u1 == 109 { return (q3 * NX_MAGIC_37795 / 1000 + 500) / 1000 } } // cm = 96/2.54 px
      if u0 == 109 { if u1 == 109 { return (q3 * NX_MAGIC_37795 / NX_MAGIC_10000 + 500) / 1000 } }// mm = cm/10
  }
  return q3 / 1000   // px / unit-less: TRUNCATE ("13.5px" -> 13, the fontsize_frac gate's contract)
615}
616
617func _layout_fontsize_decl_px(ctx: *LayoutCtx, element_idx: i64, pct_out: *i64) -> i64 {
  let fname: *u8 = "font-size\x00" as *u8
  let fsh: *u8 = "font\x00" as *u8
  var i: i64 = ctx.n_computed - 1
  while i >= 0 {
      let cd: *CssComputedDecl = (ctx.computed as *u8 + (i as nx_size) * (NX_CSS_COMPUTED_DECL_BYTES as nx_size)) as *CssComputedDecl
      if cd.element_idx == element_idx {
          if cd.prop_len == 4 {
              var same4: i64 = 1
              var k4: i64 = 0
              while k4 < 4 {
                  if (ctx.src[cd.prop_off + k4] & 0xff) != (fsh[k4] & 0xff) { same4 = 0; k4 = 4 } else { k4 = k4 + 1 }
              }
              if same4 == 1 {
                  // digit-leading value only ("15px/..." -- "italic 15px/..." is the documented v1 gap)
                  let c0: i64 = (ctx.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 = (ctx.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 {
              var same: i64 = 1
              var k: i64 = 0
              while k < 9 {
                  if (ctx.src[cd.prop_off + k] & 0xff) != (fname[k] & 0xff) { same = 0; k = 9 } else { k = k + 1 }
              }
              if same == 1 {
                  // ONE resolver for the value (nx_fontsize_value_px above): px/%/em/rem/fractions,
                  // calc()/keywords DROPPED (-1) like CSS drops an unevaluable decl -> fall through
                  // to the older cascade decl / inherit. History this replaces: the digit-scan read
                  // `font-size:100%` as 100px (the 07-27 CSS-on height blowup), `calc(1rem*0.875)`
                  // as 10px, and `0.875rem` as ZERO -- the fs=0 root behind the vec-measure w=0
                  // column class (region x-ray, 2026-07-28).
                  let fv: i64 = nx_fontsize_value_px(ctx.src, cd.val_off, cd.val_len, cd.unit_off, cd.unit_len, pct_out)
                  if fv >= 0 { return fv }
              }
          }
      }
      i = i - 1
  }
  return 0 - 1
669}
670// Inherited effective font-size (px) for a box: nearest ANCESTOR with computed font-size, else 16.
671func _layout_fontsize_inherited(ctx: *LayoutCtx, box_idx: i64) -> i64 {
  let pct: *i64 = sys_mmap(16) as *i64
  var cur: i64 = box_idx
  var safety: i64 = 0
  while safety < 256 {
      safety = safety + 1
      if cur < 0 { return 16 }
      pct[0] = 0
      let px: i64 = _layout_fontsize_decl_px(ctx, cur, pct)
      if px >= 0 {
          if pct[0] == 0 { return px }
          // PERCENTAGE (CSS 2.1 §15.7): relative to the PARENT's computed size. Walking on
          // from the parent rather than recursing keeps this iterative and inside the same
          // 256-step bound. 100% therefore means "same as parent", which is the whole point
          // of the universal reset -- not a 100-pixel font.
          let bp: *LayoutBox = (ctx.tree.boxes as *u8 + (cur as nx_size) * (NX_LAYOUT_BOX_BYTES as nx_size)) as *LayoutBox
          let parent_px: i64 = _layout_fontsize_inherited(ctx, bp.parent_idx)
          var r: i64 = (parent_px * px) / 100
          if r < 1 { r = 1 }               // never collapse a font to zero
          return r
      }
      let b: *LayoutBox = (ctx.tree.boxes as *u8 + (cur as nx_size) * (NX_LAYOUT_BOX_BYTES as nx_size)) as *LayoutBox
      cur = b.parent_idx
  }
  return 16
696}
697// Integer glyph scale for a font-size in px. MUST match _paint_scale_for_px in nx_paint_walk_layout
698// so the reserved line height == the painted glyph height (headings don't overlap the next line).
699func _layout_scale_for_px(px: i64) -> i64 {
  if px < 24 { return 1 }
  if px < 36 { return 2 }
  return 3
703}
704
705// Does the box have computed `display: none`? (The page's CSS hides chrome with this.) Local literals
706// for "display"(7)/"none"(4) -> no LayoutPropTable change. A none box takes ZERO space + lays out no
707// children (paint skips it too). The keystone for applying a page's own stylesheet correctly.
708func _layout_display_none(ctx: *LayoutCtx, box_idx: i64) -> i64 {
  let dn: *u8 = "display\x00" as *u8
  let nn: *u8 = "none\x00" as *u8
  var i: i64 = ctx.n_computed - 1
  while i >= 0 {
      let cd: *CssComputedDecl = (ctx.computed as *u8 + (i as nx_size) * (NX_CSS_COMPUTED_DECL_BYTES as nx_size)) as *CssComputedDecl
      if cd.element_idx == box_idx {
          if cd.prop_len == 7 {
              var sp: i64 = 1
              var k: i64 = 0
              while k < 7 { if (ctx.src[cd.prop_off+k]&0xff) != (dn[k]&0xff) { sp = 0; k = 7 } else { k = k + 1 } }
              if sp == 1 {
                  if cd.val_len == 4 {
                      var sv: i64 = 1
                      var j: i64 = 0
                      while j < 4 { if (ctx.src[cd.val_off+j]&0xff) != (nn[j]&0xff) { sv = 0; j = 4 } else { j = j + 1 } }
                      if sv == 1 { return 1 }
                  }
              }
          }
      }
      i = i - 1
  }
  return 0
732}
733
734func _il_text_w(b: *LayoutBox, avail_w: i64) -> i64 {
  var w_px: i64 = b.text_len * NX_INLINE_GLYPH_W
  if w_px > avail_w { w_px = avail_w }
  if w_px < 0 { w_px = 0 }
  return w_px
739}
740
741// Flow one inline-level box (and its inline subtree) into the pen. TEXT boxes are placed and advance
742// the pen; INLINE boxes recurse so their inline descendants share the same line context. Returns 0.
743// CSS line-height resolver (the S21 height-axis remainder): supports `line-height: 1.55` (unitless
744// MULTIPLIER of the element's own font-size -- inherits as the number, so it recomputes against each
745// descendant's fs), `line-height: 24px` (fixed), and the `font` SHORTHAND's /N part ("15px/1.55 ...").
746// One reverse scan per element = last-wins across both properties; nearest ancestor with a decl wins
747// (CSS inheritance). Returns px, or -1 when nothing declares it (callers keep the legacy 17*scale line).
748// The paint side (br_comp_lineheight_px) implements the IDENTICAL rule -- measure==paint law.
749func _layout_lineheight_decl_px(ctx: *LayoutCtx, element_idx: i64, fs: i64) -> i64 {
  let lname: *u8 = "line-height\x00" as *u8
  let fsh: *u8 = "font\x00" as *u8
  var i: i64 = ctx.n_computed - 1
  while i >= 0 {
      let cd: *CssComputedDecl = (ctx.computed as *u8 + (i as nx_size) * (NX_CSS_COMPUTED_DECL_BYTES as nx_size)) as *CssComputedDecl
      if cd.element_idx == element_idx {
          if cd.prop_len == 11 {
              var same: i64 = 1
              var k: i64 = 0
              while k < 11 {
                  if ((ctx.src[cd.prop_off + k] as i64) & 255) != ((lname[k] as i64) & 255) { same = 0; k = 11 } else { k = k + 1 }
              }
              if same == 1 {
                  // number span then optional unit ("1.55" unitless / "24px")
                  var nl: i64 = 0
                  var ns: i64 = 1
                  while ns == 1 {
                      if nl >= cd.val_len { ns = 0 }
                      else {
                          let c: i64 = (ctx.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(ctx.src, cd.val_off, nl)
                  if q3 == NX_CSS_NUMBER_PARSE_ERROR { return 0 - 1 }
                  // px: DIMENSION tokens carry the unit in the SEPARATE unit fields (val = digits only);
                  // swept spans carry it inline. Unitless must be EXACTLY the number (else miss, not 16x).
                  if cd.unit_len == 2 {
                      if ((ctx.src[cd.unit_off] as i64) & 255) == 112 { if ((ctx.src[cd.unit_off + 1] as i64) & 255) == 120 {
                          return q3 / 1000
                      } }
                  }
                  if nl + 1 < cd.val_len {
                      if ((ctx.src[cd.val_off + nl] as i64) & 255) == 112 { if ((ctx.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 {
              var same4: i64 = 1
              var k4: i64 = 0
              while k4 < 4 {
                  if ((ctx.src[cd.prop_off + k4] as i64) & 255) != ((fsh[k4] as i64) & 255) { same4 = 0; k4 = 4 } else { k4 = k4 + 1 }
              }
              if same4 == 1 {
                  let c0: i64 = (ctx.src[cd.val_off] as i64) & 255
                  if c0 >= 48 { if c0 <= 57 {
                      // skip the leading size token to the '/' (e.g. "15px/1.55 system-ui")
                      var j: i64 = 0
                      var sl: i64 = 0 - 1
                      var g: i64 = 1
                      while g == 1 {
                          if j >= cd.val_len { g = 0 }
                          else {
                              let cj: i64 = (ctx.src[cd.val_off + j] as i64) & 255
                              if cj == 47 { sl = j; g = 0 }
                              else { if cj == 32 { g = 0 } else { j = j + 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 = (ctx.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(ctx.src, vo, n2)
                              if q32 != NX_CSS_NUMBER_PARSE_ERROR {
                                  if n2 + 1 < vmax {
                                      if ((ctx.src[vo + n2] as i64) & 255) == 112 { if ((ctx.src[vo + n2 + 1] as i64) & 255) == 120 {
                                          return q32 / 1000
                                      } }
                                  }
                                  return (q32 * fs) / 1000
                              }
                          }
                      }
                  } }
              }
          }
      }
      i = i - 1
  }
  return 0 - 1
850}
851func _layout_lineheight_px(ctx: *LayoutCtx, 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 = _layout_lineheight_decl_px(ctx, cur, fs)
      if v >= 0 { return v }
      let b: *LayoutBox = (ctx.tree.boxes as *u8 + (cur as nx_size) * (NX_LAYOUT_BOX_BYTES as nx_size)) as *LayoutBox
      cur = b.parent_idx
  }
  return 0 - 1
863}
864
865// VEC-MEASURE mode (opt-in, default OFF so every existing gate is byte-unchanged): when the renderer will
866// paint runs with the proportional VECTOR font (the GUI: vec_headings=2), layout must reserve widths from
867// the SAME metric (font_adv_em) or every styled inline span/link lands at bitmap-width positions while
868// glyphs paint narrower -> the measured gap bug (S21 F3; dominant Wikipedia paint delta). Same module-
869// toggle pattern as the paint side's br_set_fast_vec.
870static l_vec_measure: i64
871func nx_layout_set_vec_measure(v: i64) -> i64 { l_vec_measure = v; return 0 }
872// Y-TRAP (debug instrument, seq linkedin-2^62): when armed, any box whose computed y exceeds 10^9
873// prints its idx + the exact operands so the corrupt ADDEND is named in one run. Never on by default.
874static l_ytrap: i64
875func nx_layout_set_ytrap(v: i64) -> i64 { l_ytrap = v; return 0 }
876func _yt_w(s: *u8) -> i64 { var n: i64=0; while s[n]!=(0 as u8){n=n+1} sys_write(2,s,n); return 0 }
877func _yt_n(v: i64) -> i64 { let b: *u8=sys_mmap(28); var m: i64=v; if m<0{_yt_w("-" as *u8);m=0-m} let t: *u8=sys_mmap(28); var k: i64=0; if m==0{t[0]=48 as u8;k=1} while m>0{t[k]=(48+(m%10)) as u8;m=m/10;k=k+1} var i: i64=0; while i<k{b[i]=t[k-1-i];i=i+1} sys_write(2,b,k); return 0 }
878
879// ---- TABLE COLUMN LAYOUT (CSS 2.1 §17.5.2 "auto", minimal) -- seq1158, 2026-07-28 --------------
880// Rows are flex containers (UA sheet `tr{display:flex}`) and the flex path gave every auto child an
881// EQUAL share, so a 3-column table rendered as equal thirds regardless of content. On a table-built
882// site (news.ycombinator.com: rank | vote | title) that scatters the cells -- measured 57permille with
883// author CSS on while the page HEIGHT proved the content was all there. Real table layout sizes a
884// column by its MAX-CONTENT across ALL rows and shares that width down the column.
885// The widths live in statics because the row (flex) path is reached through the generic block
886// recursion; they are SAVED/RESTORED around each table so nested tables (HN nests them) are correct.
887static l_tbl_active: i64      // 1 while laying out inside a table whose columns are resolved
888static l_tbl_idx: i64         // box index of that table (a row only uses columns of ITS OWN table)
889static l_tbl_ncols: i64
890static l_tbl_colw_p: i64      // *i64 column widths (as i64; cast at use)
891const NX_TBL_MAXCOLS: i64 = 64
892
893// vector width of text[start..end) at font-size fs (1x layout units) -- the EXACT sum the vector paint
894// advances by (font_vec_adv_px2 = font_adv_em*empx/1000 with empx = fs*paint_scale; layout is 1x).
895func _layout_vec_text_w(t: *u8, start: i64, end: i64, fs: i64) -> i64 {
  var w: i64 = 0
  var i: i64 = start
  while i < end { w = w + (font_adv_em((t[i] as i64) & 255) * fs) / 1000; i = i + 1 }
  return w
900}
901
902// Byte-equal a property name at src[off..off+n) against `name`. 1 if equal, 0 otherwise.
903func _il_prop_is(src: *u8, off: i64, name: *u8, n: i64) -> i64 {
  var k: i64 = 0
  while k < n { if (src[off+k]&0xff) != (name[k]&0xff) { return 0 } k = k + 1 }
  return 1
907}
908
909// Border width (px) for a box: leading integer of the `border` shorthand ("1px solid #26304a" -> 1) or
910// `border-width`. Reverse cascade scan of ctx.computed (winner first). 0 if none. Used to size + inset an
911// atomic inline-block so its border-box matches what the painter strokes (br_comp_border).
912func _layout_border_w(ctx: *LayoutCtx, box_idx: i64) -> i64 {
  var i: i64 = ctx.n_computed - 1
  while i >= 0 {
      let cd: *CssComputedDecl = (ctx.computed as *u8 + (i as nx_size) * (NX_CSS_COMPUTED_DECL_BYTES as nx_size)) as *CssComputedDecl
      if cd.element_idx == box_idx {
          var hit: i64 = 0
          if cd.prop_len == 6 { if _il_prop_is(ctx.src, cd.prop_off, "border\x00" as *u8, 6) == 1 { hit = 1 } }
          if cd.prop_len == 12 { if _il_prop_is(ctx.src, cd.prop_off, "border-width\x00" as *u8, 12) == 1 { hit = 1 } }
          if hit == 1 {
              let v: i64 = _grid_int_val(ctx.src, cd.val_off, cd.val_len)
              if v < 0 { return 0 }
              return v
          }
      }
      i = i - 1
  }
  return 0
929}
930
931// Max-content width (px) of an inline subtree: the width its TEXT occupies on ONE unwrapped line, using
932// the SAME font metrics as the TEXT layout branch (measure==paint). Sums children (an inline run). Used to
933// shrink-to-fit an atomic inline-block that has no explicit `width` (chips/tags/badges).
934func _layout_intrinsic_w(ctx: *LayoutCtx, box_idx: i64) -> i64 {
  if box_idx < 0 { return 0 }
  if box_idx >= ctx.tree.count { return 0 }
  let b: *LayoutBox = (ctx.tree.boxes as *u8 + (box_idx as nx_size) * (NX_LAYOUT_BOX_BYTES as nx_size)) as *LayoutBox
  if b.kind == NX_LAYOUT_BOX_TEXT {
      let fs: i64 = _layout_fontsize_inherited(ctx, b.parent_idx)
      let sc: i64 = _layout_scale_for_px(fs)
      let tptr: *u8 = ((ctx.src as i64) + b.text_off) as *u8
      if ctx.text_measured == 1 {
          if ctx.font_tab == 0 { ctx.font_tab = (font8x8_table()) as i64 }
          return font8x8_text_w(ctx.font_tab as *u8, tptr, 0, b.text_len) * sc
      }
      if l_vec_measure == 1 { if font_run_has_ext(tptr, b.text_len) == 1 { return _layout_vec_text_w(tptr, 0, b.text_len, fs) } }
      return b.text_len * NX_INLINE_GLYPH_W * sc
  }
  var w: i64 = 0
  var ci: i64 = b.first_child_idx
  var sf: i64 = 0
  var keep: i64 = 1
  while keep == 1 {
      if sf >= NX_MAGIC_65536 { keep = 0 }
      else {
          sf = sf + 1
          if ci < 0 { keep = 0 }
          else {
              w = w + _layout_intrinsic_w(ctx, ci)
              let c: *LayoutBox = (ctx.tree.boxes as *u8 + (ci as nx_size) * (NX_LAYOUT_BOX_BYTES as nx_size)) as *LayoutBox
              ci = c.next_sibling_idx
          }
      }
  }
  return w
966}
967
968func _layout_inline_flow(ctx: *LayoutCtx, pen: *InlinePen, box_idx: i64) -> i64 {
  if box_idx < 0 { return 0 }
  if box_idx >= ctx.tree.count { return 0 }
  let b: *LayoutBox = (ctx.tree.boxes as *u8 + (box_idx as nx_size) * (NX_LAYOUT_BOX_BYTES as nx_size)) as *LayoutBox
972
  // display:none on an INLINE-LEVEL element (span/a in flow): contributes nothing, flows no children,
  // pen unmoved -- the same rule _layout_block_recurse applies to block boxes (seq1130 companion).
  // TEXT boxes carry no computed decls, so the O(ncomp) scan is skipped for them.
  if b.kind != NX_LAYOUT_BOX_TEXT {
      if _layout_display_none(ctx, box_idx) == 1 { return 0 }
  }
979
  if b.kind == NX_LAYOUT_BOX_TEXT {
      // Scale glyph advance + line height by the run's inherited font-size so big headings reserve
      // proportional space (paint scales the glyph identically -> no overlap with the next line).
      let fs_run: i64 = _layout_fontsize_inherited(ctx, b.parent_idx)
      let sc: i64 = _layout_scale_for_px(fs_run)
      let gw: i64 = NX_INLINE_GLYPH_W * sc
      var lh: i64 = NX_INLINE_LINE_H * sc
      // CSS line-height (S21 height axis): a declared line-height/font-shorthand-/N sets the EXACT
      // line-box height (Chrome parity), floored at 8px against pathology. Absent -> legacy 17*scale.
      let lhq: i64 = _layout_lineheight_px(ctx, b.parent_idx, fs_run)
      if lhq >= 8 { lh = lhq }
      let tptr: *u8 = ((ctx.src as i64) + b.text_off) as *u8
      // MEASURED mode: width = the SUM of per-glyph proportional advances (font8x8 metrics SSOT) so the
      // reserved box exactly equals what the paint draws. Legacy mode keeps the 9px-cell arithmetic.
      var meas: i64 = 0
      var ftab: *u8 = 0 as *u8
      if ctx.text_measured == 1 {
          meas = 1
          if ctx.font_tab == 0 { ctx.font_tab = (font8x8_table()) as i64 }
          ftab = ctx.font_tab as *u8
      }
      var full_w: i64 = b.text_len * gw
      if meas == 1 { full_w = font8x8_text_w(ftab, tptr, 0, b.text_len) * sc }
      // vec-measure: reserve the width the VECTOR paint will actually advance (same coverage test the
      // GUI paint uses: font_run_has_ext). Uncovered runs keep bitmap widths -- exactly mirroring the
      // paint-side fallback, so measure==paint in BOTH modes.
      var vec_run: i64 = 0
      if l_vec_measure == 1 { if font_run_has_ext(tptr, b.text_len) == 1 { vec_run = 1 } }
      if vec_run == 1 { full_w = _layout_vec_text_w(tptr, 0, b.text_len, fs_run) }
      if full_w <= pen.avail_w {
          // SINGLE-LINE run: wrap to a new line first if it won't fit in the remaining space (and we're
          // not already at line start), then place it and advance the pen horizontally.
          var cw: i64 = full_w
          if cw < 0 { cw = 0 }
          if pen.pen_x > 0 { if pen.pen_x + cw > pen.avail_w {
              pen.pen_y = pen.pen_y + pen.line_h
              pen.pen_x = 0
              pen.line_h = 0
          } }
          b.x = pen.origin_x + pen.pen_x
          b.y = pen.origin_y + pen.pen_y
  if l_ytrap == 1 { if b.y > NX_MAGIC_1000000000 {
      _yt_w("YTRAP@1007 idx=" as *u8); _yt_n(box_idx)
      _yt_w(" oy=" as *u8); _yt_n(pen.origin_y)
      _yt_w("
1025" as *u8)
  } }
          b.w = cw
          b.h = lh
          pen.pen_x = pen.pen_x + cw
          if pen.line_h < lh { pen.line_h = lh }
      } else {
          // MULTI-LINE run: word-wraps. Reserve the FULL height and advance the pen DOWN to the last
          // line. Measured mode breaks by SUMMED ADVANCES (font8x8_next_break); legacy by char count
          // (tw_next_break) -- each mode's paint mirrors its break fn exactly.
          if pen.pen_x > 0 {
              pen.pen_y = pen.pen_y + pen.line_h
              pen.pen_x = 0
              pen.line_h = 0
          }
          var cpl: i64 = pen.avail_w / gw
          if cpl < 1 { cpl = 1 }
          var avail_units: i64 = pen.avail_w / sc
          if avail_units < 4 { avail_units = 4 }
          var s: i64 = 0
          var nlines: i64 = 0
          var last_start: i64 = 0
          var last_end: i64 = 0
          while s < b.text_len {
              last_start = s
              var e: i64 = 0
              if meas == 1 { e = font8x8_next_break(ftab, tptr, b.text_len, avail_units, s) }
              else { e = tw_next_break(tptr, b.text_len, cpl, s) }
              last_end = e
              nlines = nlines + 1
              s = e
          }
          if nlines < 1 { nlines = 1 }
          b.x = pen.origin_x
          b.y = pen.origin_y + pen.pen_y
  if l_ytrap == 1 { if b.y > NX_MAGIC_1000000000 {
      _yt_w("YTRAP@1040 idx=" as *u8); _yt_n(box_idx)
      _yt_w(" oy=" as *u8); _yt_n(pen.origin_y)
      _yt_w("
1064" as *u8)
  } }
          b.w = pen.avail_w
          b.h = nlines * lh
          pen.pen_y = pen.pen_y + (nlines - 1) * lh
          if meas == 1 { pen.pen_x = font8x8_text_w(ftab, tptr, last_start, last_end) * sc }
          else { pen.pen_x = (last_end - last_start) * gw }
          pen.line_h = lh
      }
      return 0
  }
1075
  // INLINE-BLOCK: an ATOMIC inline-level box that sizes like a block internally (padding/border/width),
  // sits on the line, and WRAPS as a unit. Children lay out in a PRIVATE sub-pen at the inner (content)
  // origin so bg/border paint around them. Covers chips/tags/badges/buttons/pills + <img>/<input>/<button>.
  if b.kind == NX_LAYOUT_BOX_INLINE_BLOCK {
      let tbl: *LayoutPropTable = (pen.table) as *LayoutPropTable
      var plp: i64 = _layout_boxside_px(ctx, tbl.src, box_idx, tbl.padding_left_off, tbl.padding_left_len, "padding\x00" as *u8, 7, 3, 0)
      var prp: i64 = _layout_boxside_px(ctx, tbl.src, box_idx, tbl.padding_right_off, tbl.padding_right_len, "padding\x00" as *u8, 7, 1, 0)
      var ptp: i64 = _layout_boxside_px(ctx, tbl.src, box_idx, tbl.padding_top_off, tbl.padding_top_len, "padding\x00" as *u8, 7, 0, 0)
      var pbp: i64 = _layout_boxside_px(ctx, tbl.src, box_idx, tbl.padding_bottom_off, tbl.padding_bottom_len, "padding\x00" as *u8, 7, 2, 0)
      var mll: i64 = _layout_boxside_px(ctx, tbl.src, box_idx, tbl.margin_left_off, tbl.margin_left_len, "margin\x00" as *u8, 6, 3, 0)
      var mrr: i64 = _layout_boxside_px(ctx, tbl.src, box_idx, tbl.margin_right_off, tbl.margin_right_len, "margin\x00" as *u8, 6, 1, 0)
      if plp < 0 { plp = 0 }
      if prp < 0 { prp = 0 }
      if ptp < 0 { ptp = 0 }
      if pbp < 0 { pbp = 0 }
      if mll < 0 { mll = 0 }
      if mrr < 0 { mrr = 0 }
      let bdw: i64 = _layout_border_w(ctx, box_idx)
      let wexp: i64 = _layout_lookup_px(ctx, tbl.src, box_idx, tbl.width_off, tbl.width_len)
      let hexp: i64 = _layout_lookup_height_px(ctx, tbl.src, box_idx, tbl.height_off, tbl.height_len)
      var inw: i64 = wexp
      if inw < 0 { inw = _layout_intrinsic_w(ctx, box_idx) }
      if inw < 0 { inw = 0 }
      let fs_ib: i64 = _layout_fontsize_inherited(ctx, box_idx)
      let sc_ib: i64 = _layout_scale_for_px(fs_ib)
      var inh: i64 = hexp
      if inh < 0 { inh = NX_INLINE_LINE_H * sc_ib }
      let full_w: i64 = inw + plp + prp + bdw + bdw
      let full_h: i64 = inh + ptp + pbp + bdw + bdw
      // wrap the WHOLE box to the next line if it will not fit and we are not already at line start
      if pen.pen_x > 0 { if pen.pen_x + mll + full_w > pen.avail_w {
          pen.pen_y = pen.pen_y + pen.line_h
          pen.pen_x = 0
          pen.line_h = 0
      } }
      let bx: i64 = pen.origin_x + pen.pen_x + mll
      let by: i64 = pen.origin_y + pen.pen_y
      b.x = bx
      b.y = by
      if l_ytrap == 1 { if b.y > NX_MAGIC_1000000000 {
          _yt_w("YTRAP@iblk idx=" as *u8); _yt_n(box_idx)
          _yt_w(" by=" as *u8); _yt_n(by)
          _yt_w("
1119" as *u8)
      } }
      b.w = full_w
      b.h = full_h
      // lay out children in a PRIVATE sub-pen at the inner content origin (so the bg/border box wraps them)
      let ibp: *InlinePen = (sys_mmap(NX_INLINE_PEN_BYTES as nx_size)) as *InlinePen
      ibp.pen_x = 0
      ibp.pen_y = 0
      ibp.line_h = 0
      ibp.avail_w = inw
      ibp.origin_x = bx + plp + bdw
      ibp.origin_y = by + ptp + bdw
      ibp.table = pen.table
      var cib: i64 = b.first_child_idx
      var sfib: i64 = 0
      var kib: i64 = 1
      while kib == 1 {
          if sfib >= NX_MAGIC_65536 { kib = 0 }
          else {
              sfib = sfib + 1
              if cib < 0 { kib = 0 }
              else {
                  _layout_inline_flow(ctx, ibp, cib)
                  let cb: *LayoutBox = (ctx.tree.boxes as *u8 + (cib as nx_size) * (NX_LAYOUT_BOX_BYTES as nx_size)) as *LayoutBox
                  cib = cb.next_sibling_idx
              }
          }
      }
      // advance the parent pen past the atomic box + its horizontal margins; grow the line height
      pen.pen_x = pen.pen_x + mll + full_w + mrr
      if pen.line_h < full_h { pen.line_h = full_h }
      return 0
  }
1152
  // INLINE / other: transparent wrapper -- record start, flow children on the SHARED line, span to pen end.
  b.x = pen.origin_x + pen.pen_x
  b.y = pen.origin_y + pen.pen_y
  if l_ytrap == 1 { if b.y > NX_MAGIC_1000000000 {
      _yt_w("YTRAP inline idx=" as *u8); _yt_n(box_idx)
      _yt_w(" origin_y=" as *u8); _yt_n(pen.origin_y)
      _yt_w(" pen_y=" as *u8); _yt_n(pen.pen_y)
      _yt_w(" line_h=" as *u8); _yt_n(pen.line_h)
      _yt_w("\n" as *u8)
  } }
  var child_idx: i64 = b.first_child_idx
  var safety: i64 = 0
  var keep: i64 = 1
  while keep == 1 {
      if safety >= NX_MAGIC_65536 { keep = 0 }
      else {
          safety = safety + 1
          if child_idx < 0 { keep = 0 }
          else {
              _layout_inline_flow(ctx, pen, child_idx)
              let c: *LayoutBox = (ctx.tree.boxes as *u8 + (child_idx as nx_size) * (NX_LAYOUT_BOX_BYTES as nx_size)) as *LayoutBox
              child_idx = c.next_sibling_idx
          }
      }
  }
  var span_w: i64 = (pen.origin_x + pen.pen_x) - b.x
  if span_w < 0 { span_w = 0 }
  b.w = span_w
  b.h = pen.line_h
  return 0
1183}
1184
1185// Recursive layout pass over a single block subtree rooted at
1186// box_idx. `avail_w` is the content width passed down by the
1187// parent. (`origin_x`, `origin_y`) is the top-left of the content
1188// area at this box's level. Returns the OUTER height of this box
1189// (margin-top + border-top + padding-top + content_h +
1190// padding-bottom + border-bottom + margin-bottom) so the parent's
1191// sibling-stacking loop can advance.
1192//
1193// Phase 3 subset: no borders, no horizontal margin/padding, so the
1194// outer height = margin-top + padding-top + content_h +
1195// padding-bottom + margin-bottom.
1196//
1197// Does the box have computed `display: flex`? (Vector-2022 and modern pages arrange sidebar+content
1198// this way.) Same lookup shape as _layout_display_none but value "flex".
1199func _layout_display_flex(ctx: *LayoutCtx, box_idx: i64) -> i64 {
  let dn: *u8 = "display\x00" as *u8
  let fx: *u8 = "flex\x00" as *u8
  var i: i64 = ctx.n_computed - 1
  while i >= 0 {
      let cd: *CssComputedDecl = (ctx.computed as *u8 + (i as nx_size) * (NX_CSS_COMPUTED_DECL_BYTES as nx_size)) as *CssComputedDecl
      if cd.element_idx == box_idx {
          if cd.prop_len == 7 {
              var sp: i64 = 1
              var k: i64 = 0
              while k < 7 { if (ctx.src[cd.prop_off+k]&0xff) != (dn[k]&0xff) { sp = 0; k = 7 } else { k = k + 1 } }
              if sp == 1 {
                  if cd.val_len == 4 {
                      var sv: i64 = 1
                      var j: i64 = 0
                      while j < 4 { if (ctx.src[cd.val_off+j]&0xff) != (fx[j]&0xff) { sv = 0; j = 4 } else { j = j + 1 } }
                      if sv == 1 { return 1 }
                  }
              }
          }
      }
      i = i - 1
  }
  return 0
1223}
1224
1225// Does the box have computed `display: grid`? (Same lookup shape as _layout_display_flex, value "grid".)
1226// Is this box's computed margin AUTO on the given side (3=left, 1=right)? Longhand margin-left/right
1227// value "auto", or the `margin` shorthand's side token per the CSS 1/2/3/4-value mapping. Cascade
1228// winner = first hit in reverse. Powers §10.3.3 auto-margin centering (wiki `margin:0 auto`).
1229func _lb_margin_auto(ctx: *LayoutCtx, box_idx: i64, side: i64) -> i64 {
  let ml_lit: *u8 = "margin-left\x00" as *u8
  let mr_lit: *u8 = "margin-right\x00" as *u8
  let m_lit: *u8 = "margin\x00" as *u8
  var i: i64 = ctx.n_computed - 1
  while i >= 0 {
      let cd: *CssComputedDecl = (ctx.computed as *u8 + (i as nx_size) * (NX_CSS_COMPUTED_DECL_BYTES as nx_size)) as *CssComputedDecl
      if cd.element_idx == box_idx {
          var want: i64 = 0
          var lit: *u8 = m_lit
          var ll: i64 = 6
          if side == 3 { if cd.prop_len == 11 { lit = ml_lit; ll = 11; want = 1 } }
          if side == 1 { if cd.prop_len == 12 { lit = mr_lit; ll = 12; want = 1 } }
          if cd.prop_len == 6 { want = 2 }
          if want > 0 {
              var sp: i64 = 1
              var k: i64 = 0
              while k < ll { if (ctx.src[cd.prop_off+k]&0xff) != (lit[k]&0xff) { sp = 0; k = ll } else { k = k + 1 } }
              if sp == 1 {
                  if want == 1 {
                      // longhand: value == "auto"?
                      if cd.val_len == 4 { if (ctx.src[cd.val_off]&0xff)==97 { if (ctx.src[cd.val_off+1]&0xff)==117 { return 1 } } }
                      return 0
                  }
                  // shorthand: split into tokens, map side (1:all 2:[v h] 3:[t h b] 4:[t r b l])
                  let to: *i64 = sys_mmap(8*4) as *i64
                  let tl: *i64 = sys_mmap(8*4) as *i64
                  var nt: i64 = 0
                  var p: i64 = cd.val_off
                  let e: i64 = cd.val_off + cd.val_len
                  while p < e {
                      while p < e { if (ctx.src[p]&0xff) == 32 { p = p + 1 } else { p = e + 1000 } }
                      if p > e { p = p - 1000 }
                      if p < e {
                          let s0: i64 = p
                          while p < e { if (ctx.src[p]&0xff) != 32 { p = p + 1 } else { p = e + 1000 } }
                          if p > e { p = p - 1000 }
                          if nt < 4 { to[nt] = s0; tl[nt] = p - s0; nt = nt + 1 }
                      }
                  }
                  if nt == 0 { return 0 }
                  var ti2: i64 = 0
                  if nt == 1 { ti2 = 0 }
                  if nt == 2 { ti2 = 1 }
                  if nt == 3 { ti2 = 1 }
                  if nt == 4 { if side == 1 { ti2 = 1 } else { ti2 = 3 } }
                  if tl[ti2] == 4 { if (ctx.src[to[ti2]]&0xff)==97 { if (ctx.src[to[ti2]+1]&0xff)==117 { return 1 } } }
                  return 0
              }
          }
      }
      i = i - 1
  }
  return 0
1283}
1284// Does this box use NAMED GRID AREAS (`grid-template-areas`)? We place grid children by AUTO-FLOW
1285// order only, so a page that assigns items to named areas gets them in the WRONG tracks — wikipedia
1286// ≥1120px put its main content into the 12.25rem SIDEBAR column and the page exploded to 88,202px
1287// (measured 2026-07-29; the track math itself was correct). Until named placement exists, a grid we
1288// cannot place correctly DEGRADES TO NORMAL BLOCK FLOW — full-width stacking is always readable,
1289// mis-placement never is. Same principle as flex-direction:column → block.
1290func _layout_has_grid_areas(ctx: *LayoutCtx, box_idx: i64) -> i64 {
  let ga: *u8 = "grid-template-areas\x00" as *u8
  var i: i64 = ctx.n_computed - 1
  while i >= 0 {
      let cd: *CssComputedDecl = (ctx.computed as *u8 + (i as nx_size) * (NX_CSS_COMPUTED_DECL_BYTES as nx_size)) as *CssComputedDecl
      if cd.element_idx == box_idx {
          if cd.prop_len == 19 {
              var sp: i64 = 1
              var k: i64 = 0
              while k < 19 { if (ctx.src[cd.prop_off+k]&0xff) != (ga[k]&0xff) { sp = 0; k = 19 } else { k = k + 1 } }
              if sp == 1 { return 1 }
          }
      }
      i = i - 1
  }
  return 0
1306}
1307// flex-direction: column(-reverse)? Our flex branch is ROW-only; a COLUMN container must NOT take it.
1308// A column flex stacks children vertically at full width = exactly the normal block flow this engine
1309// already does, so the correct minimal treatment is "not row-flex" (align-items offsets = later rung).
1310// Found via linkedin (2026-07-28): its hero is flex-direction:column; the row path laid the children
1311// SIDEWAYS and starved the H1 to w=0 x h=1482 (the "Welcome to your professional community" column).
1312func _layout_flex_dir_col(ctx: *LayoutCtx, box_idx: i64) -> i64 {
  let fn2: *u8 = "flex-direction\x00" as *u8
  var i: i64 = ctx.n_computed - 1
  while i >= 0 {
      let cd: *CssComputedDecl = (ctx.computed as *u8 + (i as nx_size) * (NX_CSS_COMPUTED_DECL_BYTES as nx_size)) as *CssComputedDecl
      if cd.element_idx == box_idx {
          if cd.prop_len == 14 {
              var sp: i64 = 1
              var k: i64 = 0
              while k < 14 { if (ctx.src[cd.prop_off+k]&0xff) != (fn2[k]&0xff) { sp = 0; k = 14 } else { k = k + 1 } }
              if sp == 1 {
                  if cd.val_len >= 6 { if (ctx.src[cd.val_off]&0xff) == 99 { return 1 } }   // c(olumn)
                  return 0
              }
          }
      }
      i = i - 1
  }
  return 0
1331}
1332func _layout_display_grid(ctx: *LayoutCtx, box_idx: i64) -> i64 {
  let dn: *u8 = "display\x00" as *u8
  let gx: *u8 = "grid\x00" as *u8
  var i: i64 = ctx.n_computed - 1
  while i >= 0 {
      let cd: *CssComputedDecl = (ctx.computed as *u8 + (i as nx_size) * (NX_CSS_COMPUTED_DECL_BYTES as nx_size)) as *CssComputedDecl
      if cd.element_idx == box_idx {
          if cd.prop_len == 7 {
              var sp: i64 = 1
              var k: i64 = 0
              while k < 7 { if (ctx.src[cd.prop_off+k]&0xff) != (dn[k]&0xff) { sp = 0; k = 7 } else { k = k + 1 } }
              if sp == 1 {
                  if cd.val_len == 4 {
                      var sv: i64 = 1
                      var j: i64 = 0
                      while j < 4 { if (ctx.src[cd.val_off+j]&0xff) != (gx[j]&0xff) { sv = 0; j = 4 } else { j = j + 1 } }
                      if sv == 1 { return 1 }
                  }
              }
          }
      }
      i = i - 1
  }
  return 0
1356}
1357// `display:table` (the UA sheet marks every <table> with it) -- same lookup shape as flex/grid.
1358// This is how the layout knows a box is a table without carrying tag names in the box tree.
1359func _layout_display_table(ctx: *LayoutCtx, box_idx: i64) -> i64 {
  let dn: *u8 = "display\x00" as *u8
  let tx: *u8 = "table\x00" as *u8
  var i: i64 = ctx.n_computed - 1
  while i >= 0 {
      let cd: *CssComputedDecl = (ctx.computed as *u8 + (i as nx_size) * (NX_CSS_COMPUTED_DECL_BYTES as nx_size)) as *CssComputedDecl
      if cd.element_idx == box_idx {
          if cd.prop_len == 7 {
              var sp: i64 = 1
              var k: i64 = 0
              while k < 7 { if (ctx.src[cd.prop_off+k]&0xff) != (dn[k]&0xff) { sp = 0; k = 7 } else { k = k + 1 } }
              if sp == 1 {
                  if cd.val_len == 5 {
                      var sv: i64 = 1
                      var j: i64 = 0
                      while j < 5 { if (ctx.src[cd.val_off+j]&0xff) != (tx[j]&0xff) { sv = 0; j = 5 } else { j = j + 1 } }
                      if sv == 1 { return 1 }
                  }
              }
          }
      }
      i = i - 1
  }
  return 0
1383}
1384func _lb_box(ctx: *LayoutCtx, i: i64) -> *LayoutBox {
  return (ctx.tree.boxes as *u8 + (i as nx_size) * (NX_LAYOUT_BOX_BYTES as nx_size)) as *LayoutBox
1386}
1387func _layout_nearest_table(ctx: *LayoutCtx, idx: i64) -> i64 {
  var cur: i64 = idx
  var guard: i64 = 0
  while guard < 64 {
      guard = guard + 1
      if cur < 0 { return 0 - 1 }
      if _layout_display_table(ctx, cur) == 1 { return cur }
      let b: *LayoutBox = _lb_box(ctx, cur)
      cur = b.parent_idx
  }
  return 0 - 1
1398}
1399// Resolve column widths for the table at tbl_idx into colw[0..ncols); returns ncols.
1400// A ROW is any descendant with display:flex whose nearest table ancestor is tbl_idx (skips the rows
1401// of nested tables by construction). Column width = max over rows of the cell's max-content width
1402// (_layout_intrinsic_w -- the same metric the inline path measures with) + the UA cell padding.
1403// Then: over-wide -> scale to fit; under-wide -> distribute the slack proportionally (real tables are
1404// width:100%, and this preserves the content ratios that make a table readable).
1405func _layout_table_cols(ctx: *LayoutCtx, tbl_idx: i64, avail_w: i64, colw: *i64) -> i64 {
  var k: i64 = 0
  while k < NX_TBL_MAXCOLS { colw[k] = 0; k = k + 1 }
  var ncols: i64 = 0
  // document order => a subtree is a contiguous index range; stop at the first non-descendant.
  var i: i64 = tbl_idx + 1
  var go: i64 = 1
  while go == 1 {
      if i >= ctx.tree.count { go = 0 }
      else {
          // descendant test (bounded parent walk)
          var cur: i64 = i
          var isdesc: i64 = 0
          var g2: i64 = 0
          while g2 < 64 {
              g2 = g2 + 1
              if cur < 0 { g2 = 64 }
              else {
                  if cur == tbl_idx { isdesc = 1; g2 = 64 }
                  else { let pb: *LayoutBox = _lb_box(ctx, cur); cur = pb.parent_idx }
              }
          }
          if isdesc == 0 { go = 0 }
          else {
              if _layout_display_flex(ctx, i) == 1 {
                  if _layout_nearest_table(ctx, i) == tbl_idx {
                      let rb: *LayoutBox = _lb_box(ctx, i)
                      var c: i64 = rb.first_child_idx
                      var col: i64 = 0
                      var g3: i64 = 0
                      while c >= 0 {
                          if g3 >= NX_MAGIC_4096 { c = 0 - 1 }
                          else {
                              g3 = g3 + 1
                              let cb: *LayoutBox = _lb_box(ctx, c)
                              // colspan (seq1159): from_dom stashes N>=2 in source_node_idx; a spanning
                              // cell occupies N slots and its max-content contributes ACROSS the span
                              // (iw/N per column), never to one column (CSS 2.1 s17.5.2).
                              var cs: i64 = 1
                              if cb.source_node_idx >= 2 { cs = cb.source_node_idx }
                              if col < NX_TBL_MAXCOLS {
                                  var iw: i64 = _layout_intrinsic_w(ctx, c) + 8   // + UA td padding
                                  if iw > avail_w { iw = avail_w }
                                  var share: i64 = iw / cs
                                  var sk: i64 = 0
                                  while sk < cs {
                                      let sc2: i64 = col + sk
                                      if sc2 < NX_TBL_MAXCOLS {
                                          if share > colw[sc2] { colw[sc2] = share }
                                          if sc2 + 1 > ncols { ncols = sc2 + 1 }
                                      }
                                      sk = sk + 1
                                  }
                              }
                              col = col + cs
                              c = cb.next_sibling_idx
                          }
                      }
                  }
              }
              i = i + 1
          }
      }
  }
  if ncols <= 0 { return 0 }
  var sum: i64 = 0
  var j: i64 = 0
  while j < ncols { sum = sum + colw[j]; j = j + 1 }
  if sum <= 0 { return 0 }
  if sum > avail_w {
      j = 0
      while j < ncols { colw[j] = (colw[j] * avail_w) / sum; j = j + 1 }
  } else {
      let slack: i64 = avail_w - sum
      j = 0
      while j < ncols { colw[j] = colw[j] + (colw[j] * slack) / sum; j = j + 1 }
  }
  return ncols
1483}
1484// Parse the leading integer of src[voff..voff+vlen) (e.g. "16" of "16px"); -1 if none. For px values.
1485func _grid_int_val(src: *u8, voff: i64, vlen: i64) -> i64 {
  let end: i64 = voff + vlen
  var v: i64 = 0
  var any: i64 = 0
  var i: i64 = voff
  var rd: i64 = 1
  while rd == 1 {
      if i < end { let c: i64 = src[i]&0xff; if c>=48 { if c<=57 { v=v*10+(c-48); any=1; i=i+1 } else { rd=0 } } else { rd=0 } }
      else { rd = 0 }
  }
  if any == 0 { return 0 - 1 }
  return v
1497}
1498// Find a property by EXACT name on box_idx (reverse cascade = winner first) and return its leading
1499// integer value (px), or -1 if absent. Used for gap/column-gap/row-gap.
1500func _grid_prop_px(ctx: *LayoutCtx, box_idx: i64, name: *u8, nlen: i64) -> i64 {
  var i: i64 = ctx.n_computed - 1
  while i >= 0 {
      let cd: *CssComputedDecl = (ctx.computed as *u8 + (i as nx_size) * (NX_CSS_COMPUTED_DECL_BYTES as nx_size)) as *CssComputedDecl
      if cd.element_idx == box_idx {
          if cd.prop_len == nlen {
              var sp: i64 = 1
              var k: i64 = 0
              while k < nlen { if (ctx.src[cd.prop_off+k]&0xff) != (name[k]&0xff) { sp = 0; k = nlen } else { k = k + 1 } }
              if sp == 1 { return _grid_int_val(ctx.src, cd.val_off, cd.val_len) }
          }
      }
      i = i - 1
  }
  return 0 - 1
1515}
1516// Resolve the column gap (want_row=0) or row gap (want_row=1) for a grid box: column-gap/row-gap wins,
1517// else the `gap` shorthand, else 0.
1518func _grid_gap(ctx: *LayoutCtx, box_idx: i64, want_row: i64) -> i64 {
  if want_row == 1 {
      let rg: i64 = _grid_prop_px(ctx, box_idx, "row-gap\x00" as *u8, 7)
      if rg >= 0 { return rg }
  } else {
      let cg: i64 = _grid_prop_px(ctx, box_idx, "column-gap\x00" as *u8, 10)
      if cg >= 0 { return cg }
  }
  let g: i64 = _grid_prop_px(ctx, box_idx, "gap\x00" as *u8, 3)
  if g >= 0 { return g }
  return 0
1529}
1530// Get the grid-template-columns VALUE span for box_idx into ooff/olen; 1 if present, 0 if not.
1531func _layout_grid_template(ctx: *LayoutCtx, box_idx: i64, ooff: *i64, olen: *i64) -> i64 {
  let gp: *u8 = "grid-template-columns\x00" as *u8
  var i: i64 = ctx.n_computed - 1
  while i >= 0 {
      let cd: *CssComputedDecl = (ctx.computed as *u8 + (i as nx_size) * (NX_CSS_COMPUTED_DECL_BYTES as nx_size)) as *CssComputedDecl
      if cd.element_idx == box_idx {
          if cd.prop_len == 21 {
              var sp: i64 = 1
              var k: i64 = 0
              while k < 21 { if (ctx.src[cd.prop_off+k]&0xff) != (gp[k]&0xff) { sp = 0; k = 21 } else { k = k + 1 } }
              if sp == 1 { ooff[0] = cd.val_off; olen[0] = cd.val_len; return 1 }
          }
          // `grid-template` SHORTHAND (rows / columns): the COLUMNS live after the '/'. Wikipedia's
          // vector-2022 declares its sidebar grid ONLY this way (`grid-template:min-content 1fr
          // min-content / 12.25rem minmax(0,1fr)`) -- without this the grid never activated and the
          // whole page rendered flush-left (the styled dx~150 regime, 2026-07-28).
          if cd.prop_len == 13 {
              let gs: *u8 = "grid-template\x00" as *u8
              var sp2: i64 = 1
              var k2: i64 = 0
              while k2 < 13 { if (ctx.src[cd.prop_off+k2]&0xff) != (gs[k2]&0xff) { sp2 = 0; k2 = 13 } else { k2 = k2 + 1 } }
              if sp2 == 1 {
                  var sl: i64 = 0 - 1
                  var q: i64 = cd.val_off
                  let qe: i64 = cd.val_off + cd.val_len
                  while q < qe { if (ctx.src[q]&0xff) == 47 { sl = q; q = qe } else { q = q + 1 } }
                  if sl >= 0 {
                      ooff[0] = sl + 1
                      olen[0] = qe - (sl + 1)
                      return 1
                  }
              }
          }
      }
      i = i - 1
  }
  return 0
1568}
1569// Parse one track size token src[ts..te): sets fr_out[0]=1 for an `fr` (flexible) track, 0 for `px`
1570// (fixed). Returns the fr WEIGHT (>=1) for fr tracks or the px VALUE for fixed. A token with no digits
1571// (auto/min-content/etc) is treated as 1fr (so unknown tracks still take a flexible share, not zero).
1572func _grid_parse_size(src: *u8, ts: i64, te: i64, fr_out: *i64) -> i64 {
  // q3 thousandths (fractions matter: "12.25rem" was digit-scanned to 12px; it is 196px)
  var ip2: i64 = 0
  var any: i64 = 0
  var i: i64 = ts
  var rd: i64 = 1
  while rd == 1 {
      if i < te { let c: i64 = src[i]&0xff; if c>=48 { if c<=57 { ip2=ip2*10+(c-48); any=1; i=i+1 } else { rd=0 } } else { rd=0 } }
      else { rd = 0 }
  }
  var fr3: i64 = 0
  if i < te { if (src[i]&0xff) == 46 {
      i = i + 1
      var fd2: i64 = 0
      var g5: i64 = 1
      while g5 == 1 {
          if i < te { let c5: i64 = src[i]&0xff; if c5>=48 { if c5<=57 {
              if fd2 == 0 { fr3 = fr3 + (c5-48)*100 }
              if fd2 == 1 { fr3 = fr3 + (c5-48)*10 }
              if fd2 == 2 { fr3 = fr3 + (c5-48) }
              fd2 = fd2 + 1; i = i + 1
          } else { g5 = 0 } } else { g5 = 0 } }
          else { g5 = 0 }
      }
  } }
  let q3: i64 = ip2 * 1000 + fr3
  var isfr: i64 = 0
  var isrem: i64 = 0
  var j: i64 = i
  var u: i64 = 0
  while u == 0 {
      if j >= te { u = 1 }
      else {
          let c: i64 = src[j]&0xff
          if c==102 { isfr = 1; u = 1 }                      // fr
          else { if c==112 { u = 1 }                          // px
          else { if c==114 { isrem = 1; u = 1 }               // rem
          else { if c==101 { isrem = 1; u = 1 }               // em (~root-relative approx)
          else { j = j + 1 } } } }
      }
  }
  if any == 0 { fr_out[0] = 1; return 1 }
  fr_out[0] = isfr
  if isfr == 1 { var w5: i64 = q3 / 1000; if w5 < 1 { w5 = 1 } return w5 }
  if isrem == 1 { return (q3 * 16 + 500) / 1000 }
  return q3 / 1000
1618}
1619// Resolve grid-template-columns src[voff..voff+vlen) into per-column px widths[] for total available
1620// width `avail` with `col_gap` between columns. Supports a track list `200px 1fr 2fr` AND `repeat(N,
1621// SIZE)`. fr tracks split the leftover (avail - fixed_px - gaps) by weight. Returns the column count.
1622func _grid_resolve_tracks(src: *u8, voff: i64, vlen: i64, avail: i64, col_gap: i64, widths: *i64, maxcols: i64) -> i64 {
  let end: i64 = voff + vlen
  let is_fr: *i64 = sys_mmap(8 * (maxcols + 2)) as *i64
  let sz: *i64 = sys_mmap(8 * (maxcols + 2)) as *i64
  let frb: *i64 = sys_mmap(8) as *i64
  var ncols: i64 = 0
1628
  // detect a repeat( ... ) form
  var rep: i64 = 0 - 1
  var ri: i64 = voff
  while ri + 7 <= end {
      if (src[ri]&0xff)==114 { if (src[ri+1]&0xff)==101 { if (src[ri+2]&0xff)==112 { if (src[ri+3]&0xff)==101 { if (src[ri+4]&0xff)==97 { if (src[ri+5]&0xff)==116 { if (src[ri+6]&0xff)==40 {
          rep = ri + 7
      } } } } } } }
      ri = ri + 1
  }
  if rep >= 0 {
      // repeat( COUNT , TRACK ): COUNT is N or the keyword auto-fit/auto-fill; TRACK may be minmax(MIN,MAX).
      // auto-fit/fill = "as many MIN-wide columns as fit" -- THE modern responsive grid (office .newrow/.fgrid);
      // the old parser read auto-fit as N=0->1 -> single column -> everything STACKED.
      var j: i64 = rep
      var sk: i64 = 1
      while sk == 1 { if j < end { if (src[j]&0xff)==32 { j = j + 1 } else { sk = 0 } } else { sk = 0 } }
      var autofit: i64 = 0
      var nrep: i64 = 0
      if j < end { if (src[j]&0xff)==97 { autofit = 1 } }        // 'a' -> auto-fit / auto-fill
      if autofit == 1 {
          while j < end { if (src[j]&0xff)==44 { break } j = j + 1 }
      } else {
          var anyN: i64 = 0
          var rd: i64 = 1
          while rd == 1 { if j < end { let c: i64 = src[j]&0xff; if c>=48 { if c<=57 { nrep=nrep*10+(c-48); anyN=1; j=j+1 } else { rd=0 } } else { rd=0 } } else { rd=0 } }
          if anyN == 0 { nrep = 1 }
      }
      if j < end { if (src[j]&0xff)==44 { j = j + 1 } }
      var sk2: i64 = 1
      while sk2 == 1 { if j < end { if (src[j]&0xff)==32 { j = j + 1 } else { sk2 = 0 } } else { sk2 = 0 } }
      // TRACK: minmax(MIN,MAX) -> MIN px sets the auto-fit column count, MAX is the emitted track size.
      var minpx: i64 = 0
      var val: i64 = 1
      var ismm: i64 = 0
      if j + 7 <= end { if (src[j]&0xff)==109 { if (src[j+1]&0xff)==105 { if (src[j+2]&0xff)==110 { if (src[j+3]&0xff)==109 { if (src[j+4]&0xff)==97 { if (src[j+5]&0xff)==120 { if (src[j+6]&0xff)==40 { ismm = 1 } } } } } } } }
      let tfr: *i64 = sys_mmap(8) as *i64
      if ismm == 1 {
          var mj: i64 = j + 7
          var mc: i64 = mj
          while mc < end { let c: i64 = src[mc]&0xff; if c==44 { break } if c==41 { break } mc = mc + 1 }
          minpx = _grid_parse_size(src, mj, mc, tfr)
          var xj: i64 = mc
          if xj < end { if (src[xj]&0xff)==44 { xj = xj + 1 } }
          var wsx: i64 = 1
          while wsx == 1 { if xj < end { if (src[xj]&0xff)==32 { xj = xj + 1 } else { wsx = 0 } } else { wsx = 0 } }
          var xc: i64 = xj
          while xc < end { if (src[xc]&0xff)==41 { break } xc = xc + 1 }
          val = _grid_parse_size(src, xj, xc, frb)
      } else {
          var te: i64 = j
          var sd: i64 = 0
          while sd == 0 { if te >= end { sd = 1 } else { let c: i64 = src[te]&0xff; if c==41 { sd = 1 } else { if c==32 { sd = 1 } else { if c==44 { sd = 1 } else { te = te + 1 } } } } }
          val = _grid_parse_size(src, j, te, frb)
          if frb[0] == 0 { minpx = val } else { minpx = 120 }
      }
      var count: i64 = nrep
      if autofit == 1 {
          var mp: i64 = minpx
          if mp < 1 { mp = 1 }
          count = (avail + col_gap) / (mp + col_gap)
          if count < 1 { count = 1 }
      }
      var c2: i64 = 0
      while c2 < count { if ncols < maxcols { is_fr[ncols] = frb[0]; sz[ncols] = val; ncols = ncols + 1 } c2 = c2 + 1 }
  } else {
      // explicit whitespace-separated track list
      var p: i64 = voff
      var scan: i64 = 1
      while scan == 1 {
          var sw: i64 = 1
          while sw == 1 { if p >= end { sw = 0 } else { let c: i64 = src[p]&0xff; if c==32 { p=p+1 } else { if c==9 { p=p+1 } else { if c==10 { p=p+1 } else { if c==13 { p=p+1 } else { sw=0 } } } } } }
          if p >= end { scan = 0 }
          else {
              var te2: i64 = p
              var sd2: i64 = 0
              while sd2 == 0 { if te2 >= end { sd2 = 1 } else { let c: i64 = src[te2]&0xff; if c==32 { sd2=1 } else { if c==9 { sd2=1 } else { if c==10 { sd2=1 } else { if c==13 { sd2=1 } else { te2=te2+1 } } } } } }
              let val2: i64 = _grid_parse_size(src, p, te2, frb)
              if ncols < maxcols { is_fr[ncols] = frb[0]; sz[ncols] = val2; ncols = ncols + 1 }
              p = te2
          }
      }
  }
  if ncols < 1 { ncols = 1; is_fr[0] = 1; sz[0] = 1 }
1712
  var fixed_total: i64 = 0
  var fr_weight: i64 = 0
  var i: i64 = 0
  while i < ncols { if is_fr[i]==1 { fr_weight = fr_weight + sz[i] } else { fixed_total = fixed_total + sz[i] } i = i + 1 }
  var total_gap: i64 = 0
  if ncols > 1 { total_gap = (ncols - 1) * col_gap }
  var free: i64 = avail - fixed_total - total_gap
  if free < 0 { free = 0 }
  var fr_unit: i64 = 0
  if fr_weight > 0 { fr_unit = free / fr_weight }
  i = 0
  while i < ncols {
      if is_fr[i]==1 { widths[i] = sz[i] * fr_unit } else { widths[i] = sz[i] }
      i = i + 1
  }
  return ncols
1729}
1730
1731// Computed `float` for a box: 0=none, 1=left, 2=right (R5 rung 1). Reverse-scan = cascade winner first.
1732// Property "float" (5), value "left"(4)/"right"(5); anything else (incl. "none") -> 0.
1733func _layout_float(ctx: *LayoutCtx, box_idx: i64) -> i64 {
  let fp: *u8 = "float\x00" as *u8
  var i: i64 = ctx.n_computed - 1
  while i >= 0 {
      let cd: *CssComputedDecl = (ctx.computed as *u8 + (i as nx_size) * (NX_CSS_COMPUTED_DECL_BYTES as nx_size)) as *CssComputedDecl
      if cd.element_idx == box_idx {
          if cd.prop_len == 5 {
              var sp: i64 = 1
              var k: i64 = 0
              while k < 5 { if (ctx.src[cd.prop_off+k]&0xff) != (fp[k]&0xff) { sp = 0; k = 5 } else { k = k + 1 } }
              if sp == 1 {
                  // "left" -> 1
                  if cd.val_len == 4 {
                      if (ctx.src[cd.val_off]&0xff)==108 { if (ctx.src[cd.val_off+1]&0xff)==101 { if (ctx.src[cd.val_off+2]&0xff)==102 { if (ctx.src[cd.val_off+3]&0xff)==116 { return 1 } } } }
                  }
                  // "right" -> 2
                  if cd.val_len == 5 {
                      if (ctx.src[cd.val_off]&0xff)==114 { if (ctx.src[cd.val_off+1]&0xff)==105 { if (ctx.src[cd.val_off+2]&0xff)==103 { if (ctx.src[cd.val_off+3]&0xff)==104 { if (ctx.src[cd.val_off+4]&0xff)==116 { return 2 } } } } }
                  }
                  return 0
              }
          }
      }
      i = i - 1
  }
  return 0
1759}
1760// Computed `position` for a box: 0=static, 1=relative, 2=absolute, 3=fixed, 4=sticky.
1761// Same reverse-scan (cascade winner first) shape as _layout_float. Property "position" (8).
1762// Values matched on length + a distinguishing byte, the idiom used throughout this file:
1763//   relative(8,'r') · absolute(8,'a') · fixed(5) · sticky(6) · static(6,'s'-at-0 w/ 'a' at 2)
1764// `static` and anything unknown -> 0, so an unrecognised value can only ever mean NORMAL FLOW.
1765func _layout_position(ctx: *LayoutCtx, box_idx: i64) -> i64 {
  let pp: *u8 = "position\x00" as *u8
  var i: i64 = ctx.n_computed - 1
  while i >= 0 {
      let cd: *CssComputedDecl = (ctx.computed as *u8 + (i as nx_size) * (NX_CSS_COMPUTED_DECL_BYTES as nx_size)) as *CssComputedDecl
      if cd.element_idx == box_idx {
          if cd.prop_len == 8 {
              var sp: i64 = 1
              var k: i64 = 0
              while k < 8 { if (ctx.src[cd.prop_off+k]&0xff) != (pp[k]&0xff) { sp = 0; k = 8 } else { k = k + 1 } }
              if sp == 1 {
                  let v0: i64 = ctx.src[cd.val_off] & 0xff
                  if cd.val_len == 8 {
                      if v0 == 114 { return 1 }        // relative
                      if v0 == 97  { return 2 }        // absolute
                  }
                  if cd.val_len == 5 { if v0 == 102 { return 3 } }   // fixed
                  if cd.val_len == 6 { if v0 == 115 {
                      // sticky vs static: byte 2 is 'i' (105) for sticky, 'a' (97) for static
                      if (ctx.src[cd.val_off+2]&0xff) == 105 { return 4 }
                      return 0
                  } }
                  return 0
              }
          }
      }
      i = i - 1
  }
  return 0
1794}
1795// Computed `justify-content` for a flex container (main-axis distribution). Returns:
1796// 0 flex-start (default) · 1 center · 2 flex-end · 3 space-between · 4 space-around · 5 space-evenly.
1797// Matched by value length (+ one byte for around/evenly) -- standard keyword set.
1798func _layout_justify(ctx: *LayoutCtx, box_idx: i64) -> i64 {
  let jp: *u8 = "justify-content\x00" as *u8
  var i: i64 = ctx.n_computed - 1
  while i >= 0 {
      let cd: *CssComputedDecl = (ctx.computed as *u8 + (i as nx_size) * (NX_CSS_COMPUTED_DECL_BYTES as nx_size)) as *CssComputedDecl
      if cd.element_idx == box_idx {
          if cd.prop_len == 15 {
              var sp: i64 = 1
              var k: i64 = 0
              while k < 15 { if (ctx.src[cd.prop_off+k]&0xff) != (jp[k]&0xff) { sp = 0; k = 15 } else { k = k + 1 } }
              if sp == 1 {
                  let vl: i64 = cd.val_len
                  let vo: i64 = cd.val_off
                  if vl == 6 { return 1 }                        // center
                  if vl == 3 { return 2 }                        // end
                  if vl == 5 { return 0 }                        // start
                  if vl == 8 { return 2 }                        // flex-end
                  if vl == 10 { return 0 }                       // flex-start
                  if vl == 13 { return 3 }                       // space-between
                  if vl == 12 { if (ctx.src[vo+6]&0xff)==97 { return 4 } return 5 }   // space-around(a)/-evenly(e)
                  return 0
              }
          }
      }
      i = i - 1
  }
  return 0
1825}
1826// Computed `align-items` for a flex container (cross-axis = vertical for a row). Returns:
1827// 0 stretch/flex-start (default) · 1 center · 2 flex-end. (baseline approximated as start.)
1828func _layout_align(ctx: *LayoutCtx, box_idx: i64) -> i64 {
  let ap: *u8 = "align-items\x00" as *u8
  var i: i64 = ctx.n_computed - 1
  while i >= 0 {
      let cd: *CssComputedDecl = (ctx.computed as *u8 + (i as nx_size) * (NX_CSS_COMPUTED_DECL_BYTES as nx_size)) as *CssComputedDecl
      if cd.element_idx == box_idx {
          if cd.prop_len == 11 {
              var sp: i64 = 1
              var k: i64 = 0
              while k < 11 { if (ctx.src[cd.prop_off+k]&0xff) != (ap[k]&0xff) { sp = 0; k = 11 } else { k = k + 1 } }
              if sp == 1 {
                  let vl: i64 = cd.val_len
                  if vl == 6 { return 1 }                        // center
                  if vl == 3 { return 2 }                        // end
                  if vl == 8 { if (ctx.src[cd.val_off]&0xff)==102 { return 2 } return 0 }   // flex-end(f) vs baseline(b)
                  return 0                                        // flex-start / start / stretch
              }
          }
      }
      i = i - 1
  }
  return 0
1850}
1851// Computed `flex-grow` for a flex ITEM (the CHILD box, not the container). Returns the grow factor in Q3
1852// THOUSANDTHS (1.0 -> 1000; fractional 0.1 -> 100; 0 = does not grow) so fractional grow works. Also
1853// accepts the `flex` shorthand's FIRST token (`flex:1` -> 1000, `flex:0 0 0%` -> 0) since `flex:N` is more
1854// common on real pages. Negative/invalid -> 0 (negative flex-grow is invalid per spec). Reverse-walk =
1855// source-order winner, so a later `flex-grow` correctly overrides an earlier `flex` shorthand (and v.v.).
1856func _layout_flex_grow(ctx: *LayoutCtx, box_idx: i64) -> i64 {
  let fg: *u8 = "flex-grow\x00" as *u8     // len 9 (exact compare -- must NOT match flex-wrap, also len 9)
  let fx: *u8 = "flex\x00" as *u8          // len 4 (the shorthand)
  var i: i64 = ctx.n_computed - 1
  while i >= 0 {
      let cd: *CssComputedDecl = (ctx.computed as *u8 + (i as nx_size) * (NX_CSS_COMPUTED_DECL_BYTES as nx_size)) as *CssComputedDecl
      if cd.element_idx == box_idx {
          var matched: i64 = 0
          if cd.prop_len == 9 {
              var sp: i64 = 1
              var k: i64 = 0
              while k < 9 { if (ctx.src[cd.prop_off+k]&0xff) != (fg[k]&0xff) { sp = 0; k = 9 } else { k = k + 1 } }
              if sp == 1 { matched = 1 }
          }
          if matched == 0 { if cd.prop_len == 4 {
              var sp2: i64 = 1
              var k2: i64 = 0
              while k2 < 4 { if (ctx.src[cd.prop_off+k2]&0xff) != (fx[k2]&0xff) { sp2 = 0; k2 = 4 } else { k2 = k2 + 1 } }
              if sp2 == 1 { matched = 1 }
          } }
          if matched == 1 {
              // Parse the FIRST token of the value as a number in Q3 thousandths (so fractional grow like
              // 0.1 -> 100 works). For the `flex` shorthand ("0 0 0%") only the first token is the grow
              // factor. Skip leading spaces, take bytes up to the next space, hand to nx_css_number_parse.
              var p: i64 = cd.val_off
              let pe: i64 = cd.val_off + cd.val_len
              var skip: i64 = 1
              while skip == 1 {
                  if p < pe { if (ctx.src[p]&0xff) == 32 { p = p + 1 } else { skip = 0 } }
                  else { skip = 0 }
              }
              var te: i64 = p
              var go: i64 = 1
              while go == 1 { if te < pe { if (ctx.src[te]&0xff) == 32 { go = 0 } else { te = te + 1 } } else { go = 0 } }
              if te > p {
                  let q3: i64 = nx_css_number_parse(ctx.src, p, te - p)
                  if q3 == NX_CSS_NUMBER_PARSE_ERROR { return 0 }
                  if q3 < 0 { return 0 }
                  return q3
              }
              return 0
          }
      }
      i = i - 1
  }
  return 0
1902}
1903// Shift a box and its WHOLE subtree vertically by dy (used to cross-align a flex item after it's placed).
1904func _layout_shift_subtree(ctx: *LayoutCtx, box_idx: i64, dy: i64) -> i64 {
  if box_idx < 0 { return 0 }
  if box_idx >= ctx.tree.count { return 0 }
  let b: *LayoutBox = (ctx.tree.boxes as *u8 + (box_idx as nx_size) * (NX_LAYOUT_BOX_BYTES as nx_size)) as *LayoutBox
  b.y = b.y + dy
  if l_ytrap == 1 { if b.y + dy > NX_MAGIC_1000000000 {
      _yt_w("YTRAP@shift idx=" as *u8); _yt_n(box_idx)
      _yt_w(" oldy=" as *u8); _yt_n(b.y)
      _yt_w(" dy=" as *u8); _yt_n(dy)
      _yt_w("
1914" as *u8)
  } }
  var c: i64 = b.first_child_idx
  var safety: i64 = 0
  while c >= 0 {
      if safety >= NX_MAGIC_65536 { c = 0 - 1 }
      else {
          safety = safety + 1
          _layout_shift_subtree(ctx, c, dy)
          let cc: *LayoutBox = (ctx.tree.boxes as *u8 + (c as nx_size) * (NX_LAYOUT_BOX_BYTES as nx_size)) as *LayoutBox
          c = cc.next_sibling_idx
      }
  }
  return 0
1928}
1929func _layout_block_recurse(ctx: *LayoutCtx, table: *LayoutPropTable,
                          box_idx: i64,
                          avail_w: i64,
                          origin_x: i64, origin_y: i64) -> i64 {
  if box_idx < 0 { return 0 }
  if box_idx >= ctx.tree.count { return 0 }
1935
  let b: *LayoutBox = (ctx.tree.boxes as *u8 + (box_idx as nx_size) * (NX_LAYOUT_BOX_BYTES as nx_size)) as *LayoutBox
1937
  // display:none -> the box (and its subtree) take ZERO space and are not laid out (paint skips too).
  if _layout_display_none(ctx, box_idx) == 1 {
      b.x = origin_x
      b.y = origin_y
  if l_ytrap == 1 { if b.y > NX_MAGIC_1000000000 {
      _yt_w("YTRAP@1775 idx=" as *u8); _yt_n(box_idx)
      _yt_w(" oy=" as *u8); _yt_n(origin_y)
      _yt_w("
1946" as *u8)
  } }
      b.w = 0
      b.h = 0
      return 0
  }
1952
  // ---- TEXT box intrinsic sizing (5x7 bitmap font, 1px spacing) ----
  // Real CSS font-metrics integration is a separate arc; this gives
  // text boxes non-zero dimensions so block-flow stacking produces
  // visible vertical extent.  Compute width = min(text_len * 6, avail_w),
  // height = lines * 10 where lines = ceil(text_len / line_chars) and
  // line_chars = max(1, avail_w / 6).  Bits-up basis: see
  // nx_font_bitmap_5x7.nx for the underlying 5x7 glyph metrics.
  if b.kind == NX_LAYOUT_BOX_TEXT {
      let glyph_w: i64 = 9           // matches the 9x15 X render font advance (was 6)
      let glyph_h: i64 = 17          // matches 9x15 font height + leading (was 10)
      let tl: i64 = b.text_len
      if ctx.text_measured == 1 {
          // MEASURED mode: proportional width + measured word-wrap line count (font8x8 metrics SSOT).
          if ctx.font_tab == 0 { ctx.font_tab = (font8x8_table()) as i64 }
          let ftab: *u8 = ctx.font_tab as *u8
          let tp: *u8 = ((ctx.src as i64) + b.text_off) as *u8
          var mw: i64 = font8x8_text_w(ftab, tp, 0, tl)
          var av: i64 = avail_w
          if av < 4 { av = 4 }
          var ml: i64 = 0
          var ms: i64 = 0
          while ms < tl { ms = font8x8_next_break(ftab, tp, tl, av, ms); ml = ml + 1 }
          if ml < 1 { ml = 1 }
          if mw > avail_w { mw = avail_w }
          b.x = origin_x
          b.y = origin_y
  if l_ytrap == 1 { if b.y > NX_MAGIC_1000000000 {
      _yt_w("YTRAP@1806 idx=" as *u8); _yt_n(box_idx)
      _yt_w(" oy=" as *u8); _yt_n(origin_y)
      _yt_w("
1983" as *u8)
  } }
          b.w = mw
          b.h = ml * glyph_h
          return b.h
      }
      var line_chars: i64 = avail_w / glyph_w
      if line_chars < 1 { line_chars = 1 }
      var lines: i64 = tl / line_chars
      if tl - lines * line_chars > 0 { lines = lines + 1 }
      if lines < 1 { lines = 1 }
      var w_px: i64 = tl * glyph_w
      if w_px > avail_w { w_px = avail_w }
      b.x = origin_x
      b.y = origin_y
  if l_ytrap == 1 { if b.y > NX_MAGIC_1000000000 {
      _yt_w("YTRAP@1819 idx=" as *u8); _yt_n(box_idx)
      _yt_w(" oy=" as *u8); _yt_n(origin_y)
      _yt_w("
2002" as *u8)
  } }
      b.w = w_px
      b.h = lines * glyph_h
      return b.h
  }
2008
  // Resolve box-model values from cascade (-1 / UNSET = not specified). Each side = ONE reverse scan
  // across its longhand AND the `margin`/`padding` shorthand -- last declaration wins (cascade order).
  let mt_raw: i64 = _layout_boxside_px(ctx, table.src, box_idx, table.margin_top_off, table.margin_top_len, "margin" as *u8, 6, 0, NX_MARGIN_UNSET)
  let mb_raw: i64 = _layout_boxside_px(ctx, table.src, box_idx, table.margin_bottom_off, table.margin_bottom_len, "margin" as *u8, 6, 2, NX_MARGIN_UNSET)
  let ml_raw: i64 = _layout_boxside_px(ctx, table.src, box_idx, table.margin_left_off, table.margin_left_len, "margin" as *u8, 6, 3, NX_MARGIN_UNSET)
  let mr_raw: i64 = _layout_boxside_px(ctx, table.src, box_idx, table.margin_right_off, table.margin_right_len, "margin" as *u8, 6, 1, NX_MARGIN_UNSET)
  let pt_raw: i64 = _layout_boxside_px(ctx, table.src, box_idx, table.padding_top_off, table.padding_top_len, "padding" as *u8, 7, 0, 0 - 1)
  let pb_raw: i64 = _layout_boxside_px(ctx, table.src, box_idx, table.padding_bottom_off, table.padding_bottom_len, "padding" as *u8, 7, 2, 0 - 1)
  let pl_raw: i64 = _layout_boxside_px(ctx, table.src, box_idx, table.padding_left_off, table.padding_left_len, "padding" as *u8, 7, 3, 0 - 1)
  let pr_raw: i64 = _layout_boxside_px(ctx, table.src, box_idx, table.padding_right_off, table.padding_right_len, "padding" as *u8, 7, 1, 0 - 1)
  let w_raw: i64 = _layout_lookup_px(ctx, table.src, box_idx, table.width_off, table.width_len)
  let h_raw: i64 = _layout_lookup_height_px(ctx, table.src, box_idx, table.height_off, table.height_len)
2021
  // SCREEN-READER-ONLY pattern (seq1150, 2026-07-28): width:1px + height:1px (+ clip/overflow:hidden,
  // which this engine does not implement) is the universal accessibility hide -- wikipedia's
  // .mw-jump-link, WordPress .screen-reader-text. Chrome shows NOTHING readable (contents clipped to
  // the 1x1 box); without clipping we char-wrapped the text into a 1px-wide, 255px-tall visible
  // column (probe-proven on the real page). An element EXPLICITLY sized <=1x1 on BOTH axes lays out
  // as hidden: subtree untouched, the paint's h==0 guard skips it. A 1px DIVIDER (width:1px,
  // height auto/large) is NOT matched -- both axes must be explicit and <=1.
  if w_raw >= 0 { if w_raw <= 1 { if h_raw >= 0 { if h_raw <= 1 {
      b.x = origin_x
      b.y = origin_y
  if l_ytrap == 1 { if b.y > NX_MAGIC_1000000000 {
      _yt_w("YTRAP@1847 idx=" as *u8); _yt_n(box_idx)
      _yt_w(" oy=" as *u8); _yt_n(origin_y)
      _yt_w("
2036" as *u8)
  } }
      b.w = 0
      b.h = 0
      return 0
  } } } }
2042
  var mt: i64 = mt_raw
  if mt == NX_MARGIN_UNSET { mt = 0 }    // unset -> 0; a real NEGATIVE margin is KEPT (overlap), not clamped
  var mb: i64 = mb_raw
  if mb == NX_MARGIN_UNSET { mb = 0 }
  var ml: i64 = ml_raw
  if ml == NX_MARGIN_UNSET { ml = 0 }
  var mr: i64 = mr_raw
  if mr == NX_MARGIN_UNSET { mr = 0 }
  var pt: i64 = pt_raw
  if pt < 0 { pt = 0 }
  var pb: i64 = pb_raw
  if pb < 0 { pb = 0 }
  var pl: i64 = pl_raw
  if pl < 0 { pl = 0 }
  var pr: i64 = pr_raw
  if pr < 0 { pr = 0 }
2059
  // Width: explicit, else fill avail_w (minus horizontal margins).
  var content_w: i64 = w_raw
  if content_w < 0 {
      content_w = avail_w - ml - mr
      if content_w < 0 { content_w = 0 }
  }
  // MAX-WIDTH (CSS 2.1 §10.4) via the literal-source lookup (the top/left trick -- no prop-table
  // widening). Constrains both explicit and fill widths; absurd values already rejected upstream.
  let mxw: i64 = _layout_lookup_px(ctx, "max-width\x00" as *u8, box_idx, 0, 9)
  if mxw >= 0 { if mxw < NX_MAGIC_100000 { if content_w > mxw { content_w = mxw } } }
2070
  // Position the border-box. Horizontal margin shifts x; padding
  // expands children's available width and offsets their origin.
  b.x = origin_x + ml
  // AUTO-MARGIN CENTERING (§10.3.3): both horizontal margins auto + used width < avail -> the free
  // space splits equally. THE styled-wikipedia dx≈150 regime: `.mw-page-container{margin:0 auto;
  // max-width:...}` -- Chrome centers the whole page column; we rendered it flush-left (2026-07-28).
  if content_w < avail_w {
      if _lb_margin_auto(ctx, box_idx, 3) == 1 { if _lb_margin_auto(ctx, box_idx, 1) == 1 {
          b.x = origin_x + (avail_w - content_w) / 2
      } }
  }
  b.y = origin_y + mt
  if l_ytrap == 1 { if b.y > NX_MAGIC_1000000000 {
      _yt_w("YTRAP block idx=" as *u8); _yt_n(box_idx)
      _yt_w(" origin_y=" as *u8); _yt_n(origin_y)
      _yt_w(" mt=" as *u8); _yt_n(mt)
      _yt_w(" mt_raw=" as *u8); _yt_n(mt_raw)
      _yt_w("\n" as *u8)
  } }
  b.w = content_w
2091
  // Lay out children inside the content box.
  let content_origin_x: i64 = b.x + pl
  let content_origin_y: i64 = b.y + pt
  let child_avail_w: i64 = content_w - pl - pr
2096
  var children_h: i64 = 0
  var use_grid: i64 = _layout_display_grid(ctx, box_idx)
  if use_grid == 1 { if _layout_has_grid_areas(ctx, box_idx) == 1 { use_grid = 0 } }   // named areas -> block flow
  if use_grid == 1 {
      // ---- GRID (rung 2) ---- tracks from grid-template-columns with PER-TRACK sizing (px fixed + fr
      // flexible share of leftover) + column-gap/row-gap/gap. Children placed ROW-MAJOR, wrapping every
      // ncols; row height = tallest child outer height; rows separated by row_gap. (rung 1 = equal cols
      // is the special case all-fr-equal/no-gap.) grid-template-rows, line placement + spanning = later.
      let g_toff: *i64 = sys_mmap(8) as *i64
      let g_tlen: *i64 = sys_mmap(8) as *i64
      let g_widths: *i64 = sys_mmap(8 * 258) as *i64
      let col_gap: i64 = _grid_gap(ctx, box_idx, 0)
      let row_gap: i64 = _grid_gap(ctx, box_idx, 1)
      var ncols: i64 = 1
      if _layout_grid_template(ctx, box_idx, g_toff, g_tlen) == 1 {
          ncols = _grid_resolve_tracks(ctx.src, g_toff[0], g_tlen[0], child_avail_w, col_gap, g_widths, 256)
      } else { g_widths[0] = child_avail_w }
      if ncols < 1 { ncols = 1 }
      var gcol: i64 = 0
      var rows_done: i64 = 0
      var row_y: i64 = content_origin_y
      var row_h: i64 = 0
      var col_x: i64 = content_origin_x
      var gci: i64 = b.first_child_idx
      var gsf: i64 = 0
      while gci >= 0 {
          if gsf >= NX_MAGIC_4096 { gci = 0 - 1 }
          else {
              gsf = gsf + 1
              if gcol == 0 {
                  if rows_done > 0 { row_y = row_y + row_gap }
                  col_x = content_origin_x
              }
              let gcw: i64 = g_widths[gcol]
              let gchh: i64 = _layout_block_recurse(ctx, table, gci, gcw, col_x, row_y)
              if gchh > row_h { row_h = gchh }
              let gcc: *LayoutBox = (ctx.tree.boxes as *u8 + (gci as nx_size) * (NX_LAYOUT_BOX_BYTES as nx_size)) as *LayoutBox
              let gnxt: i64 = gcc.next_sibling_idx
              col_x = col_x + gcw + col_gap
              gcol = gcol + 1
              if gcol >= ncols { row_y = row_y + row_h; rows_done = rows_done + 1; row_h = 0; gcol = 0 }
              gci = gnxt
          }
      }
      if gcol > 0 { row_y = row_y + row_h }
      children_h = row_y - content_origin_y
  } else {
  // TABLE (seq1158): resolve this table's column widths ONCE, publish them for the row (flex) path
  // below, lay the subtree out normally, then RESTORE the previous table context -- nested tables
  // (news.ycombinator.com nests them) each get their own columns and the outer one survives intact.
  var tbl_saved_active: i64 = 0
  var tbl_saved_idx: i64 = 0
  var tbl_saved_ncols: i64 = 0
  var tbl_saved_p: i64 = 0
  var tbl_entered: i64 = 0
  if _layout_display_table(ctx, box_idx) == 1 {
      tbl_saved_active = l_tbl_active
      tbl_saved_idx = l_tbl_idx
      tbl_saved_ncols = l_tbl_ncols
      tbl_saved_p = l_tbl_colw_p
      tbl_entered = 1
      let cwbuf: *i64 = sys_mmap(8 * NX_TBL_MAXCOLS) as *i64
      let nc: i64 = _layout_table_cols(ctx, box_idx, child_avail_w, cwbuf)
      if nc > 0 {
          l_tbl_active = 1
          l_tbl_idx = box_idx
          l_tbl_ncols = nc
          l_tbl_colw_p = cwbuf as i64
      } else { l_tbl_active = 0 }
  }
  var is_rowflex: i64 = _layout_display_flex(ctx, box_idx)
  if is_rowflex == 1 { if _layout_flex_dir_col(ctx, box_idx) == 1 { is_rowflex = 0 } }   // column flex = block stacking
  if is_rowflex == 1 {
      // ---- FLEX ROW (rung 2: + justify-content) ---- children LEFT-TO-RIGHT; width = explicit `width`
      // else an equal share of the remaining space (auto-fill); container height = tallest child.
      // justify-content distributes the FREE space (avail - used) on the main axis -- a no-op when
      // children auto-fill (free=0, so tables/sidebars are unchanged), active when children have explicit
      // widths. flex-grow/shrink/basis, wrap, align-items = subsequent rungs.
      var nauto: i64 = 0
      var sum_explicit: i64 = 0
      var sum_base: i64 = 0          // Σ flex-basis (explicit width else content width) -- auto != 0
      var n_children: i64 = 0
      var sum_grow: i64 = 0          // Σ flex-grow over children, in Q3 thousandths (rung 3; fractional-aware)
      var has_grow: i64 = 0          // any child with flex-grow>0 -> use the grow distribution path
      var ci: i64 = b.first_child_idx
      var sf: i64 = 0
      while ci >= 0 {
          if sf >= NX_MAGIC_4096 { ci = 0 - 1 }
          else {
              sf = sf + 1
              n_children = n_children + 1
              let cw0: i64 = _layout_lookup_px(ctx, table.src, ci, table.width_off, table.width_len)
              let cg: i64 = _layout_flex_grow(ctx, ci)
              // flex-grow accrues for EVERY growing item (explicit-width OR auto basis). BASE size =
              // explicit width else the item's CONTENT width -- CSS flex-basis defaults to AUTO, not 0.
              // The old base-0 model collapsed every grow-0 auto sibling to w=0: x.com's login card laid
              // "Continue with Google" (explicit) while "Continue with phone/Apple"/"or"/"Email or
              // username" all rendered as w=0 slivers (region x-ray, 2026-07-28).
              if cg > 0 { has_grow = 1; sum_grow = sum_grow + cg }
              var cb0: i64 = cw0
              if cb0 < 0 { cb0 = _layout_intrinsic_w(ctx, ci) }
              sum_base = sum_base + cb0
              if cw0 >= 0 { sum_explicit = sum_explicit + cw0 } else { nauto = nauto + 1 }
              let cc: *LayoutBox = (ctx.tree.boxes as *u8 + (ci as nx_size) * (NX_LAYOUT_BOX_BYTES as nx_size)) as *LayoutBox
              ci = cc.next_sibling_idx
          }
      }
      var rem: i64 = child_avail_w - sum_explicit
      // FLEX-SHRINK (minimal, 2026-07-28): when explicit-width children OVERFLOW the row, real CSS
      // shrinks them (flex-shrink defaults to 1); our old model kept them full-size and starved every
      // auto sibling to w=0 (the x.com login-card sliver that survived the basis fix). Shrink-mode
      // sizes EVERY child proportionally to its basis so the row exactly fits. Fires ONLY in the
      // previously-broken overflow case -- healthy rows are untouched by construction.
      var shrinkmode: i64 = 0
      if has_grow == 0 { if rem <= 0 { if sum_base > 0 { if n_children > 1 { shrinkmode = 1 } } } }
      if rem < 0 { rem = 0 }
      var auto_w: i64 = 0
      if nauto > 0 { auto_w = rem / nauto }
      // free space on the main axis after laying children at their widths -> justify-content distributes it
      let total_used: i64 = sum_explicit + nauto * auto_w
      var free: i64 = child_avail_w - total_used
      if free < 0 { free = 0 }
      // flex-grow (rung 3): distribute the leftover space (avail - Σ explicit-width siblings) among the
      // AUTO-basis growing items, proportionally to their grow factors (basis 0). Grown items consume
      // all the leftover, so there is no main-axis free space for justify-content (free=0 -> no-op).
      var grow_free: i64 = 0
      if has_grow == 1 {
          grow_free = child_avail_w - sum_base     // leftover AFTER content-sized bases (basis:auto)
          if grow_free < 0 { grow_free = 0 }
          free = 0
      }
      let jc: i64 = _layout_justify(ctx, box_idx)
      var start_off: i64 = 0
      var spacing: i64 = 0
      if jc == 1 { start_off = free / 2 }                                          // center
      if jc == 2 { start_off = free }                                              // flex-end
      if jc == 3 { if n_children > 1 { spacing = free / (n_children - 1) } }        // space-between
      if jc == 4 { if n_children > 0 { spacing = free / n_children; start_off = spacing / 2 } }   // space-around
      if jc == 5 { if n_children > 0 { spacing = free / (n_children + 1); start_off = spacing } } // space-evenly
      var rx: i64 = content_origin_x + start_off
      var max_h: i64 = 0
      var tcell_i: i64 = 0          // 0-based cell index = the COLUMN index for a table row
      ci = b.first_child_idx
      sf = 0
      while ci >= 0 {
          if sf >= NX_MAGIC_4096 { ci = 0 - 1 }
          else {
              sf = sf + 1
              let cwe: i64 = _layout_lookup_px(ctx, table.src, ci, table.width_off, table.width_len)
              var cw: i64 = auto_w
              if cwe >= 0 { cw = cwe }
              if shrinkmode == 1 {
                  var sbase: i64 = cwe
                  if sbase < 0 { sbase = _layout_intrinsic_w(ctx, ci) }
                  cw = (sbase * child_avail_w) / sum_base
              }
              // TABLE COLUMN (seq1158): an auto-width cell of a row belonging to the ACTIVE table takes
              // its COLUMN's shared max-content width instead of an equal share. Guarded by the row's
              // nearest-table identity, so a plain display:flex div inside a cell is unaffected.
              // colspan (seq1159): a spanning cell takes the SUM of its N columns and advances N slots.
              var tcell_adv: i64 = 1
              if l_tbl_active == 1 { if cwe < 0 { if tcell_i < l_tbl_ncols {
                  if _layout_nearest_table(ctx, box_idx) == l_tbl_idx {
                      let tcolw: *i64 = l_tbl_colw_p as *i64
                      let cellb: *LayoutBox = _lb_box(ctx, ci)
                      if cellb.source_node_idx >= 2 { tcell_adv = cellb.source_node_idx }
                      var csum: i64 = 0
                      var ck: i64 = 0
                      while ck < tcell_adv {
                          if tcell_i + ck < l_tbl_ncols { csum = csum + tcolw[tcell_i + ck] }
                          ck = ck + 1
                      }
                      cw = csum
                  }
              } } }
              // flex-grow distribution: width = base + its proportional share of the leftover, where
              // base = explicit width (flex-basis) else 0. A grow-0 auto item collapses to 0; a grow-0
              // explicit item keeps its width. Active only in a has_grow container, so non-grow flex
              // layouts (the common case) are byte-identical to before.
              if has_grow == 1 {
                  let cg2: i64 = _layout_flex_grow(ctx, ci)
                  var base: i64 = cwe
                  if base < 0 { base = _layout_intrinsic_w(ctx, ci) }   // flex-basis:auto = content size
                  var share: i64 = 0
                  // divisor = max(1.0, Σgrow) in Q3 thousandths: when Σgrow<1, only that fraction of the
                  // free space is distributed (the rest stays unused), per CSS Flexbox §9.7. When Σgrow>=1
                  // it normalizes (grow_i/Σgrow) as usual. Integer grow (1->1000) is unchanged.
                  if cg2 > 0 {
                      var divisor: i64 = sum_grow
                      if divisor < 1000 { divisor = 1000 }
                      share = (cg2 * grow_free) / divisor
                  }
                  cw = base + share
              }
              let chh: i64 = _layout_block_recurse(ctx, table, ci, cw, rx, content_origin_y)
              // explicit-width grow item: the recurse sized the box to its explicit width (it reads the
              // CSS width directly, ignoring the grown avail we passed) -> force the grown main-size onto
              // the box. Exact for leaf items; a non-leaf's children keep the explicit width (minor approx).
              if has_grow == 1 { if cwe >= 0 {
                  let ccg: *LayoutBox = (ctx.tree.boxes as *u8 + (ci as nx_size) * (NX_LAYOUT_BOX_BYTES as nx_size)) as *LayoutBox
                  ccg.w = cw
              } }
              rx = rx + cw + spacing
              tcell_i = tcell_i + tcell_adv
              if chh > max_h { max_h = chh }
              let cc2: *LayoutBox = (ctx.tree.boxes as *u8 + (ci as nx_size) * (NX_LAYOUT_BOX_BYTES as nx_size)) as *LayoutBox
              ci = cc2.next_sibling_idx
          }
      }
      // align-items (cross axis): items were placed at the top; center/flex-end shift each down within
      // the row's height (max_h). A no-op for the default (stretch/flex-start) and when all items are
      // equal-height (offset 0), so existing flex layouts are unchanged.
      let ai: i64 = _layout_align(ctx, box_idx)
      if ai != 0 {
          // cross-size = the container's content height (explicit height wins, else the tallest item)
          var cross_size: i64 = max_h
          if h_raw >= 0 { cross_size = h_raw }
          var ci3: i64 = b.first_child_idx
          var sf3: i64 = 0
          while ci3 >= 0 {
              if sf3 >= NX_MAGIC_4096 { ci3 = 0 - 1 }
              else {
                  sf3 = sf3 + 1
                  let cb: *LayoutBox = (ctx.tree.boxes as *u8 + (ci3 as nx_size) * (NX_LAYOUT_BOX_BYTES as nx_size)) as *LayoutBox
                  let chh2: i64 = cb.h
                  var aoff: i64 = 0
                  if ai == 1 { aoff = (cross_size - chh2) / 2 }
                  if ai == 2 { aoff = cross_size - chh2 }
                  if aoff < 0 { aoff = 0 }
                  if aoff > NX_MAGIC_100000 { aoff = 0 }   // a cross-shift beyond any page is corrupt input, never applied
                  let cnext: i64 = cb.next_sibling_idx
                  if aoff > 0 { _layout_shift_subtree(ctx, ci3, aoff) }
                  ci3 = cnext
              }
          }
      }
      children_h = max_h
  } else {
      // Mixed block/inline flow: BLOCK children stack vertically; runs of INLINE/TEXT children flow
      // horizontally via a line-box pen (wrapping at avail_w). The pen's pen_y is the single vertical
      // cursor; a BLOCK child first flushes any open inline line, then advances pen_y by its height.
      let pen: *InlinePen = (sys_mmap(NX_INLINE_PEN_BYTES as nx_size)) as *InlinePen
      pen.pen_x = 0
      pen.pen_y = 0
      pen.line_h = 0
      pen.avail_w = child_avail_w
      pen.origin_x = content_origin_x
      pen.origin_y = content_origin_y
      pen.table = table as i64
      // float state (R5 rung 1): ONE active float region; fl_bottom/fl_w are content-relative.
      // float_extent = lowest float bottom seen (so the container grows to contain a tall float).
      var fl_side: i64 = 0           // 0 none, 1 left, 2 right
      var fl_bottom: i64 = 0
      var fl_w: i64 = 0
      var float_extent: i64 = 0
      var child_idx: i64 = b.first_child_idx
      var safety: i64 = 0
      let MAX_ITER: i64 = NX_MAGIC_65536
      var keep: i64 = 1
      while keep == 1 {
          if safety >= MAX_ITER { keep = 0 }
          else {
              safety = safety + 1
              if child_idx < 0 { keep = 0 }
              else {
                  let c: *LayoutBox = (ctx.tree.boxes as *u8 + (child_idx as nx_size) * (NX_LAYOUT_BOX_BYTES as nx_size)) as *LayoutBox
                  if c.kind == NX_LAYOUT_BOX_BLOCK {
                      if pen.pen_x > 0 {
                          pen.pen_y = pen.pen_y + pen.line_h
                          pen.pen_x = 0
                          pen.line_h = 0
                      }
                      // OUT-OF-FLOW POSITIONING (CSS 2.1 §9.3): absolute/fixed boxes are removed
                      // from normal flow -- they do NOT advance the cursor and do NOT contribute
                      // height. Before this, an overlay/dropdown/sticky-header stacked as a normal
                      // block, so real stylesheets built a tall scattered ribbon instead of a
                      // layout: MEASURED 2026-07-27, stackoverflow's page_h ran 18,617 vs Chrome's
                      // ~7,000 with CSS on, and layout_pos_probe showed an absolute box adding its
                      // full 100px to the page. They are still laid out and painted (at the current
                      // flow origin, offset by top/left when given) so content stays visible --
                      // full containing-block resolution is the next rung, but consuming flow space
                      // is the part that actually wrecks the page.
                      var oof: i64 = 0
                      let posk: i64 = _layout_position(ctx, child_idx)
                      if posk == 2 { oof = 1 }
                      if posk == 3 { oof = 1 }
                      if oof == 1 {
                          // `top`/`left` are not in LayoutPropTable (it carries only margin/padding/
                          // width/height), and widening that struct would touch every constructor.
                          // _layout_lookup_px compares against a CALLER-SUPPLIED buffer, so a string
                          // literal at offset 0 is a legal property source -- no struct change needed.
                          let poff_t: i64 = _layout_lookup_px(ctx, "top\x00" as *u8, child_idx, 0, 3)
                          let poff_l: i64 = _layout_lookup_px(ctx, "left\x00" as *u8, child_idx, 0, 4)
                          var pax: i64 = content_origin_x
                          var pay: i64 = content_origin_y + pen.pen_y
                          if poff_l >= 0 { pax = content_origin_x + poff_l }
                          if poff_t >= 0 { pay = content_origin_y + poff_t }
                          // laid out + painted, but pen.pen_y is NOT advanced -> zero flow height.
                          _layout_block_recurse(ctx, table, child_idx, child_avail_w, pax, pay)
                      }
                      let flo: i64 = _layout_float(ctx, child_idx)
                      let fwe: i64 = _layout_lookup_px(ctx, table.src, child_idx, table.width_off, table.width_len)
                      if oof == 1 { fl_side = fl_side }              // out-of-flow: nothing else to do
                      else { if flo != 0 { if fwe >= 0 {
                          // FLOATED block with explicit width: pin to the left/right edge at the current
                          // pen_y, OUT of normal flow (pen_y does NOT advance -> following blocks flow beside).
                          var fx: i64 = content_origin_x
                          if flo == 2 { fx = content_origin_x + child_avail_w - fwe }
                          let fh: i64 = _layout_block_recurse(ctx, table, child_idx, fwe, fx, content_origin_y + pen.pen_y)
                          fl_side = flo
                          fl_w = fwe
                          let fbot: i64 = pen.pen_y + fh
                          if fbot > fl_bottom { fl_bottom = fbot }
                          if fbot > float_extent { float_extent = fbot }
                      } else {
                          // float w/o explicit width: shrink-to-fit is a later rung -> normal full-width block.
                          let chn: i64 = _layout_block_recurse(ctx, table, child_idx, child_avail_w, content_origin_x, content_origin_y + pen.pen_y)
                          pen.pen_y = pen.pen_y + chn
                      } }
                      else {
                          // NORMAL block: while an active float covers this y, flow BESIDE it (shifted + narrower).
                          var bx: i64 = content_origin_x
                          var bw: i64 = child_avail_w
                          if fl_side != 0 { if pen.pen_y < fl_bottom {
                              bw = child_avail_w - fl_w
                              if bw < 0 { bw = 0 }
                              if fl_side == 1 { bx = content_origin_x + fl_w }   // left float pushes content right
                          } }
                          let child_outer_h: i64 = _layout_block_recurse(ctx, table, child_idx, bw, bx, content_origin_y + pen.pen_y)
                          pen.pen_y = pen.pen_y + child_outer_h
                          if fl_side != 0 { if pen.pen_y >= fl_bottom { fl_side = 0; fl_w = 0 } }   // cleared the float
                      } }
                  } else {
                      // INLINE content beside a float: narrow/shift the pen so inline text flows BESIDE
                      // the float (the same treatment BLOCK children get above) instead of overlapping it
                      // -- the Wikipedia header fix (a float:right infobox was overlapping the intro text).
                      // ALWAYS recompute the pen constraints from the CURRENT float coverage (not just when
                      // active) so a cleared float resets cleanly to full width. Right float narrows
                      // avail_w; left float also shifts origin_x past the float.
                      var iaw: i64 = child_avail_w
                      var ileft: i64 = content_origin_x
                      if fl_side != 0 { if pen.pen_y < fl_bottom {
                          iaw = child_avail_w - fl_w
                          if iaw < 0 { iaw = 0 }
                          if fl_side == 1 { ileft = content_origin_x + fl_w }
                      } }
                      pen.avail_w = iaw
                      pen.origin_x = ileft
                      _layout_inline_flow(ctx, pen, child_idx)
                      if fl_side != 0 { if pen.pen_y >= fl_bottom { fl_side = 0; fl_w = 0 } }
                  }
                  child_idx = c.next_sibling_idx
              }
          }
      }
      if pen.pen_x > 0 {
          pen.pen_y = pen.pen_y + pen.line_h
          pen.pen_x = 0
          pen.line_h = 0
      }
      children_h = pen.pen_y
      if float_extent > children_h { children_h = float_extent }   // contain a float taller than the text
  }
  }
  // leaving a table: restore the enclosing table's column context (nested-table correctness)
  if tbl_entered == 1 {
      l_tbl_active = tbl_saved_active
      l_tbl_idx = tbl_saved_idx
      l_tbl_ncols = tbl_saved_ncols
      l_tbl_colw_p = tbl_saved_p
  }
2468
  // Content height: explicit `height` declaration wins, else
  // sum of children heights.
  var content_h: i64 = children_h
  if h_raw >= 0 { content_h = h_raw }
2473
  b.h = pt + content_h + pb
2475
  return mt + b.h + mb
2477}
2478
2479// ---- public API ----
2480
2481func nx_layout_block_layout(ctx: *LayoutCtx, table: *LayoutPropTable,
                           root_idx: i64) -> i64 {
  if root_idx < 0 { return -1 }
  if root_idx >= ctx.tree.count { return -1 }
  let outer_h: i64 = _layout_block_recurse(ctx, table, root_idx,
      ctx.viewport_w, 0, 0)
  return outer_h
2488}
2489
2490func nx_layout_ctx_init(ctx: *LayoutCtx, tree: *LayoutTree,
                       computed: *CssComputedDecl, n_computed: i64,
                       src: *u8, viewport_w: i64,
                       resolve_ctx: *CssResolveCtx) -> i64 {
  ctx.tree = tree
  ctx.computed = computed
  ctx.n_computed = n_computed
  ctx.src = src
  ctx.viewport_w = viewport_w
  ctx.resolve_ctx = resolve_ctx
  ctx.text_measured = 0          // legacy monospace cells unless the consumer opts in (additive)
  ctx.font_tab = 0
  return 0
2503}
nx_layout_block.nx source

`nx_layout_block.nx` source
