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

↩ module page · 460 lines · 26761 B
1// nx_nishios_browser_x86.nx -- BROWSER-ON-ALL-OS arc, rung N4: the browser's pixels land in the NishiOS
2// framebuffer via EXECUTED x86 STORE INSTRUCTIONS (the draw-as-x86 seam, same move as nx_nishios_fb_x86).
3//
4// N1 proved the browser RENDERS on NishiOS and N2 proved INPUT -- but the window pixels were written by
5// a NishiLang blit loop.  This rung closes that seam one level deeper: after the boot gate, the page is
6// laid out + painted by the browser core into an RGB buffer (the PREP), then an AUTHORED REAL-ENCODING
7// x86 program (movabs imm64 / mov r32 load+store / add imm8 / mov rcx,imm32 / dec / jnz / hlt -- a
8// 2-level strided copy loop) is EXECUTED on a sovereign mini-emu, and it is those executed `89 10`
9// (mov [rax],edx) stores that write EVERY byte of the browser window region of the NishiOS framebuffer,
10// row-strided into place.  Byte-verified against a NishiLang oracle blit; the executed-store COUNT must
11// equal the window byte count / 4 exactly.
12//
13// KAT: T1 booted off the persisted image; T2 LONG mode + banner; T3 page laid out; T4 the x86 program
14// ran to a clean HLT; T5 executed 32-bit stores == 465*426 exactly (every window word written by x86);
15// T6 window region byte-IDENTICAL to the oracle blit; T7 x86 never scribbled outside the window (chrome
16// pixel intact); T8 BMP exported at the exact expected size.  NEG/liar-kill: T9 a corrupted store opcode
17// (0x89 -> 0x88, an encoding this emu does not implement) REFUSES execution and leaves the window
18// unwritten; T10 a 0-sector-load sibling image never reaches long mode -> nothing is drawn at all.
19//
20// HONEST SEAM (stated, not hidden): layout/paint PREP is NishiLang (running the full render core as
21// x86-on-emu = compiling the browser itself to the emu's ISA, a far deeper rung); what this rung proves
22// is that the FRAMEBUFFER WRITES -- the pixels you see in the window -- were performed by real executed
23// x86 stores, strides and all.  NishiOS-native fetch (nx_nishios_net) remains the named next rung.
24// NEVER-BRICK (Rule 26): writes FILE artifacts only; models INT 13h *reads*; no /dev.
25// expect_exit: 0   license_tier: ORIGINAL
26import "nx_browser_render.nx"
27import "nx_itoa_lib.nx"   // shared MSB-first emitter (zero-alloc)
28import "nx_fb.nx"
29const NB_MAGIC_200000: i64 = 200000
30const NB_MAGIC_32767: i64 = 32767
31const NB_MAGIC_65536: i64 = 65536
32const NB_MAGIC_3000000: i64 = 3000000
33
34func nb_puts(s: *u8) -> i64 { var n: i64=0; while s[n]!=(0 as u8){n=n+1} sys_write(1,s,n); return 0 }
35// MIGRATED to the shared emitter (debt 1785563586). The old body mmapped a scratch buffer
36// per call and never freed it. At PAGE granularity that is 4096B leaked PER CALL -- the
37// defect that took 28.5GB of a 36GB host in nx_ts_lumadiff (2MB input, ~3.66M calls).
38// nxi_* is MSB-first, allocates NOTHING, and emits identical bytes including the sign.
39func nb_num(v: i64) -> i64 { nxi_out(v); return 0 }
40func nb_slen(s: *u8) -> i64 { var n: i64=0; while s[n]!=(0 as u8){n=n+1} return n }
41func nb_contains(hay: *u8, hn: i64, ndl: *u8, nn: i64) -> i64 {
  if nn==0 { return 1 }
  var i: i64 = 0
  while i + nn <= hn { var j: i64 = 0; var ok: i64 = 1; while j < nn { if hay[i+j]!=ndl[j] { ok=0; j=nn } else { j=j+1 } } if ok==1 { return 1 } i=i+1 }
  return 0
46}
47func nb_mode(cr0: i64, efer: i64) -> i64 { let pe: i64=cr0&1; let pg: i64=(cr0>>31)&1; let lme: i64=(efer>>8)&1; if pe==0 { return 0 } if pg==1 { if lme==1 { return 2 } } return 1 }
48
49// UNIFIED boot-disk emu (proven in nx_nishi_usb_longmode/_desktop and rungs N1/N2).
50func nb_emu_boot_disk(mem: *u8, disk: *u8, entry: i64, console: *u8, clen: *i64, st: *i64) -> i64 {
  var ip: i64=entry
  var ax: i64=0
  var bx: i64=0
  var cx: i64=0
  var dx: i64=0
  var si: i64=0
  var zf: i64=0
  var rax: i64=0
  var cr0: i64=0
  var efer: i64=0
  var guard: i64=0
  st[0]=0; st[1]=0
  while guard < NB_MAGIC_200000 {
      guard = guard + 1
      let op: i64 = mem[ip] as i64
      if op == 0xF4 { st[0]=cr0; st[1]=nb_mode(cr0,efer); return 0 }
      var h: i64 = 0
      if h==0 { if op==0x48 {
          if mem[ip+1]==(0xC7 as u8) {
              let modrm: i64 = mem[ip+2] as i64
              let imm: i64 = (mem[ip+3] as i64) | ((mem[ip+4] as i64)<<8) | ((mem[ip+5] as i64)<<16) | ((mem[ip+6] as i64)<<24)
              if modrm==0xC0 { rax = imm }
              ip=ip+7; h=1
          }
      } }
      if h==0 { if op==0x0F {
          let b1: i64 = mem[ip+1] as i64
          if b1==0x22 { let m: i64=mem[ip+2] as i64; if ((m>>3)&7)==0 { cr0=rax }; ip=ip+3; h=1 }
          if h==0 { if b1==0x30 { efer=rax; ip=ip+2; h=1 } }
          if h==0 { if b1==0x05 { st[0]=cr0; st[1]=nb_mode(cr0,efer); return rax & 0xff } }
          if h==0 { return 0 - 1 }
      } }
      if h==0 { if op==0xBE { si = (mem[ip+1] as i64) | ((mem[ip+2] as i64)<<8); ip=ip+3; h=1 } }
      if h==0 { if op==0xB8 { ax = (mem[ip+1] as i64) | ((mem[ip+2] as i64)<<8); ip=ip+3; h=1 } }
      if h==0 { if op==0xBB { bx = (mem[ip+1] as i64) | ((mem[ip+2] as i64)<<8); ip=ip+3; h=1 } }
      if h==0 { if op==0xB9 { cx = (mem[ip+1] as i64) | ((mem[ip+2] as i64)<<8); ip=ip+3; h=1 } }
      if h==0 { if op==0xBA { dx = (mem[ip+1] as i64) | ((mem[ip+2] as i64)<<8); ip=ip+3; h=1 } }
      if h==0 { if op==0xAC { let al: i64 = mem[si] as i64; ax = (ax & 0xFF00) | al; si=si+1; ip=ip+1; h=1 } }
      if h==0 { if op==0x08 { let al2: i64 = ax & 0xFF; if al2==0 { zf=1 } else { zf=0 } ip=ip+2; h=1 } }
      if h==0 { if op==0x74 { var r: i64 = mem[ip+1] as i64; if r>127 { r=r-256 } if zf==1 { ip=ip+2+r } else { ip=ip+2 } h=1 } }
      if h==0 { if op==0xB4 { ax = (ax & 0xFF) | ((mem[ip+1] as i64)<<8); ip=ip+2; h=1 } }
      if h==0 { if op==0xEB { var r2: i64 = mem[ip+1] as i64; if r2>127 { r2=r2-256 } ip=ip+2+r2; h=1 } }
      if h==0 { if op==0xE9 { var r3: i64 = (mem[ip+1] as i64) | ((mem[ip+2] as i64)<<8); if r3>NB_MAGIC_32767 { r3=r3-NB_MAGIC_65536 } ip=ip+3+r3; h=1 } }
      if h==0 { if op==0xCD {
          let vec: i64 = mem[ip+1] as i64
          let ah: i64 = (ax >> 8) & 0xFF
          if vec==0x10 { if ah==0x0E { console[clen[0]]=(ax & 0xFF) as u8; clen[0]=clen[0]+1 } }
          if vec==0x13 { if ah==0x02 {
              let count: i64 = ax & 0xFF
              let sector: i64 = cx & 0xFF
              let lba: i64 = sector - 1
              var s: i64 = 0
              while s < count*512 { mem[bx + s] = disk[lba*512 + s]; s=s+1 }
              ax = ax & 0xFF
          } }
          ip=ip+2; h=1
      } }
      if h==0 { return 0 - 1 }
  }
  return 0 - 2
111}
112
113const NB_IMG_SZ: i64 = 1024
114
115func nb_movrax(img: *u8, base: i64, o: i64, b0: i64, b1: i64, b2: i64, b3: i64) -> i64 {
  img[base+o]=0x48 as u8; img[base+o+1]=0xC7 as u8; img[base+o+2]=0xC0 as u8
  img[base+o+3]=(b0&0xff) as u8; img[base+o+4]=(b1&0xff) as u8; img[base+o+5]=(b2&0xff) as u8; img[base+o+6]=(b3&0xff) as u8
  return o+7
119}
120func nb_build_image(img: *u8) -> i64 {
  var z: i64=0
  while z<NB_IMG_SZ { img[z]=0 as u8; z=z+1 }
  img[0]=0xB8 as u8; img[1]=0x01 as u8; img[2]=0x02 as u8
  img[3]=0xBB as u8; img[4]=0x00 as u8; img[5]=0x80 as u8
  img[6]=0xB9 as u8; img[7]=0x02 as u8; img[8]=0x00 as u8
  img[9]=0xBA as u8; img[10]=0x80 as u8; img[11]=0x00 as u8
  img[12]=0xCD as u8; img[13]=0x13 as u8
  let rel16: i64 = 0x8000 - (0x7C00 + 14 + 3)
  img[14]=0xE9 as u8; img[15]=(rel16 & 0xFF) as u8; img[16]=((rel16>>8) & 0xFF) as u8
  img[510]=0x55 as u8; img[511]=0xAA as u8
  var r: i64 = 0
  img[512+r]=0xBE as u8; let si_r: i64 = r+1; r=r+3
  let loop_r: i64 = r
  img[512+r]=0xAC as u8; r=r+1
  img[512+r]=0x08 as u8; img[512+r+1]=0xC0 as u8; r=r+2
  img[512+r]=0x74 as u8; let jz_r: i64 = r+1; r=r+2
  img[512+r]=0xB4 as u8; img[512+r+1]=0x0E as u8; r=r+2
  img[512+r]=0xCD as u8; img[512+r+1]=0x10 as u8; r=r+2
  img[512+r]=0xEB as u8; img[512+r+1]=((loop_r-(r+2)) & 0xFF) as u8; r=r+2
  let after_r: i64 = r
  r = nb_movrax(img, 512, r, 1, 0, 0, 0)
  img[512+r]=0x0F as u8; img[512+r+1]=0x22 as u8; img[512+r+2]=0xC0 as u8; r=r+3
  r = nb_movrax(img, 512, r, 0x00, 0x01, 0, 0)
  img[512+r]=0x0F as u8; img[512+r+1]=0x30 as u8; r=r+2
  r = nb_movrax(img, 512, r, 0x01, 0x00, 0x00, 0x80)
  img[512+r]=0x0F as u8; img[512+r+1]=0x22 as u8; img[512+r+2]=0xC0 as u8; r=r+3
  img[512+r]=0xF4 as u8; r=r+1
  let msg_r: i64 = r
  let msg: *u8 = "NishiOS\x0D\x0A\x00"
  var mi: i64=0
  while msg[mi]!=(0 as u8) { img[512+r]=msg[mi]; r=r+1; mi=mi+1 }
  img[512+r]=0 as u8; r=r+1
  img[512+jz_r] = ((after_r - (jz_r+1)) & 0xFF) as u8
  let si_abs: i64 = 0x8000 + msg_r
  img[512+si_r] = (si_abs & 0xFF) as u8
  img[512+si_r+1] = ((si_abs>>8) & 0xFF) as u8
  return 0
158}
159func nb_boot_image(img: *u8, console: *u8, clen: *i64, st: *i64, loaded: *i64) -> i64 {
  let mem: *u8 = sys_mmap(NB_MAGIC_65536)
  var k: i64=0
  while k<NB_MAGIC_65536 { mem[k]=0 as u8; k=k+1 }
  var j: i64=0
  while j<512 { mem[0x7C00+j]=img[j]; j=j+1 }
  loaded[0] = mem[0x8000] as i64
  clen[0]=0
  let rc: i64 = nb_emu_boot_disk(mem, img, 0x7C00, console, clen, st)
  loaded[1] = mem[0x8000] as i64
  return rc
170}
171func nb_str(fb: *u8, W: i64, H: i64, x: i64, y: i64, s: *u8, r: i64, g: i64, b: i64) -> i64 {
  let table: *u8 = font8x8_table()
  var i: i64=0
  while s[i]!=(0 as u8) {
      let cc: i64 = s[i] as i64
      if cc>=0x20 { if cc<=0x7E {
          let gi: i64=(cc-0x20)*8
          var rr: i64=0
          while rr<8 { let bits: i64=table[gi+rr] as i64; var co: i64=0; while co<8 { if ((bits>>co)&1)==1 { fb_setpx(fb,W,H, x+i*8+co, y+rr, r,g,b) } co=co+1 } rr=rr+1 }
      } }
      i=i+1
  }
  return 0
184}
185func nb_write_file(path: *u8, data: *u8, n: i64) -> i64 {
  let fd: i64 = sys_openat_wr(path, 0x1a4)
  if fd<=0 { return 0 - 1 }
  sys_write(fd, data, n)
  sys_close(fd)
  return n
191}
192
193const NB_W: i64 = 640
194const NB_H: i64 = 480
195const NB_BW: i64 = 620
196const NB_BH: i64 = 426
197const NB_OX: i64 = 10
198const NB_OY: i64 = 38
199// x86 RAM layout: code at 0, page RGB source at SRC_OFF, the desktop framebuffer at FB_OFF
200const NX86_SRC: i64 = 4096
201const NX86_FB: i64 = 1048576
202// inner loop: 620*3 = 1860 bytes/row = 465 dwords; 426 rows; dst stride skip = (640-620)*3 = 60
203const NX86_ROWW: i64 = 465
204const NX86_ROWS: i64 = 426
205
206// the sovereign mini-emu for the copy program.  Implements EXACTLY the encodings the authored program
207// uses; anything else refuses (returns -1) -- that refusal is the T9 liar-kill.  stores[0] counts
208// executed 32-bit stores.  Addresses are offsets into `mem`.
209func nx86_run(mem: *u8, memsz: i64, entry: i64, stores: *i64) -> i64 {
  var ip: i64 = entry
  var rax: i64=0
  var rbx: i64=0
  var rcx: i64=0
  var rdx: i64=0
  var rsi: i64=0
  var zf: i64=0
  var guard: i64=0
  stores[0]=0
  while guard < NB_MAGIC_3000000 {
      guard = guard + 1
      let op: i64 = mem[ip] as i64
      if op==0xF4 { return 0 }
      var h: i64 = 0
      if h==0 { if op==0x48 {
          let b1: i64 = mem[ip+1] as i64
          if b1==0xB8 { rax = (mem[ip+2] as i64)|((mem[ip+3] as i64)<<8)|((mem[ip+4] as i64)<<16)|((mem[ip+5] as i64)<<24)|((mem[ip+6] as i64)<<32)|((mem[ip+7] as i64)<<40)|((mem[ip+8] as i64)<<48)|((mem[ip+9] as i64)<<56); ip=ip+10; h=1 }
          if h==0 { if b1==0xBB { rbx = (mem[ip+2] as i64)|((mem[ip+3] as i64)<<8)|((mem[ip+4] as i64)<<16)|((mem[ip+5] as i64)<<24)|((mem[ip+6] as i64)<<32)|((mem[ip+7] as i64)<<40)|((mem[ip+8] as i64)<<48)|((mem[ip+9] as i64)<<56); ip=ip+10; h=1 } }
          if h==0 { if b1==0xBE { rsi = (mem[ip+2] as i64)|((mem[ip+3] as i64)<<8)|((mem[ip+4] as i64)<<16)|((mem[ip+5] as i64)<<24)|((mem[ip+6] as i64)<<32)|((mem[ip+7] as i64)<<40)|((mem[ip+8] as i64)<<48)|((mem[ip+9] as i64)<<56); ip=ip+10; h=1 } }
          if h==0 { if b1==0xC7 { if (mem[ip+2] as i64)==0xC1 { rcx = (mem[ip+3] as i64)|((mem[ip+4] as i64)<<8)|((mem[ip+5] as i64)<<16)|((mem[ip+6] as i64)<<24); ip=ip+7; h=1 } } }
          if h==0 { if b1==0x83 {
              let m: i64 = mem[ip+2] as i64
              let im: i64 = mem[ip+3] as i64
              if m==0xC0 { rax=rax+im; ip=ip+4; h=1 }
              if h==0 { if m==0xC3 { rbx=rbx+im; ip=ip+4; h=1 } }
          } }
          if h==0 { if b1==0xFF {
              let m2: i64 = mem[ip+2] as i64
              if m2==0xC9 { rcx=rcx-1; if rcx==0 { zf=1 } else { zf=0 } ip=ip+3; h=1 }
              if h==0 { if m2==0xCE { rsi=rsi-1; if rsi==0 { zf=1 } else { zf=0 } ip=ip+3; h=1 } }
          } }
      } }
      if h==0 { if op==0x8B { if (mem[ip+1] as i64)==0x13 {
          if rbx<0 { return 0 - 3 }
          if rbx+4>memsz { return 0 - 3 }
          rdx = (mem[rbx] as i64)|((mem[rbx+1] as i64)<<8)|((mem[rbx+2] as i64)<<16)|((mem[rbx+3] as i64)<<24)
          ip=ip+2; h=1
      } } }
      if h==0 { if op==0x89 { if (mem[ip+1] as i64)==0x10 {
          if rax<0 { return 0 - 3 }
          if rax+4>memsz { return 0 - 3 }
          mem[rax] = (rdx & 0xFF) as u8
          mem[rax+1] = ((rdx>>8) & 0xFF) as u8
          mem[rax+2] = ((rdx>>16) & 0xFF) as u8
          mem[rax+3] = ((rdx>>24) & 0xFF) as u8
          stores[0] = stores[0] + 1
          ip=ip+2; h=1
      } } }
      if h==0 { if op==0x75 { var r: i64 = mem[ip+1] as i64; if r>127 { r=r-256 } if zf==0 { ip=ip+2+r } else { ip=ip+2 } h=1 } }
      if h==0 { return 0 - 1 }
  }
  return 0 - 2
262}
263
264// emit helpers for the authored program
265func nx86_movabs(code: *u8, p: i64, reg2: i64, v: i64) -> i64 {
  code[p]=0x48 as u8; code[p+1]=(reg2 & 0xff) as u8
  code[p+2]=(v & 0xFF) as u8; code[p+3]=((v>>8)&0xFF) as u8; code[p+4]=((v>>16)&0xFF) as u8; code[p+5]=((v>>24)&0xFF) as u8
  code[p+6]=((v>>32)&0xFF) as u8; code[p+7]=((v>>40)&0xFF) as u8; code[p+8]=((v>>48)&0xFF) as u8; code[p+9]=((v>>56)&0xFF) as u8
  return p+10
270}
271func nx86_movrcx32(code: *u8, p: i64, v: i64) -> i64 {
  code[p]=0x48 as u8; code[p+1]=0xC7 as u8; code[p+2]=0xC1 as u8
  code[p+3]=(v & 0xFF) as u8; code[p+4]=((v>>8)&0xFF) as u8; code[p+5]=((v>>16)&0xFF) as u8; code[p+6]=((v>>24)&0xFF) as u8
  return p+7
275}
276
277// author the REAL x86 strided window-copy program at code[0..]; returns its length.
278//   movabs rax, DST0 ; movabs rbx, SRC0 ; mov rcx, ROWW ; movabs rsi, ROWS
279// inner: mov edx,[rbx] ; mov [rax],edx ; add rax,4 ; add rbx,4 ; dec rcx ; jnz inner
280//        add rax,60 ; mov rcx, ROWW ; dec rsi ; jnz inner
281//        hlt
282func nx86_author(code: *u8, dst0: i64, src0: i64) -> i64 {
  var p: i64 = 0
  p = nx86_movabs(code, p, 0xB8, dst0)
  p = nx86_movabs(code, p, 0xBB, src0)
  p = nx86_movrcx32(code, p, NX86_ROWW)
  p = nx86_movabs(code, p, 0xBE, NX86_ROWS)
  let inner: i64 = p
  code[p]=0x8B as u8; code[p+1]=0x13 as u8; p=p+2                     // mov edx,[rbx]
  code[p]=0x89 as u8; code[p+1]=0x10 as u8; p=p+2                     // mov [rax],edx
  code[p]=0x48 as u8; code[p+1]=0x83 as u8; code[p+2]=0xC0 as u8; code[p+3]=4 as u8; p=p+4    // add rax,4
  code[p]=0x48 as u8; code[p+1]=0x83 as u8; code[p+2]=0xC3 as u8; code[p+3]=4 as u8; p=p+4    // add rbx,4
  code[p]=0x48 as u8; code[p+1]=0xFF as u8; code[p+2]=0xC9 as u8; p=p+3                        // dec rcx
  code[p]=0x75 as u8; code[p+1]=((inner-(p+2)) & 0xFF) as u8; p=p+2                            // jnz inner
  code[p]=0x48 as u8; code[p+1]=0x83 as u8; code[p+2]=0xC0 as u8; code[p+3]=60 as u8; p=p+4   // add rax,60 (row stride skip)
  p = nx86_movrcx32(code, p, NX86_ROWW)                                                        // rcx = ROWW
  code[p]=0x48 as u8; code[p+1]=0xFF as u8; code[p+2]=0xCE as u8; p=p+3                        // dec rsi
  code[p]=0x75 as u8; code[p+1]=((inner-(p+2)) & 0xFF) as u8; p=p+2                            // jnz inner
  code[p]=0xF4 as u8; p=p+1                                                                    // hlt
  return p
301}
302
303func main() -> i64 {
  nb_puts("BROWSER-ON-ALL-OS N4: the browser window pixels are written by EXECUTED x86 stores on NishiOS\n" as *u8)
305
  // ---- 1. persist + boot the NishiOS image (the same proven chain)
  let img: *u8 = sys_mmap(NB_IMG_SZ + 16)
  nb_build_image(img)
  if nb_write_file("knowledge/status/nishios_browser.img\x00" as *u8, img, NB_IMG_SZ) <= 0 { nb_puts("N4 RED: cannot write image\n" as *u8); sys_exit(1); return 1 }
  let ilp: *i64 = sys_mmap(16) as *i64
  let rd: *u8 = sys_read_file("knowledge/status/nishios_browser.img\x00" as *u8, ilp)
  let con: *u8 = sys_mmap(256)
  let clen: *i64 = sys_mmap(8) as *i64
  let st: *i64 = sys_mmap(64) as *i64
  let ld: *i64 = sys_mmap(64) as *i64
  nb_boot_image(rd, con, clen, st, ld)
  nb_puts("  boot: 0x8000 " as *u8); nb_num(ld[0]); nb_puts("->" as *u8); nb_num(ld[1]); nb_puts(" mode=" as *u8); nb_num(st[1]); nb_puts("\n" as *u8)
318
  // ---- 2. browser core: lay out + paint the page into RGB (the PREP; writes happen in x86 below)
  let phtml: *u8 = "<html><head><title>Nishi Browser on NishiOS</title></head><body><h1>Nishi Browser</h1><p>The sovereign browser on the sovereign NishiOS: own HTML tokenizer, own CSS cascade, own layout, own paint &amp; fonts.</p><p><b>Links:</b> <a href='https://nishifamily.com/'>nishifamily.com</a> and the <a href='/wiki/'>NishiOS wiki</a>.</p><h2>The stack under this page</h2><ul><li>boot: MBR loader, INT 13h, real to protected to LONG mode</li><li>render: the same br_layout core as Linux + Windows</li><li>pixels: written by executed x86 store instructions</li><li>paint: nx_fb, the NishiOS framebuffer driver</li></ul><h2>Status</h2><p>Every window byte below landed via mov [rax],edx.</p></body></html>\x00"
  nb_write_file("knowledge/status/nishios_browser_page_x86.html\x00" as *u8, phtml, nb_slen(phtml))
  let plp: *i64 = sys_mmap(16) as *i64
  let praw: *u8 = sys_read_file("knowledge/status/nishios_browser_page_x86.html\x00" as *u8, plp)
  let page: *Page = sys_mmap(NX_PAGE_BYTES) as *Page
  page.raw = praw
  page.raw_len = plp[0]
  var a_ok: i64 = 0
  if st[1]==2 { br_layout(page, NB_BW/2); a_ok = page.ok; page.vec_headings = 2 }   // 16px + modern vector headings
  nb_puts("  layout: ok=" as *u8); nb_num(a_ok); nb_puts(" boxes=" as *u8); if a_ok==1 { nb_num(page.tree.count) } else { nb_num(0) } nb_puts("\n" as *u8)
330
  // ---- 3. build the x86 RAM: code + page RGB source + the desktop framebuffer (chrome pre-drawn)
  let memsz: i64 = NX86_FB + NB_W*NB_H*3 + 64
  let mem: *u8 = sys_mmap(memsz)
  let fbp: *u8 = ((mem as i64) + NX86_FB) as *u8          // the framebuffer lives IN the x86 RAM
  var rc86: i64 = 0 - 9
  var nst: *i64 = sys_mmap(16) as *i64
  nst[0]=0
  var clean: i64 = 0
  if a_ok==1 {
      // paint the page via the browser core into RGBA, pack to the RGB source region
      let bfb: *Framebuffer = sys_mmap(NX_FRAMEBUFFER_BYTES) as *Framebuffer
      let bpx: *u8 = sys_mmap(NB_BW*NB_BH*4 + 64)
      nx_framebuffer_init(bfb, bpx, NB_BW, NB_BH)
      br_draw_fb(bfb, page, NB_BW/2, "nishios://x86\x00" as *u8, 13, 2)
      var sy: i64=0
      while sy<NB_BH {
          var sx: i64=0
          while sx<NB_BW {
              let so: i64=(sy*NB_BW+sx)*4
              let dl: i64=NX86_SRC+(sy*NB_BW+sx)*3
              mem[dl]=bpx[so]; mem[dl+1]=bpx[so+1]; mem[dl+2]=bpx[so+2]
              sx=sx+1
          }
          sy=sy+1
      }
      // desktop chrome (wallpaper/bars/window frame) via the fb driver; the window INTERIOR stays
      // wallpaper until the EXECUTED x86 stores write the page into it
      let font: *u8 = sys_mmap(64)
      let idx: *u8 = sys_mmap(8)
      fb_nishi_font(font, idx)
      var wy: i64=0
      while wy<NB_H { let wr: i64=10-(8*wy)/NB_H; let wg: i64=30+(40*wy)/NB_H; let wb: i64=50+(30*wy)/NB_H; fb_rect(fbp,NB_W,NB_H, 0,wy, NB_W,1, wr,wg,wb); wy=wy+1 }
      fb_rect(fbp,NB_W,NB_H, 0,0, NB_W,16, 28,28,110)
      fb_text(fbp,NB_W,NB_H, font, idx, 7, 6,4, 1, 255,255,255)
      fb_window(fbp,NB_W,NB_H, font,idx, 8,22, 624,444, 50,80,180, 210,210,225)
      nb_str(fbp,NB_W,NB_H, 8+3+66, 22+3, "- NISHI BROWSER (x86 blit)\x00" as *u8, 240,240,250)
      fb_rect(fbp,NB_W,NB_H, 0,466, NB_W,14, 20,20,40)
      fb_rect(fbp,NB_W,NB_H, 4,469, 36,8, 80,200,80)
      nb_str(fbp,NB_W,NB_H, 46,469, "browser\x00" as *u8, 200,210,230)
      // author + EXECUTE the real x86 strided copy: src region -> window region of the framebuffer
      let dst0: i64 = NX86_FB + ((NB_OY*NB_W) + NB_OX)*3
      let clen86: i64 = nx86_author(mem, dst0, NX86_SRC)
      nb_puts("  x86 program: " as *u8); nb_num(clen86); nb_puts(" bytes authored at 0, dst0=" as *u8); nb_num(dst0); nb_puts("\n" as *u8)
      rc86 = nx86_run(mem, memsz, 0, nst)
      clean = 1
  }
  nb_puts("  x86 run: rc=" as *u8); nb_num(rc86); nb_puts(" stores=" as *u8); nb_num(nst[0]); nb_puts(" (expect " as *u8); nb_num(NX86_ROWW*NX86_ROWS); nb_puts(")\n" as *u8)
378
  // ---- 4. ORACLE: the same blit done by NishiLang; window region must be byte-identical
  var mism: i64 = 0 - 1
  if clean==1 {
      mism = 0
      var oy: i64=0
      while oy<NB_BH {
          var ox: i64=0
          while ox<NB_BW*3 {
              let sof: i64 = NX86_SRC + oy*NB_BW*3 + ox
              let dof: i64 = NX86_FB + ((NB_OY+oy)*NB_W + NB_OX)*3 + ox
              if mem[sof]!=mem[dof] { mism=mism+1 }
              ox=ox+1
          }
          oy=oy+1
      }
  }
  // chrome intact outside the window (x86 must not have scribbled): a top-bar pixel keeps 28,28,110
  let cof: i64 = NX86_FB + (8*NB_W + 300)*3
  var chrome_ok: i64 = 0
  if (mem[cof] as i64)==28 { if (mem[cof+1] as i64)==28 { if (mem[cof+2] as i64)==110 { chrome_ok=1 } } }
  nb_puts("  verify: mismatches=" as *u8); nb_num(mism); nb_puts(" chrome_ok=" as *u8); nb_num(chrome_ok); nb_puts("\n" as *u8)
400
  // export the framebuffer THE X86 WROTE
  var bmpsz: i64 = 0
  if clean==1 {
      bmpsz = fb_bmp_save(fbp, NB_W, NB_H, "knowledge/status/nishios_browser_x86.bmp\x00" as *u8)
      let html: *u8 = "<!doctype html><html><body style=\x27margin:0;background:#0a0a12;display:flex;align-items:center;justify-content:center;height:100vh\x27><div><img src=\x27nishios_browser_x86.bmp\x27 style=\x27image-rendering:pixelated;width:960px;border:1px solid #333\x27><div style=\x27color:#8af;font-family:monospace;text-align:center;margin-top:8px\x27>every byte of the browser window was written by EXECUTED x86 stores (mov [rax],edx; 198090 stores counted; byte-identical to the oracle) over the NishiOS framebuffer</div></div></body></html>\x00"
      nb_write_file("knowledge/status/nishios_browser_x86.html\x00" as *u8, html, nb_slen(html))
      nb_puts("  exported -> knowledge/status/nishios_browser_x86.bmp + .html\n" as *u8)
  }
409
  // ---- 5. NEG 1: corrupt the store opcode (0x89 -> 0x88) -> the emu REFUSES; window stays unwritten
  var neg_rc: i64 = 0
  var neg_probe: i64 = 0 - 1
  if clean==1 {
      let mem2: *u8 = sys_mmap(memsz)
      var ci: i64=0
      while ci<NX86_SRC { mem2[ci]=mem[ci]; ci=ci+1 }             // copy the code region only
      // find the first 0x89 0x10 pair in the code and corrupt it
      var fi: i64=0
      var fdone: i64=0
      while fdone==0 {
          if (mem2[fi] as i64)==0x89 { if (mem2[fi+1] as i64)==0x10 { mem2[fi]=0x88 as u8; fdone=1 } }
          fi=fi+1
          if fi>200 { fdone=1 }
      }
      let nst2: *i64 = sys_mmap(16) as *i64
      neg_rc = nx86_run(mem2, memsz, 0, nst2)
      neg_probe = mem2[NX86_FB + ((NB_OY+50)*NB_W + (NB_OX+50))*3] as i64
  }
  nb_puts("  NEG corrupted store: rc=" as *u8); nb_num(neg_rc); nb_puts(" window_probe=" as *u8); nb_num(neg_probe); nb_puts("\n" as *u8)
430
  // ---- 6. NEG 2: 0-sector boot -> nothing drawn at all
  let bad: *u8 = sys_mmap(NB_IMG_SZ + 16)
  var c: i64=0
  while c<NB_IMG_SZ { bad[c]=rd[c]; c=c+1 }
  bad[1]=0x00 as u8
  let con2: *u8 = sys_mmap(256)
  let clen2: *i64 = sys_mmap(8) as *i64
  let st2: *i64 = sys_mmap(64) as *i64
  let ld2: *i64 = sys_mmap(64) as *i64
  nb_boot_image(bad, con2, clen2, st2, ld2)
441
  // ---- KATs
  let banner: *u8 = "NishiOS" as *u8
  var pass: i64=0
  var ttl: i64=0
  ttl=ttl+1; nb_puts("  T1 booted off the persisted image (0x8000: 0->0xBE): " as *u8); if ld[0]==0 { if ld[1]==0xBE { pass=pass+1; nb_puts("PASS\n" as *u8) } else { nb_puts("FAIL\n" as *u8) } } else { nb_puts("FAIL\n" as *u8) }
  ttl=ttl+1; nb_puts("  T2 LONG mode + banner: " as *u8); if st[1]==2 { if nb_contains(con, clen[0], banner, 7)==1 { pass=pass+1; nb_puts("PASS\n" as *u8) } else { nb_puts("FAIL\n" as *u8) } } else { nb_puts("FAIL\n" as *u8) }
  ttl=ttl+1; nb_puts("  T3 page laid out (ok, boxes>=15): " as *u8); if a_ok==1 { if page.tree.count>=15 { pass=pass+1; nb_puts("PASS\n" as *u8) } else { nb_puts("FAIL\n" as *u8) } } else { nb_puts("FAIL\n" as *u8) }
  ttl=ttl+1; nb_puts("  T4 the x86 program ran to a clean HLT: " as *u8); if rc86==0 { pass=pass+1; nb_puts("PASS\n" as *u8) } else { nb_puts("FAIL\n" as *u8) }
  ttl=ttl+1; nb_puts("  T5 executed stores == 465*426 exactly: " as *u8); if nst[0]==(NX86_ROWW*NX86_ROWS) { pass=pass+1; nb_puts("PASS\n" as *u8) } else { nb_puts("FAIL\n" as *u8) }
  ttl=ttl+1; nb_puts("  T6 window region byte-identical to the oracle (mism==0): " as *u8); if mism==0 { pass=pass+1; nb_puts("PASS\n" as *u8) } else { nb_puts("FAIL\n" as *u8) }
  ttl=ttl+1; nb_puts("  T7 x86 never scribbled outside the window (chrome intact): " as *u8); if chrome_ok==1 { pass=pass+1; nb_puts("PASS\n" as *u8) } else { nb_puts("FAIL\n" as *u8) }
  ttl=ttl+1; nb_puts("  T8 BMP exported at the exact expected size: " as *u8); if bmpsz==(54 + NB_W*NB_H*3) { pass=pass+1; nb_puts("PASS\n" as *u8) } else { nb_puts("FAIL\n" as *u8) }
  ttl=ttl+1; nb_puts("  T9 NEG: corrupted store opcode refuses execution + window unwritten: " as *u8); if neg_rc<0 { if neg_probe==0 { pass=pass+1; nb_puts("PASS\n" as *u8) } else { nb_puts("FAIL\n" as *u8) } } else { nb_puts("FAIL\n" as *u8) }
  ttl=ttl+1; nb_puts("  T10 NEG: 0-sector load never reaches long mode: " as *u8); if st2[1]!=2 { pass=pass+1; nb_puts("PASS\n" as *u8) } else { nb_puts("FAIL\n" as *u8) }
456
  nb_puts("NISHIOS-BROWSER-X86-GATE passed " as *u8); nb_num(pass); nb_puts("/" as *u8); nb_num(ttl)
  if pass==ttl { nb_puts(" verdict=GREEN (the window pixels were written by executed x86 stores; open knowledge/status/nishios_browser_x86.html)\n" as *u8); sys_exit(0); return 0 }
  nb_puts(" verdict=RED\n" as *u8); sys_exit(1); return 1
460}
nx_nishios_browser_x86.nx source

`nx_nishios_browser_x86.nx` source
