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

↩ module page · 483 lines · 20109 B
1// nx_netsync_gate.nx -- CERTIFICATION of nx_netsync (gamebench gap-queue rank 1: networking-multiplayer).
2// The existing nx_lockstep/nx_rollback gates prove netcode mechanisms on a TOY stepper; this gate proves
3// the same laws hold when the simulation is the REAL certified world (nx_worldsim) and the snapshots are
4// REAL save files (nx_gamesave) -- the composition the capability actually demands.
5//   T1 LOCKSTEP DETERMINISM -- two peers, same commands, different within-tick arrival order,
6//      200 ticks -> checksums equal EVERY tick and shared state word-exact
7//   T2 STALL-NOT-GUESS -- missing one peer's input for a tick freezes the session (no advance, no state
8//      change) until it arrives; advancing on partial input is THE lockstep desync bug
9//   T3 ARRIVAL-CHAOS IMMUNE -- the full 400-command schedule delivered in a shuffled order with
10//      duplicates -> final state EXACTLY equals the in-order run; a conflicting resend is REFUSED
11//   T4 DESYNC LOCALIZED -- a 1-unit wealth mint injected into one peer at tick 120 is first visible in
12//      the checksum stream AT tick 120 (never earlier, never missed)
13//   T5 ROLLBACK ON THE REAL SIM -- speculative head with predicted inputs diverges when the prediction
14//      was wrong; discard + resim from the confirmed state converges bit-exact to ground truth; a
15//      CORRECT prediction triggers no divergence (no false rollback)
16//   T6 LATE-JOIN VIA nx_gamesave -- a peer that loads a mid-session snapshot file into a ZEROED arena
17//      tracks the original checksum-for-checksum to the end (GX-9 transparency)
18//   T7 BOUNDED + LOUD -- out-of-range tick/peer and conflicting input each refuse with a DISTINCT code
19//      and change nothing
20//   T8 ANTI-VACUITY -- the session actually traded and grew (a frozen or all-no-op world would pass
21//      T1-T3 while proving nothing)
22//   T9 ARTIFACT -- the final session round-trips through a real save file and RESUMES identically;
23//      knowledge/nx_netsync_session.sav is the board evidence
24// license_tier: ORIGINAL  expect_exit: 0
25import "nx_syscalls.nx"
26import "nx_netsync.nx"
27import "nx_gamesave.nx"
28import "nx_net_chan.nx"
29const K_MAGIC_25214903917: i64 = 25214903917
30const K_MAGIC_2654435761: i64 = 2654435761
31const K_MAGIC_100000000: i64 = 100000000
32const K_MAGIC_1000000: i64 = 1000000
33const K_MAGIC_4242: i64 = 4242
34const K_MAGIC_20260730: i64 = 20260730
35const K_MAGIC_60621: i64 = 60621
36const K_MAGIC_1785425000: i64 = 1785425000
37const K_MAGIC_9750: i64 = 9750
38const K_MAGIC_60620: i64 = 60620
39const K_MAGIC_38921: i64 = 38921
40const K_MAGIC_31337: i64 = 31337
41
42func pw(s: *u8) -> i64 { var n: i64=0; while s[n]!=(0 as u8){n=n+1} sys_write(1,s,n); return 0 }
43func pn(v: i64) -> i64 {
  if v==0 { sys_write(1,"0" as *u8,1); return 0 }
  var m: i64=v; if m<0 { sys_write(1,"-" as *u8,1); m=0-m }
  let t: *u8=sys_mmap(32); var k: i64=0
  while m>0 { t[k]=(48+(m%10)) as u8; m=m/10; k=k+1 }
  let o: *u8=sys_mmap(32); var q: i64=k-1; var i: i64=0
  while q>=0 { o[i]=t[q]; i=i+1; q=q-1 }
  sys_write(1,o,i); return 0
51}
52func lcg(s: *i64) -> i64 { s[0] = ((s[0]*K_MAGIC_25214903917)+11) & 0x7FFFFFFFFFFF; return s[0] }
53
54// the deterministic command schedule -- a pure function of (tick,peer), so every session in this gate
55// independently derives the same "player decisions". ~3/4 of commands are real trade orders.
56func cmd_for(t: i64, p: i64) -> i64 {
  var x: i64 = t*31 + p*17 + 7
  x = (x * K_MAGIC_2654435761) & 0x7FFFFFFFFFFFFFFF
  if x % 4 == 0 { return 0 }
  let from: i64 = x % 6
  var to: i64 = (x / 7) % 6
  if to == from { to = (to + 1) % 6 }
  let amt: i64 = 100 + ((x / 49) % 300)
  return from*K_MAGIC_100000000 + to*K_MAGIC_1000000 + amt
65}
66
67const GMAXT: i64 = 300
68const GNFAC: i64 = 6
69// 2 peers, 300 tick capacity, 6 factions
70func mksess(a: *i64, self_id: i64, seed: i64) -> i64 {
  ns_init(a, 2, self_id, GMAXT, GNFAC, seed)
  let w: *i64 = ns_world(a)
  var i: i64 = 0
  while i < GNFAC {
      ws_set_res(w, i, 1000 + i*250)
      ws_set_pop(w, i, 500 + i*100)
      ws_set_terr(w, i, 3 + i)
      i = i + 1
  }
  return 0
81}
82
83func main() -> i64 {
  pw("=== nx_netsync_gate: is multiplayer netcode safe to build on the certified parts? ===\n\n")
  var pass: i64 = 0
  var checks: i64 = 0
  let W: i64 = ns_words(2, GMAXT, GNFAC)
  let AP: *u8 = "knowledge/nx_netsync_session.sav" as *u8
  let JP: *u8 = "knowledge/nx_netsync_join.sav" as *u8
  // start clean -- both artifacts must be REGENERATED by this run
  sys_unlinkat(AP)
  sys_unlinkat(JP)
93
  // ---------- T1 lockstep determinism on the real sim ----------
  checks = checks + 1
  let A: *i64 = sys_mmap(W*8) as *i64
  let B: *i64 = sys_mmap(W*8) as *i64
  mksess(A, 0, K_MAGIC_4242)
  mksess(B, 1, K_MAGIC_4242)
  var ckok: i64 = 1
  var t: i64 = 0
  while t < 200 {
      ns_offer(A, t, 0, cmd_for(t,0)); ns_offer(A, t, 1, cmd_for(t,1))
      ns_offer(B, t, 1, cmd_for(t,1)); ns_offer(B, t, 0, cmd_for(t,0))
      ns_step(A, 4); ns_step(B, 4)
      if ns_checksum(A) != ns_checksum(B) { ckok = 0 }
      t = t + 1
  }
  var t1: i64 = 0
  if ckok==1 { if ns_shared_eq(A,B)==1 { if ns_tick(A)==200 { t1=1 } } }
  if t1==1 {
      pw("T1 GREEN lockstep deterministic: 2 peers, 200 ticks, different arrival order -> checksum equal every tick, shared state word-exact (ck=")
      pn(ns_checksum(A)); pw(")\n"); pass=pass+1
  } else { pw("T1 RED   peers diverged: ckok="); pn(ckok); pw(" tick="); pn(ns_tick(A)); pw("\n") }
115
  // ---------- T2 stall-not-guess ----------
  checks = checks + 1
  let S: *i64 = sys_mmap(W*8) as *i64
  mksess(S, 0, 777)
  t = 0
  while t < 50 {
      ns_offer(S, t, 0, cmd_for(t,0)); ns_offer(S, t, 1, cmd_for(t,1))
      t = t + 1
  }
  ns_offer(S, 50, 0, cmd_for(50,0))
  while ns_step(S, 4)==1 {}
  let stick: i64 = ns_tick(S)
  let sck: i64 = ns_checksum(S)
  let z1: i64 = ns_step(S, 4)
  let z2: i64 = ns_step(S, 4)
  var t2: i64 = 0
  if stick==50 { if z1==0 { if z2==0 { if ns_checksum(S)==sck {
      ns_offer(S, 50, 1, cmd_for(50,1))
      if ns_step(S, 4)==1 { if ns_tick(S)==51 { t2=1 } }
  } } } }
  if t2==1 {
      pw("T2 GREEN stalls-not-guesses: missing peer-1 input froze tick at 50 (2 step attempts, state untouched); arrival unfroze to 51\n")
      pass=pass+1
  } else { pw("T2 RED   advanced on partial input: tick="); pn(stick); pw("\n") }
140
  // ---------- T3 arrival-chaos immune ----------
  checks = checks + 1
  let list: *i64 = sys_mmap(400*8) as *i64
  var i: i64 = 0
  while i < 400 { list[i]=i; i=i+1 }
  let rs: *i64 = sys_mmap(8) as *i64
  rs[0] = K_MAGIC_20260730
  i = 399
  while i > 0 {
      let j: i64 = lcg(rs) % (i+1)
      let tmp: i64 = list[i]; list[i]=list[j]; list[j]=tmp
      i = i - 1
  }
  let C: *i64 = sys_mmap(W*8) as *i64
  mksess(C, 0, K_MAGIC_4242)
  var acc: i64 = 0
  var dup: i64 = 0
  i = 0
  while i < 400 {
      let k: i64 = list[i]
      let kt: i64 = k / 2
      let kp: i64 = k % 2
      let rc: i64 = ns_offer(C, kt, kp, cmd_for(kt,kp))
      if rc==1 { acc = acc + 1 }
      if i % 8 == 0 {
          let rc2: i64 = ns_offer(C, kt, kp, cmd_for(kt,kp))
          if rc2==0 { dup = dup + 1 }
      }
      while ns_step(C, 4)==1 {}
      i = i + 1
  }
  let ck3: i64 = ns_checksum(C)
  let rcx: i64 = ns_offer(C, 10, 0, cmd_for(10,0)+1)
  var t3: i64 = 0
  if ns_tick(C)==200 { if ns_shared_eq(C,A)==1 { if acc==400 { if dup==50 {
      if rcx==NS_E_CONFLICT { if ns_checksum(C)==ck3 { t3=1 } } } } } }
  if t3==1 {
      pw("T3 GREEN chaos immune: 400 commands shuffled + 50 duplicates -> identical to in-order run; conflicting resend REFUSED, state untouched\n")
      pass=pass+1
  } else {
      pw("T3 RED   chaos diverged: tick="); pn(ns_tick(C)); pw(" eq="); pn(ns_shared_eq(C,A))
      pw(" acc="); pn(acc); pw(" dup="); pn(dup); pw(" rcx="); pn(rcx); pw("\n")
  }
184
  // ---------- T4 desync localized to the exact tick ----------
  checks = checks + 1
  let A2: *i64 = sys_mmap(W*8) as *i64
  let B2: *i64 = sys_mmap(W*8) as *i64
  mksess(A2, 0, 999)
  mksess(B2, 1, 999)
  var first_diff: i64 = 0-1
  t = 0
  while t < 200 {
      if t==120 {
          let wc: *i64 = ns_world(B2)
          wc[ws_o_res(wc)+0] = wc[ws_o_res(wc)+0] + 1
      }
      ns_offer(A2, t, 0, cmd_for(t,0)); ns_offer(A2, t, 1, cmd_for(t,1))
      ns_offer(B2, t, 0, cmd_for(t,0)); ns_offer(B2, t, 1, cmd_for(t,1))
      ns_step(A2, 4); ns_step(B2, 4)
      if ns_checksum(A2) != ns_checksum(B2) { if first_diff < 0 { first_diff = t } }
      t = t + 1
  }
  let mint: i64 = ws_total_res(ns_world(B2)) - ws_total_res(ns_world(A2))
  var t4: i64 = 0
  if first_diff==120 { if mint==1 { t4=1 } }
  if t4==1 {
      pw("T4 GREEN desync localized: 1-unit mint at tick 120 first flagged AT tick 120 (0 false positives before), audit shows exactly +"); pn(mint); pw(" phantom unit\n")
      pass=pass+1
  } else { pw("T4 RED   first_diff="); pn(first_diff); pw(" mint="); pn(mint); pw("\n") }
211
  // ---------- T5 rollback on the real sim ----------
  checks = checks + 1
  var TK: i64 = 250
  while cmd_for(TK,1)==0 { TK = TK + 1 }
  let GT: *i64 = sys_mmap(W*8) as *i64
  mksess(GT, 0, 555)
  t = 0
  while t < TK+3 {
      ns_offer(GT, t, 0, cmd_for(t,0)); ns_offer(GT, t, 1, cmd_for(t,1))
      ns_step(GT, 4)
      t = t + 1
  }
  let P: *i64 = sys_mmap(W*8) as *i64
  mksess(P, 0, 555)
  t = 0
  while t < TK {
      ns_offer(P, t, 0, cmd_for(t,0)); ns_offer(P, t, 1, cmd_for(t,1))
      ns_step(P, 4)
      t = t + 1
  }
  let H: *i64 = sys_mmap(W*8) as *i64
  ns_copy(H, P, W)
  t = TK
  while t < TK+3 {
      ns_offer(H, t, 0, cmd_for(t,0))
      ns_offer(H, t, 1, 0)
      ns_step(H, 4)
      t = t + 1
  }
  var mispred: i64 = 0
  if cmd_for(TK,1) != 0 { mispred = 1 }
  var hdiv: i64 = 0
  if ns_shared_eq(H, GT)==0 { hdiv = 1 }
  t = TK
  while t < TK+3 {
      ns_offer(P, t, 0, cmd_for(t,0)); ns_offer(P, t, 1, cmd_for(t,1))
      ns_step(P, 4)
      t = t + 1
  }
  let conv: i64 = ns_shared_eq(P, GT)
  var TK2: i64 = 250
  while cmd_for(TK2,1)!=0 { TK2 = TK2 + 1 }
  let G2: *i64 = sys_mmap(W*8) as *i64
  mksess(G2, 0, 555)
  t = 0
  while t < TK2 {
      ns_offer(G2, t, 0, cmd_for(t,0)); ns_offer(G2, t, 1, cmd_for(t,1))
      ns_step(G2, 4)
      t = t + 1
  }
  let H2: *i64 = sys_mmap(W*8) as *i64
  ns_copy(H2, G2, W)
  ns_offer(H2, TK2, 0, cmd_for(TK2,0)); ns_offer(H2, TK2, 1, 0)
  ns_step(H2, 4)
  ns_offer(G2, TK2, 0, cmd_for(TK2,0)); ns_offer(G2, TK2, 1, cmd_for(TK2,1))
  ns_step(G2, 4)
  let nofalse: i64 = ns_shared_eq(H2, G2)
  var t5: i64 = 0
  if mispred==1 { if hdiv==1 { if conv==1 { if nofalse==1 { t5=1 } } } }
  if t5==1 {
      pw("T5 GREEN rollback converges: wrong prediction at tick "); pn(TK)
      pw(" diverged the speculative head; resim from confirmed state == ground truth bit-exact; correct prediction (tick ")
      pn(TK2); pw(") rolled nothing back\n"); pass=pass+1
  } else {
      pw("T5 RED   mispred="); pn(mispred); pw(" hdiv="); pn(hdiv); pw(" conv="); pn(conv)
      pw(" nofalse="); pn(nofalse); pw("\n")
  }
279
  // ---------- T6 late-join via nx_gamesave ----------
  checks = checks + 1
  let A3: *i64 = sys_mmap(W*8) as *i64
  mksess(A3, 0, 888)
  t = 0
  while t < 150 {
      ns_offer(A3, t, 0, cmd_for(t,0)); ns_offer(A3, t, 1, cmd_for(t,1))
      ns_step(A3, 4)
      t = t + 1
  }
  let jw: i64 = gs_save(JP, K_MAGIC_60621, A3, W, K_MAGIC_1785425000)
  let C3: *i64 = sys_mmap(W*8) as *i64
  let jr: i64 = gs_load(JP, C3, W, 0 as *i64)
  C3[1] = 1
  var jok: i64 = 1
  t = 150
  while t < 200 {
      ns_offer(A3, t, 0, cmd_for(t,0)); ns_offer(A3, t, 1, cmd_for(t,1))
      ns_offer(C3, t, 0, cmd_for(t,0)); ns_offer(C3, t, 1, cmd_for(t,1))
      ns_step(A3, 4); ns_step(C3, 4)
      if ns_checksum(A3) != ns_checksum(C3) { jok = 0 }
      t = t + 1
  }
  var t6: i64 = 0
  if jw > 0 { if jr==W { if jok==1 { if ns_shared_eq(A3,C3)==1 { if ns_tick(C3)==200 { t6=1 } } } } }
  if t6==1 {
      pw("T6 GREEN late-join: peer loaded the tick-150 snapshot file ("); pn(jw)
      pw("B) into a ZEROED arena and tracked the host checksum-for-checksum to tick 200\n"); pass=pass+1
  } else { pw("T6 RED   jw="); pn(jw); pw(" jr="); pn(jr); pw(" jok="); pn(jok); pw("\n") }
309
  // ---------- T7 bounded + loud ----------
  checks = checks + 1
  let S7: *i64 = sys_mmap(W*8) as *i64
  mksess(S7, 0, 111)
  let ckb: i64 = ns_checksum(S7)
  let r1: i64 = ns_offer(S7, 0-1, 0, 5)
  let r2: i64 = ns_offer(S7, GMAXT, 0, 5)
  let r3: i64 = ns_offer(S7, 5, 2, 5)
  ns_offer(S7, 5, 0, 7)
  let r4: i64 = ns_offer(S7, 5, 0, 8)
  let r5: i64 = ns_offer(S7, 5, 0, 7)
  var t7: i64 = 0
  if r1==NS_E_TICK { if r2==NS_E_TICK { if r3==NS_E_PEER { if r4==NS_E_CONFLICT { if r5==NS_DUP {
      if ns_checksum(S7)==ckb { t7=1 } } } } } }
  if t7==1 {
      pw("T7 GREEN bounded+loud: tick/peer/conflict refusals distinct ("); pn(r1); pw("/"); pn(r3)
      pw("/"); pn(r4); pw("), duplicate idempotent ("); pn(r5); pw("), shared state untouched\n"); pass=pass+1
  } else {
      pw("T7 RED   codes r1="); pn(r1); pw(" r2="); pn(r2); pw(" r3="); pn(r3)
      pw(" r4="); pn(r4); pw(" r5="); pn(r5); pw("\n")
  }
331
  // ---------- T8 anti-vacuity ----------
  checks = checks + 1
  var sched_nz: i64 = 0
  t = 0
  while t < 200 {
      if cmd_for(t,0)!=0 { sched_nz = sched_nz + 1 }
      if cmd_for(t,1)!=0 { sched_nz = sched_nz + 1 }
      t = t + 1
  }
  let wA: *i64 = ns_world(A)
  var relmoved: i64 = 0
  i = 0
  while i < GNFAC {
      var jj: i64 = i+1
      while jj < GNFAC {
          if ws_rel(wA, i, jj) != 0 { relmoved = 1 }
          jj = jj + 1
      }
      i = i + 1
  }
  var t8: i64 = 0
  if ns_applied(A) >= 50 { if ns_moved(A) > 0 { if ws_total_res(wA) > K_MAGIC_9750 {
      if relmoved==1 { if sched_nz >= 100 { t8=1 } } } } }
  if t8==1 {
      pw("T8 GREEN anti-vacuity: "); pn(ns_applied(A)); pw(" trades moved "); pn(ns_moved(A))
      pw(" units over "); pn(sched_nz); pw(" real commands; wealth 9750 -> "); pn(ws_total_res(wA))
      pw("; relations moved -- the session actually simulates\n"); pass=pass+1
  } else {
      pw("T8 RED   applied="); pn(ns_applied(A)); pw(" moved="); pn(ns_moved(A))
      pw(" total="); pn(ws_total_res(wA)); pw(" relmoved="); pn(relmoved); pw("\n")
  }
363
  // ---------- T9 artifact round-trip + resume ----------
  checks = checks + 1
  let aw: i64 = gs_save(AP, K_MAGIC_60620, A, W, K_MAGIC_1785425000)
  let RD: *i64 = sys_mmap(W*8) as *i64
  let ar: i64 = gs_load(AP, RD, W, 0 as *i64)
  var exact: i64 = 1
  i = 0
  while i < W { if RD[i]!=A[i] { exact=0 } i=i+1 }
  var t9: i64 = 0
  if aw > 0 { if ar==W { if exact==1 {
      ns_offer(A, 200, 0, cmd_for(200,0)); ns_offer(A, 200, 1, cmd_for(200,1))
      ns_offer(RD, 200, 0, cmd_for(200,0)); ns_offer(RD, 200, 1, cmd_for(200,1))
      ns_step(A, 4); ns_step(RD, 4)
      if ns_shared_eq(A, RD)==1 { t9=1 }
  } } }
  if t9==1 {
      pw("T9 GREEN artifact: "); pn(W); pw("-word session ("); pn(aw)
      pw("B) round-tripped through knowledge/nx_netsync_session.sav word-exact AND resumed stepping identically\n")
      pass=pass+1
  } else { pw("T9 RED   aw="); pn(aw); pw(" ar="); pn(ar); pw(" exact="); pn(exact); pw("\n") }
384
  // ---------- T10 REAL-SOCKET TRANSPORT (closes the declared residual) ----------
  // Two PROCESSES, one per peer, exchange commands over a REAL loopback TCP socket using the
  // nx_net_chan 8-byte big-endian frame protocol -- the wire is the kernel's, not a model.
  // Property: sessions converge tick-for-tick across the socket; final checksums exchanged OVER
  // THE WIRE must match and the child must exit clean. A bind failure (port squat) FAILS LOUD
  // rather than skipping -- the throwaway-port lesson: a tooth must verify its own listener.
  checks = checks + 1
  var t10: i64 = 0
  let NSPORT: i64 = K_MAGIC_38921
  let lfd: i64 = nx_sock_socket(NX_AF_INET, NX_SOCK_STREAM, NX_IPPROTO_TCP)
  var bok: i64 = 0
  if lfd >= 0 {
      nx_sock_reuseaddr(lfd)
      let sa: *u8 = sys_mmap(16)
      nx_sock_sin_init(sa, 0x0100007F, NSPORT)
      if nx_sock_bind(lfd, sa, 16) >= 0 { if nx_sock_listen(lfd, 1) >= 0 { bok = 1 } }
  }
  if bok == 0 {
      pw("T10 RED  cannot bind loopback port 38921 (squatter or perm) -- refusing to skip\n")
  }
  if bok == 1 {
      let pid: i64 = sys_fork()
      if pid == 0 {
          let cfd: i64 = nx_sock_socket(NX_AF_INET, NX_SOCK_STREAM, NX_IPPROTO_TCP)
          let ca: *u8 = sys_mmap(16)
          nx_sock_sin_init(ca, 0x0100007F, NSPORT)
          if cfd < 0 { sys_exit(9) }
          if nx_sock_connect(cfd, ca, 16) < 0 { sys_exit(9) }
          let nc: *NxNetChan = nx_net_chan_from_fd(cfd)
          let SC: *i64 = sys_mmap(W*8) as *i64
          mksess(SC, 1, K_MAGIC_31337)
          let rvp: *i64 = sys_mmap(16) as *i64
          var tt: i64 = 0
          var bad: i64 = 0
          while tt < 120 {
              if nx_net_chan_send(nc, cmd_for(tt,1)) != 0 { bad = 1 }
              if bad == 0 { if nx_net_chan_recv(nc, rvp) != 0 { bad = 1 } }
              if bad == 0 {
                  ns_offer(SC, tt, 1, cmd_for(tt,1))
                  ns_offer(SC, tt, 0, rvp[0])
                  ns_step(SC, 4)
              }
              tt = tt + 1
          }
          if bad == 1 { sys_exit(8) }
          let myck: i64 = ns_checksum(SC)
          if nx_net_chan_send(nc, myck) != 0 { sys_exit(8) }
          if nx_net_chan_recv(nc, rvp) != 0 { sys_exit(8) }
          if rvp[0] != myck { sys_exit(7) }
          sys_exit(0)
      }
      let afd: i64 = nx_sock_accept(lfd, 0 as *u8, 0 as *i64)
      var pok: i64 = 1
      if afd < 0 { pok = 0 }
      var pck: i64 = 0
      var rck: i64 = 0
      let SP: *i64 = sys_mmap(W*8) as *i64
      if pok == 1 {
          let np: *NxNetChan = nx_net_chan_from_fd(afd)
          mksess(SP, 0, K_MAGIC_31337)
          let rp: *i64 = sys_mmap(16) as *i64
          var tp: i64 = 0
          while tp < 120 {
              if nx_net_chan_send(np, cmd_for(tp,0)) != 0 { pok = 0 }
              if pok == 1 { if nx_net_chan_recv(np, rp) != 0 { pok = 0 } }
              if pok == 1 {
                  ns_offer(SP, tp, 0, cmd_for(tp,0))
                  ns_offer(SP, tp, 1, rp[0])
                  ns_step(SP, 4)
              }
              tp = tp + 1
          }
          pck = ns_checksum(SP)
          if pok == 1 { if nx_net_chan_recv(np, rp) != 0 { pok = 0 } }
          if pok == 1 { rck = rp[0] }
          nx_net_chan_send(np, pck)
      }
      let stp: *i64 = sys_mmap(16) as *i64
      stp[0] = 0
      sys_wait4(pid, stp, 0)
      let cexit: i64 = (stp[0] >> 8) & 255
      if pok == 1 { if cexit == 0 { if rck == pck { if ns_tick(SP) == 120 { if ns_applied(SP) > 0 {
          t10 = 1
      } } } } }
      if t10 == 1 {
          pw("T10 GREEN real-socket transport: 2 processes, 120 ticks over loopback TCP (nx_net_chan 8B-BE frames), checksums exchanged OVER THE WIRE match (ck=")
          pn(pck); pw("), child exit 0 -- the residual is closed by execution, not declaration\n")
          pass = pass + 1
      } else {
          pw("T10 RED  socket lockstep failed: pok="); pn(pok); pw(" child-exit="); pn(cexit)
          pw(" pck="); pn(pck); pw(" rck="); pn(rck); pw(" tick="); pn(ns_tick(SP)); pw("\n")
      }
  }
478
  pw("\n=== nx_netsync_gate "); pn(pass); pw("/"); pn(checks)
  if pass == checks { pw(" verdict=GREEN ===\n"); return 0 }
  pw(" RED ===\n")
  return 1
483}
nx_netsync_gate.nx source

`nx_netsync_gate.nx` source
