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

↩ module page · 265 lines · 16318 B
1// ORIGINAL. Read-only real NXA witness. Usage: gate.elf <banked-asset.nxa>
2// Container validation stays with nx_nxa; this gate admits the documented payloads.
3// Inactive integer identity is tested here. The renderer must retain its original
4// float32 position/normal buffers when moved==0; this gate cannot prove that seam.
5import "nx_syscalls.nx"
6import "nx_gate_verdict.nx"
7import "nx_nxa.nx"
8import "nx_morf_draw_core.nx"
9import "nx_nxa_morf_admit.nx"
10import "nx_nxa_morf_draw_admit.nx"
11import "nx_wasm_craft.nx"
12
13func mdag_equal(a: *i64,b: *i64,n: i64) -> i64 {
  var i: i64 = 0
  while i < n { if a[i] != b[i] { return 0 }; i = i+1 }
  return 1
17}
18func mdag_text_equal(a: *u8,b: *u8) -> i64 {
  var i: i64 = 0
  while a[i] != (0 as u8) { if a[i] != b[i] { return 0 }; i = i+1 }
  if b[i] != (0 as u8) { return 0 }
  return 1
23}
24func mdag_run(path: *u8,ctr: *i64) -> i64 {
  let lp: *i64 = sys_mmap(8) as *i64
  if (lp as i64) <= 0 { return 0-1 }
  let bytes: *u8 = sys_read_file(path,lp)
  if (bytes as i64) <= 0 { return 0-1 }
  let original: *u8 = sys_mmap(lp[0])
  if (original as i64) <= 0 { return 0-4 }
  var byte_i: i64 = 0
  while byte_i < lp[0] { original[byte_i] = bytes[byte_i]; byte_i = byte_i+1 }
  let h: *i64 = bytes as *i64
  let nv: i64 = nmi_scratch_bytes(bytes,lp[0])
  if nv < 1 { return NMI_E_SHAPE }
  let member: *u8 = sys_mmap(nv) as *u8
  let admitted: *NmiAsset = sys_mmap(__size_of(NmiAsset)) as *NmiAsset
  let av: *MvcView = sys_mmap(__size_of(MvcView)) as *MvcView
  if (member as i64) <= 0 { return 0-4 }
  if (admitted as i64) <= 0 { return 0-4 }
  if (av as i64) <= 0 { return 0-4 }
  admitted.view = av
  av.channels = 0-999
  gv_check_eq("undersized membership scratch refuses real asset" as *u8,nmi_admit(bytes,lp[0],member,nv-1,admitted),NMI_E_SCRATCH,ctr)
  gv_check_eq("refused ingress leaves output view unpublished" as *u8,av.channels,0-999,ctr)
  let admission: i64 = nmi_admit(bytes,lp[0],member,nv,admitted)
  gv_check_eq("canonical shared admission accepts real asset" as *u8,admission,0,ctr)
  if admission < 0 { return admission }
  gv_check_eq("membership may not overwrite immutable input" as *u8,nmi_admit(bytes,lp[0],bytes,nv,admitted),NMI_E_SCRATCH,ctr)
  let tw: i64 = nxa_counted_section(bytes,lp[0],nxa_tag4("TRIS" as *u8),MVC_AXES)
  if tw < 0 { return NMI_E_SHAPE }
  let nf: i64 = av.faces; let nc: i64 = av.channels
  let dw: i64 = av.delta_words; let cw: i64 = dw/nc
  let words: i64 = av.bind_words
  let bind: *i64 = av.bind
  let tri: *i64 = ((bytes as i64)+(tw+1)*MVC_WORD) as *i64
  let face: *i64 = av.face
  let delta: *i64 = av.delta
  let seen: *i64 = sys_mmap(nv*8) as *i64
  let bn: *i64 = sys_mmap(words*8) as *i64
  let pos: *i64 = sys_mmap(words*8) as *i64
  let norm: *i64 = sys_mmap(words*8) as *i64
  let again: *i64 = sys_mmap(words*8) as *i64
  let norm2: *i64 = sys_mmap(words*8) as *i64
  let expected: *i64 = sys_mmap(words*8) as *i64
  let weights: *i64 = sys_mmap(nc*8) as *i64
  let v: *MvcView = sys_mmap(__size_of(MvcView)) as *MvcView
  let a: *MrdAsset = sys_mmap(__size_of(MrdAsset)) as *MrdAsset
  if (seen as i64) <= 0 { return 0-4 }; if (bn as i64) <= 0 { return 0-4 }
  if (pos as i64) <= 0 { return 0-4 }; if (norm as i64) <= 0 { return 0-4 }
  if (again as i64) <= 0 { return 0-4 }; if (norm2 as i64) <= 0 { return 0-4 }
  if (expected as i64) <= 0 { return 0-4 }; if (weights as i64) <= 0 { return 0-4 }
  if (v as i64) <= 0 { return 0-4 }; if (a as i64) <= 0 { return 0-4 }
  var i: i64 = 0
  while i < nv { seen[i] = 0; i = i+1 }
  i = 0
  while i < nf {
      let id: i64 = face[i]
      if id < 0 { return 0-5 }; if id >= nv { return 0-5 }
      if seen[id] != 0 { return 0-5 }; seen[id] = 1; i = i+1
  }
  // Degree proof admits the actual shared area-weighted owner before baseline.
  i = 0
  while i < nv { seen[i] = 0; i = i+1 }
  var degree: i64 = 0; i = 0
  while i < h[tw]*3 {
      let id: i64 = tri[i]
      if id < 0 { return 0-5 }; if id >= nv { return 0-5 }
      seen[id] = seen[id]+1
      if seen[id] > degree { degree = seen[id] }; i = i+1
  }
  if mrd_normal_envelope(bind,tri,h[tw],degree) < 0 { return MRD_E_NORMAL_RANGE }
  if vn_smooth_area(bind,tri,nv,h[tw],bn) < 0 { return 0-6 }
  let admitted_normals: *i64 = sys_mmap(words*MVC_WORD) as *i64
  if (admitted_normals as i64) <= 0 { return 0-4 }
  a.triangle_words = 0-999
  gv_check_eq("wrong normal output length refuses" as *u8,nmd_admit(bytes,lp[0],member,nv,admitted,admitted_normals,words-1,a),NMD_E_NORMAL_WORDS,ctr)
  gv_check_eq("refusal leaves draw unpublished" as *u8,a.triangle_words,0-999,ctr)
  let draw_admission: i64 = nmd_admit(bytes,lp[0],member,nv,admitted,admitted_normals,words,a)
  gv_check_eq("actual draw asset admitted" as *u8,draw_admission,0,ctr)
  if draw_admission < 0 { return draw_admission }
  gv_check("all admitted normals exactly equal direct shared-owner baseline" as *u8,mdag_equal(admitted_normals,bn,words),ctr)
  gv_check_eq("counted TRIS word offset becomes correct byte pointer" as *u8,a.triangles as i64,(bytes as i64)+(tw+1)*MVC_WORD,ctr)
  gv_check_eq("all declared triangle words exposed" as *u8,a.triangle_words,h[tw]*VN_TRI_I,ctr)
  var selected: i64 = 0-1; i = 0
  while i < dw { if delta[i] != 0 { if selected < 0 { selected = i/cw } }; i = i+1 }
  if selected < 0 { return 0-7 }
  i = 0
  while i < nc { weights[i] = 0; i = i+1 }
  weights[selected] = av.unit
  i = 0
  while i < words { expected[i] = bind[i]; i = i+1 }
  var support: i64 = 0; i = 0
  while i < nf {
      var axis: i64 = 0; var changed: i64 = 0
      while axis < 3 {
          let d: i64 = delta[selected*cw+i*3+axis]
          let at: i64 = face[i]*3+axis
          if mvc_sum_ok(bind[at],d) == 0 { return 0-8 }
          expected[at] = bind[at]+d
          if d != 0 { changed = 1 }; axis = axis+1
      }
      support = support+changed; i = i+1
  }
  v.bind = bind; v.bind_words = words; v.face = face; v.face_words = nf
  v.delta = delta; v.delta_words = dw; v.vertices = nv; v.faces = nf; v.channels = nc; v.unit = av.unit
  let moved: i64 = mrd_prepare(a,weights,nc,pos,words,norm,words)
  gv_check("actual channel has nonzero support" as *u8,support > 0,ctr)
  gv_check_eq("actual support count is exact" as *u8,moved,support,ctr)
  if moved < 0 { return moved }
  gv_check("every VERT coordinate matches stored full-weight delta including non-FACE identity" as *u8,mdag_equal(pos,expected,words),ctr)
  var normals_valid: i64 = 1; i = 0
  while i < nv {
      var axis: i64 = 0; var nonzero: i64 = 0
      while axis < 3 {
          let value: i64 = norm[i*3+axis]
          if value < 0-VN_SCALE { normals_valid = 0 }
          if value > VN_SCALE { normals_valid = 0 }
          if value != 0 { nonzero = 1 }; axis = axis+1
      }
      if nonzero == 0 { normals_valid = 0 }; i = i+1
  }
  gv_check("every actual vertex has bounded nonzero geometric normal" as *u8,normals_valid,ctr)
  gv_check_eq("repeat real draw succeeds" as *u8,mrd_prepare(a,weights,nc,again,words,norm2,words),moved,ctr)
  gv_check("repeat geometry exact" as *u8,mdag_equal(pos,again,words),ctr)
  gv_check("repeat normals exact" as *u8,mdag_equal(norm,norm2,words),ctr)
  weights[selected] = 0
  gv_check_eq("inactive entity returns zero" as *u8,mrd_prepare(a,weights,nc,again,words,norm2,words),0,ctr)
  gv_check("inactive positions exact" as *u8,mdag_equal(bind,again,words),ctr)
  gv_check("inactive supplied normals exact" as *u8,mdag_equal(bn,norm2,words),ctr)
  gv_check("inactive entity did not overwrite active geometry" as *u8,mdag_equal(pos,expected,words),ctr)
  // Compose real admitted data into the actual engine's owned arena.
  let capacity: i64 = wc_morf_storage_bytes(a,admitted.tag_words)
  if capacity < 0 { return capacity }
  let base: i64 = sys_mmap(CRAFT_EXT_TOTAL+capacity) as i64
  if base <= 0 { return 0-4 }
  let mobs: *i64 = mobp(base)
  en_init(mobs,MOB_CAP,MOB_NCOMP)
  en_spawn(mobs); en_spawn(mobs)
  gv_check_eq("real admitted asset binds engine-owned storage" as *u8,wc_morf_bind(base,capacity,a,admitted.tags,admitted.tag_words),0,ctr)
  gv_check_eq("real asset tag identity survives ingress" as *u8,wc_morf_channel_tag(base,selected),admitted.tags[selected*NMI_CHANNEL_WORDS],ctr)
  gv_check_eq("real asset weight unit accepted by engine" as *u8,wc_cast_morf_weight(base,0,selected,av.unit),0,ctr)
  gv_check_eq("real engine draw moves actual channel support" as *u8,wc_cast_morf(base,0),support,ctr)
  let draw: *WcmDraw = wc_morf_descriptor(base)
  gv_check("engine geometry agrees with independent stored-delta oracle" as *u8,mdag_equal(draw.positions,expected,words),ctr)
  gv_check("engine normals agree with admitted direct draw" as *u8,mdag_equal(draw.normals,norm,words),ctr)
  gv_check_eq("second real entity stays on incumbent float path" as *u8,wc_cast_morf(base,1),0,ctr)
  // Corrupt membership with VALID checksums: fail on actual duplicate identity,
  // not merely on integrity. Restore every changed word before returning.
  if nf > 1 {
      let fe: i64 = nxa_section_entry(bytes,lp[0],nxa_tag4("FACE" as *u8))
      let old_id: i64 = face[0]; let old_fc: i64 = h[fe+3]; let old_toc: i64 = h[3]
      face[0] = face[1]
      h[fe+3] = nxa_check2(1,((bytes as i64)+h[fe+1]) as *i64,h[fe+2])
      h[3] = nxa_check2(1,((bytes as i64)+32) as *i64,h[2]*4)
      gv_check_eq("checksummed duplicate FACE identity refused" as *u8,nmi_admit(bytes,lp[0],member,nv,admitted),NMI_R_FACE_DUPLICATE,ctr)
      gv_check("duplicate FACE retains exact prior diagnostic" as *u8,mdag_text_equal(nmi_diagnostic(NMI_R_FACE_DUPLICATE),"MORF-REFUSE duplicate FACE vertex ID\n" as *u8),ctr)
      face[0] = old_id; h[fe+3] = old_fc; h[3] = old_toc
      gv_check_eq("restored real asset admits again" as *u8,nmi_admit(bytes,lp[0],member,nv,admitted),0,ctr)
  }
  let me: i64 = nxa_section_entry(bytes,lp[0],nxa_tag4("MORF" as *u8))
  let mp: *i64 = ((bytes as i64)+h[me+1]) as *i64
  let old_unit: i64 = mp[3]; let old_mc: i64 = h[me+3]; let old_tc: i64 = h[3]
  mp[3] = 0
  h[me+3] = nxa_check2(1,mp,h[me+2])
  h[3] = nxa_check2(1,((bytes as i64)+32) as *i64,h[2]*4)
  gv_check_eq("checksummed invalid unit retains precise reason" as *u8,nmi_admit(bytes,lp[0],member,nv,admitted),NMI_R_UNIT,ctr)
  gv_check("unit retains exact prior diagnostic" as *u8,mdag_text_equal(nmi_diagnostic(NMI_R_UNIT),"MORF-REFUSE declared weight unit is not positive\n" as *u8),ctr)
  mp[3] = old_unit; h[me+3] = old_mc; h[3] = old_tc
  let fe2: i64 = nxa_section_entry(bytes,lp[0],nxa_tag4("FACE" as *u8))
  let old_tag: i64 = h[fe2]; let old_tc2: i64 = h[3]
  h[fe2] = nxa_tag4("TEST" as *u8)
  h[3] = nxa_check2(1,((bytes as i64)+32) as *i64,h[2]*4)
  let missing: i64 = nmi_admit(bytes,lp[0],member,nv,admitted)
  gv_check_eq("missing FACE retains precise reason" as *u8,missing,NMI_R_NO_FACE,ctr)
  gv_check_eq("missing FACE retains missing-section class" as *u8,nmi_missing(missing),1,ctr)
  gv_check("missing FACE retains exact prior diagnostic" as *u8,mdag_text_equal(nmi_diagnostic(missing),"MORF-REFUSE no FACE section -- run derive first\n" as *u8),ctr)
  h[fe2] = old_tag; h[3] = old_tc2
  gv_check_eq("normal output cannot alias immutable file" as *u8,nmd_admit(bytes,lp[0],member,nv,admitted,bytes as *i64,words,a),NMD_E_ALIAS,ctr)
  gv_check_eq("normal output cannot alias membership scratch" as *u8,nmd_admit(bytes,lp[0],member,nv,admitted,member as *i64,words,a),NMD_E_ALIAS,ctr)
  gv_check_eq("draw descriptor cannot alias admitted morph view" as *u8,nmd_admit(bytes,lp[0],member,nv,admitted,admitted_normals,words,av as *MrdAsset),NMD_E_ALIAS,ctr)
  let te: i64 = nxa_section_entry(bytes,lp[0],nxa_tag4("TRIS" as *u8))
  if te < 0 { return NMD_E_TRIANGLES }
  let tp: *i64 = ((bytes as i64)+h[te+1]) as *i64
  let tris_checksum: i64 = h[te+3]; let toc_checksum: i64 = h[3]
  let triangle_count: i64 = tp[0]
  gv_check("actual fixture has triangles for index mutation" as *u8,triangle_count > 0,ctr)
  if triangle_count < 1 { return NMD_E_TRIANGLES }
  tp[0] = triangle_count+1
  h[te+3] = nxa_check2(1,tp,h[te+2])
  h[3] = nxa_check2(1,((bytes as i64)+32) as *i64,h[2]*4)
  a.triangle_words = 0-999; admitted_normals[0] = 739
  gv_check_eq("checksummed TRIS count mismatch refuses" as *u8,nmd_admit(bytes,lp[0],member,nv,admitted,admitted_normals,words,a),NMD_E_TRIANGLES,ctr)
  gv_check_eq("bad topology leaves draw unpublished" as *u8,a.triangle_words,0-999,ctr)
  gv_check_eq("bad topology leaves normal scratch untouched" as *u8,admitted_normals[0],739,ctr)
  tp[0] = triangle_count; h[te+3] = tris_checksum; h[3] = toc_checksum
  let first_index: i64 = tp[1]
  tp[1] = nv
  h[te+3] = nxa_check2(1,tp,h[te+2])
  h[3] = nxa_check2(1,((bytes as i64)+32) as *i64,h[2]*4)
  gv_check_eq("checksummed out-of-range triangle index refuses" as *u8,nmd_admit(bytes,lp[0],member,nv,admitted,admitted_normals,words,a),NMD_E_TRIANGLES,ctr)
  tp[1] = first_index; h[te+3] = tris_checksum; h[3] = toc_checksum
  // VERT's counted xyz payload is also a checksum-valid counted triple array.
  // Redirect TRIS to it: only full-section separation can reject this alias.
  let ve: i64 = nxa_section_entry(bytes,lp[0],nxa_tag4("VERT" as *u8))
  let original_offset: i64 = h[te+1]; let original_words: i64 = h[te+2]
  h[te+1] = h[ve+1]; h[te+2] = h[ve+2]; h[te+3] = h[ve+3]
  h[3] = nxa_check2(1,((bytes as i64)+32) as *i64,h[2]*4)
  gv_check_eq("checksum-valid TRIS/VERT section overlap refuses" as *u8,nmd_admit(bytes,lp[0],member,nv,admitted,admitted_normals,words,a),NMD_E_ALIAS,ctr)
  h[te+1] = original_offset; h[te+2] = original_words; h[te+3] = tris_checksum; h[3] = toc_checksum
  var other_entry: i64 = 0-1; var section: i64 = 0
  while section < h[2] {
      let e: i64 = 4+section*4; let tag: i64 = h[e]
      if tag != nxa_tag4("VERT" as *u8) { if tag != nxa_tag4("FACE" as *u8) { if tag != nxa_tag4("MORF" as *u8) { if tag != nxa_tag4("TRIS" as *u8) { other_entry = e } } } }
      section = section+1
  }
  gv_check("actual asset contains an independent duplicate-tag mutation target" as *u8,other_entry >= 0,ctr)
  if other_entry >= 0 {
      let previous_tag: i64 = h[other_entry]
      let previous_offset: i64 = h[other_entry+1]
      let previous_words: i64 = h[other_entry+2]
      let previous_checksum: i64 = h[other_entry+3]
      h[other_entry] = nxa_tag4("TRIS" as *u8)
      h[other_entry+1] = h[te+1]; h[other_entry+2] = h[te+2]; h[other_entry+3] = h[te+3]
      h[3] = nxa_check2(1,((bytes as i64)+32) as *i64,h[2]*4)
      gv_check_eq("checksummed duplicate TRIS identity refuses" as *u8,nmd_admit(bytes,lp[0],member,nv,admitted,admitted_normals,words,a),NMD_E_TRIANGLES,ctr)
      h[other_entry] = previous_tag; h[other_entry+1] = previous_offset
      h[other_entry+2] = previous_words; h[other_entry+3] = previous_checksum; h[3] = toc_checksum
  }
  gv_check_eq("restored real draw asset admits again" as *u8,nmd_admit(bytes,lp[0],member,nv,admitted,admitted_normals,words,a),0,ctr)
  gv_check("restored normals match every direct baseline word" as *u8,mdag_equal(admitted_normals,bn,words),ctr)
  var immutable: i64 = 1; byte_i = 0
  while byte_i < lp[0] { if bytes[byte_i] != original[byte_i] { immutable = 0 }; byte_i = byte_i+1 }
  gv_check("borrowed real asset remains byte-identical after admission and restored mutations" as *u8,immutable,ctr)
  return 0
256}
257func main(argc: i64,argv: *i64) -> i64 {
  let ctr: *i64 = gv_ctr()
  gv_head("shared canonical MORF ingress into actual engine storage" as *u8)
  var rc: i64 = 0-1
  if argc == 1 { rc = mdag_run("/tmp/nxmorfgate/d1.nxa" as *u8,ctr) }
  if argc == 2 { rc = mdag_run(argv[1] as *u8,ctr) }
  gv_check_eq("real asset admission and preparation succeeds" as *u8,rc,0,ctr)
  return gv_verdict("NX-NXA-MORF-DRAW-INGRESS" as *u8,ctr,"real geometry witness; renderer float32 bypass and both GPU doors remain separate acceptance" as *u8)
265}
nx_nxa_morf_draw_ingress_gate.nx source

`nx_nxa_morf_draw_ingress_gate.nx` source
