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

↩ module page · 332 lines · 19173 B
1// nx_asset_record_gate.nx -- KAT + TEETH for nx_asset_record (R0 of the universal org-tooling arc).
2//
3// Proves the unified content-addressed ASSET RECORD on real bytes through the real durable store:
4//   (a) DETERMINISTIC IDENTITY  same record bytes -> same CID; ONE changed field -> DIFFERENT CID
5//   (b) ROUND-TRIP              ar_encode -> ar_put -> ar_get_by_cid -> ar_decode is byte-faithful
6//                               (every field identical, byte length identical)
7//   (c) 3 PROVENANCE CLASSES    human / machine(tool+model) / downloaded(source URL) each encode,
8//                               store, and decode with the correct class + payload surviving
9//   (d) INTEGRITY TEETH         flip ONE byte of a stored record -> recomputed CID != the stored
10//                               key (tamper detected; content-address self-proof is load-bearing)
11//
12// Verdict logged to knowledge/status/asset_record_gate.log (append-only; ADDITIVE law #13).
13// expect_exit: 0   license_tier: ORIGINAL
14import "nx_syscalls.nx"
15import "nx_canon_cid.nx"
16import "nx_uxf_decode.nx"
17import "nx_seg_store.nx"
18import "nx_asset_record.nx"
19import "nx_gate_verdict.nx"
20
21// log fd is THREADED as a parameter (the compiler supports const globals but not
22// reassigning a module-level var from inside a function -- match the nx_blob_gate idiom).
23func g_puts(logfd: i64, s: *u8) -> i64 {
  var n: i64 = 0
  while s[n] != (0 as u8) { n = n + 1 }
  sys_write(1, s, n)
  if logfd > 0 { sys_write(logfd, s, n) }
  return 0
29}
30
31func g_putn(logfd: i64, v: i64) -> i64 {
  let bb: *u8 = sys_mmap(28)
  var m: i64 = v
  if m < 0 { g_puts(logfd, "-\x00" 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 { bb[i] = t[k - 1 - i]; i = i + 1 }
  sys_write(1, bb, k)
  if logfd > 0 { sys_write(logfd, bb, k) }
  return 0
44}
45
46func g_streq(a: *u8, b: *u8) -> i64 {
  var i: i64 = 0
  while 1 == 1 {
      if a[i] != b[i] { return 0 }
      if a[i] == (0 as u8) { return 1 }
      i = i + 1
  }
  return 1
54}
55
56// raw byte-for-byte equality of two buffers of equal length
57func g_memeq(a: *u8, b: *u8, n: i64) -> i64 {
  var i: i64 = 0
  while i < n { if a[i] != b[i] { return 0 } i = i + 1 }
  return 1
61}
62
63// empty-string sentinel for omitted optional fields
64func E() -> *u8 { return "\x00" as *u8 }
65
66// set one slot of an i64 ptr-array to a string pointer
67func sset(a: *i64, i: i64, s: *u8) -> i64 { a[i] = s as i64; return 0 }
68
69// build a record from the 7 core / 6 prov / 4 media / 6 org fields -> canonical bytes into `out`;
70// returns byte length.  (Grouped arrays keep us under the 16-arg call cap; ar_fields then ar_encode.)
71func mk_rec(core: *i64, prov: *i64, media: *i64, org: *i64, out: *u8) -> i64 {
  let keys: *i64 = sys_mmap(8 * 48) as *i64
  let vals: *i64 = sys_mmap(8 * 48) as *i64
  let n: i64 = ar_fields(core, prov, media, org, keys, vals)
  return ar_encode(keys, vals, n, out)
76}
77
78func main() -> i64 {
  let logfd: i64 = sys_openat_append("knowledge/status/asset_record_gate.log\x00" as *u8, 0x1a4)
  g_puts(logfd, "=== ASSET-RECORD-GATE (R0: unified content-addressed asset record) ===\n\x00" as *u8)
81
  var pass: i64 = 0
  var total: i64 = 0
84
  // unique store prefix per run so the durable segmented store starts clean + idempotent
  let prefix: *u8 = sys_mmap(256)
  var po: i64 = 0
  let pfx: *u8 = "/tmp/ar-\x00" as *u8
  while pfx[po] != (0 as u8) { prefix[po] = pfx[po]; po = po + 1 }
  let stamp: i64 = sys_now_ms()
  var m: i64 = stamp
  let ds: *u8 = sys_mmap(28)
  var k: i64 = 0
  if m == 0 { ds[0] = 48 as u8; k = 1 }
  while m > 0 { ds[k] = (48 + (m % 10)) as u8; m = m / 10; k = k + 1 }
  var j: i64 = 0
  while j < k { prefix[po] = ds[k - 1 - j]; po = po + 1; j = j + 1 }
  prefix[po] = 45 as u8; po = po + 1   // '-'
  prefix[po] = 0 as u8
100
  // ============================================================================================
  // (a) DETERMINISTIC IDENTITY
  // A MACHINE-generated image record (operator's generated-image case).
  let pc: *u8 = sys_mmap(64)
  let pa: *u8 = sys_mmap(64)
  let pt: *u8 = sys_mmap(128)
  let pm: *u8 = sys_mmap(128)
  ar_prov_machine("nishi-gen-img\x00" as *u8, "sdxl-v1\x00" as *u8, pc, pa, pt, pm)
109
  // core/prov/media/org grouped field arrays for the image record
  let coreA: *i64 = sys_mmap(8 * 8) as *i64
  sset(coreA, 0, "image\x00" as *u8); sset(coreA, 1, "Sunset over the lake\x00" as *u8)
  sset(coreA, 2, "Nishi Studio\x00" as *u8); sset(coreA, 3, "2026-06-18\x00" as *u8)
  sset(coreA, 4, "img-0001\x00" as *u8); sset(coreA, 5, "landscape\x00" as *u8); sset(coreA, 6, "CC-BY\x00" as *u8)
  let provA: *i64 = sys_mmap(8 * 8) as *i64
  sset(provA, 0, pc); sset(provA, 1, pa); sset(provA, 2, pt); sset(provA, 3, pm); sset(provA, 4, E()); sset(provA, 5, E())
  let mediaA: *i64 = sys_mmap(8 * 8) as *i64
  sset(mediaA, 0, "1920\x00" as *u8); sset(mediaA, 1, "1080\x00" as *u8); sset(mediaA, 2, E()); sset(mediaA, 3, "image/png\x00" as *u8)
  let orgA: *i64 = sys_mmap(8 * 8) as *i64
  sset(orgA, 0, "sunset,lake,landscape\x00" as *u8); sset(orgA, 1, "/volume1/assets/img-0001.png\x00" as *u8)
  sset(orgA, 2, "manage\x00" as *u8); sset(orgA, 3, "1\x00" as *u8); sset(orgA, 4, "private\x00" as *u8); sset(orgA, 5, E())
122
  let recA: *u8 = sys_mmap(8192)
  let lenA: i64 = mk_rec(coreA, provA, mediaA, orgA, recA)
  let cidA: *u8 = sys_mmap(128)
  ar_cid(recA, lenA, cidA)
  g_puts(logfd, "  recA bytes=\x00" as *u8); g_putn(logfd, lenA); g_puts(logfd, "  CID=\x00" as *u8); g_puts(logfd, cidA); g_puts(logfd, "\n\x00" as *u8)
128
  // identical fields, fresh arrays + reversed-insertion to PROVE order-independence -> SAME CID.
  let coreA2: *i64 = sys_mmap(8 * 8) as *i64
  sset(coreA2, 6, "CC-BY\x00" as *u8); sset(coreA2, 5, "landscape\x00" as *u8); sset(coreA2, 4, "img-0001\x00" as *u8)
  sset(coreA2, 3, "2026-06-18\x00" as *u8); sset(coreA2, 2, "Nishi Studio\x00" as *u8)
  sset(coreA2, 1, "Sunset over the lake\x00" as *u8); sset(coreA2, 0, "image\x00" as *u8)
  let recA2: *u8 = sys_mmap(8192)
  let lenA2: i64 = mk_rec(coreA2, provA, mediaA, orgA, recA2)
  let cidA2: *u8 = sys_mmap(128)
  ar_cid(recA2, lenA2, cidA2)
138
  total = total + 1
  g_puts(logfd, "  (a1) same fields -> same CID: \x00" as *u8)
  if g_streq(cidA, cidA2) == 1 { pass = pass + 1; g_puts(logfd, "PASS\n\x00" as *u8) } else { g_puts(logfd, "FAIL\n\x00" as *u8) }
142
  // ONE field changed (title "Sunset"->"Sunrise"), everything else identical -> DIFFERENT CID
  let coreB: *i64 = sys_mmap(8 * 8) as *i64
  sset(coreB, 0, "image\x00" as *u8); sset(coreB, 1, "Sunrise over the lake\x00" as *u8)
  sset(coreB, 2, "Nishi Studio\x00" as *u8); sset(coreB, 3, "2026-06-18\x00" as *u8)
  sset(coreB, 4, "img-0001\x00" as *u8); sset(coreB, 5, "landscape\x00" as *u8); sset(coreB, 6, "CC-BY\x00" as *u8)
  let recB: *u8 = sys_mmap(8192)
  let lenB: i64 = mk_rec(coreB, provA, mediaA, orgA, recB)
  let cidB: *u8 = sys_mmap(128)
  ar_cid(recB, lenB, cidB)
  g_puts(logfd, "  recB (title changed) CID=\x00" as *u8); g_puts(logfd, cidB); g_puts(logfd, "\n\x00" as *u8)
153
  total = total + 1
  g_puts(logfd, "  (a2) changed field -> different CID: \x00" as *u8)
  if g_streq(cidA, cidB) == 0 { pass = pass + 1; g_puts(logfd, "PASS\n\x00" as *u8) } else { g_puts(logfd, "FAIL\n\x00" as *u8) }
157
  // ============================================================================================
  // (b) ROUND-TRIP: encode -> put -> get -> decode is byte-faithful
  let prc: i64 = ar_put(prefix, recA, lenA)
  total = total + 1
  g_puts(logfd, "  (b1) ar_put recA rc=\x00" as *u8); g_putn(logfd, prc); g_puts(logfd, ": \x00" as *u8)
  if prc == 0 { pass = pass + 1; g_puts(logfd, "PASS\n\x00" as *u8) } else { g_puts(logfd, "FAIL\n\x00" as *u8) }
164
  let gp: *i64 = sys_mmap(16) as *i64
  let gl: *i64 = sys_mmap(16) as *i64
  let gr: i64 = ar_get_by_cid(prefix, cidA, gp, gl)
  total = total + 1
  g_puts(logfd, "  (b2) ar_get_by_cid rc=\x00" as *u8); g_putn(logfd, gr); g_puts(logfd, " len=\x00" as *u8); g_putn(logfd, gl[0])
  g_puts(logfd, " (want \x00" as *u8); g_putn(logfd, lenA); g_puts(logfd, "): \x00" as *u8)
  var got_ok: i64 = 0
  if gr == 1 { if gl[0] == lenA { got_ok = 1 } }
  if got_ok == 1 { pass = pass + 1; g_puts(logfd, "PASS\n\x00" as *u8) } else { g_puts(logfd, "FAIL\n\x00" as *u8) }
174
  // raw stored bytes identical to the encoded bytes
  total = total + 1
  g_puts(logfd, "  (b3) stored bytes byte-faithful: \x00" as *u8)
  var bytes_ok: i64 = 0
  if got_ok == 1 { if g_memeq(gp[0] as *u8, recA, lenA) == 1 { bytes_ok = 1 } }
  if bytes_ok == 1 { pass = pass + 1; g_puts(logfd, "PASS\n\x00" as *u8) } else { g_puts(logfd, "FAIL\n\x00" as *u8) }
181
  // decode the retrieved bytes and check every field equals the originals
  let dk: *i64 = sys_mmap(8 * 48) as *i64
  let dv: *i64 = sys_mmap(8 * 48) as *i64
  let nf: i64 = ar_decode(gp[0] as *u8, gl[0], dk, dv, 40)
  total = total + 1
  g_puts(logfd, "  (b4) decoded fields nf=\x00" as *u8); g_putn(logfd, nf); g_puts(logfd, ": \x00" as *u8)
  var fields_ok: i64 = 1
  if nf < 0 { fields_ok = 0 }
  if fields_ok == 1 {
      if g_streq(ar_get(dk, dv, nf, "type\x00" as *u8), "image\x00" as *u8) == 0 { fields_ok = 0 }
      if g_streq(ar_get(dk, dv, nf, "title\x00" as *u8), "Sunset over the lake\x00" as *u8) == 0 { fields_ok = 0 }
      if g_streq(ar_get(dk, dv, nf, "creator\x00" as *u8), "Nishi Studio\x00" as *u8) == 0 { fields_ok = 0 }
      if g_streq(ar_get(dk, dv, nf, "width\x00" as *u8), "1920\x00" as *u8) == 0 { fields_ok = 0 }
      if g_streq(ar_get(dk, dv, nf, "height\x00" as *u8), "1080\x00" as *u8) == 0 { fields_ok = 0 }
      if g_streq(ar_get(dk, dv, nf, "classification\x00" as *u8), "private\x00" as *u8) == 0 { fields_ok = 0 }
      if g_streq(ar_get(dk, dv, nf, "is_current\x00" as *u8), "1\x00" as *u8) == 0 { fields_ok = 0 }
  }
  if fields_ok == 1 { pass = pass + 1; g_puts(logfd, "PASS\n\x00" as *u8) } else { g_puts(logfd, "FAIL\n\x00" as *u8) }
200
  // ============================================================================================
  // (c) 3 PROVENANCE CLASSES round-trip with correct class + payload
203
  // -- (c1) HUMAN-authored doc --
  let hc: *u8 = sys_mmap(64)
  let ha: *u8 = sys_mmap(64)
  ar_prov_human("Elder Westover\x00" as *u8, hc, ha)
  let coreH: *i64 = sys_mmap(8 * 8) as *i64
  sset(coreH, 0, "doc\x00" as *u8); sset(coreH, 1, "Family charter\x00" as *u8)
  sset(coreH, 2, "Elder Westover\x00" as *u8); sset(coreH, 3, "2026-06-18\x00" as *u8)
  sset(coreH, 4, E()); sset(coreH, 5, "governance\x00" as *u8); sset(coreH, 6, E())
  let provH: *i64 = sys_mmap(8 * 8) as *i64
  sset(provH, 0, hc); sset(provH, 1, ha); sset(provH, 2, E()); sset(provH, 3, E()); sset(provH, 4, E()); sset(provH, 5, E())
  let mediaH: *i64 = sys_mmap(8 * 8) as *i64
  sset(mediaH, 0, E()); sset(mediaH, 1, E()); sset(mediaH, 2, E()); sset(mediaH, 3, E())
  let orgH: *i64 = sys_mmap(8 * 8) as *i64
  sset(orgH, 0, "charter,family\x00" as *u8); sset(orgH, 1, "/volume1/docs/charter.md\x00" as *u8)
  sset(orgH, 2, "use\x00" as *u8); sset(orgH, 3, "1\x00" as *u8); sset(orgH, 4, "professional\x00" as *u8); sset(orgH, 5, E())
  let recH: *u8 = sys_mmap(8192)
  let lenH: i64 = mk_rec(coreH, provH, mediaH, orgH, recH)
  let dkh: *i64 = sys_mmap(8 * 48) as *i64
  let dvh: *i64 = sys_mmap(8 * 48) as *i64
  let nfh: i64 = ar_decode(recH, lenH, dkh, dvh, 40)
  total = total + 1
  g_puts(logfd, "  (c1) HUMAN class survives [class=\x00" as *u8); g_puts(logfd, ar_get(dkh, dvh, nfh, "prov_class\x00" as *u8))
  g_puts(logfd, " agent=\x00" as *u8); g_puts(logfd, ar_get(dkh, dvh, nfh, "prov_agent\x00" as *u8)); g_puts(logfd, "]: \x00" as *u8)
  var h_ok: i64 = 1
  if g_streq(ar_get(dkh, dvh, nfh, "prov_class\x00" as *u8), "human\x00" as *u8) == 0 { h_ok = 0 }
  if g_streq(ar_get(dkh, dvh, nfh, "prov_agent\x00" as *u8), "Elder Westover\x00" as *u8) == 0 { h_ok = 0 }
  // a human record carries NO tool/source
  if ar_present(ar_get(dkh, dvh, nfh, "prov_tool\x00" as *u8)) == 1 { h_ok = 0 }
  if ar_present(ar_get(dkh, dvh, nfh, "prov_source\x00" as *u8)) == 1 { h_ok = 0 }
  if h_ok == 1 { pass = pass + 1; g_puts(logfd, "PASS\n\x00" as *u8) } else { g_puts(logfd, "FAIL\n\x00" as *u8) }
234
  // -- (c2) MACHINE-generated: tool + model must survive (reuse recA's machine prov, decode it) --
  total = total + 1
  g_puts(logfd, "  (c2) MACHINE class+tool+model survive [class=\x00" as *u8); g_puts(logfd, ar_get(dk, dv, nf, "prov_class\x00" as *u8))
  g_puts(logfd, " tool=\x00" as *u8); g_puts(logfd, ar_get(dk, dv, nf, "prov_tool\x00" as *u8))
  g_puts(logfd, " model=\x00" as *u8); g_puts(logfd, ar_get(dk, dv, nf, "prov_model\x00" as *u8)); g_puts(logfd, "]: \x00" as *u8)
  var mac_ok: i64 = 1
  if g_streq(ar_get(dk, dv, nf, "prov_class\x00" as *u8), "machine\x00" as *u8) == 0 { mac_ok = 0 }
  if g_streq(ar_get(dk, dv, nf, "prov_tool\x00" as *u8), "nishi-gen-img\x00" as *u8) == 0 { mac_ok = 0 }
  if g_streq(ar_get(dk, dv, nf, "prov_model\x00" as *u8), "sdxl-v1\x00" as *u8) == 0 { mac_ok = 0 }
  if mac_ok == 1 { pass = pass + 1; g_puts(logfd, "PASS\n\x00" as *u8) } else { g_puts(logfd, "FAIL\n\x00" as *u8) }
245
  // -- (c3) DOWNLOADED video: source URL must survive --
  let dc: *u8 = sys_mmap(64)
  let da: *u8 = sys_mmap(64)
  let dsrc: *u8 = sys_mmap(256)
  let ddate: *u8 = sys_mmap(64)
  ar_prov_downloaded("https://example.com/clip.mp4\x00" as *u8, "2026-06-17\x00" as *u8, dc, da, dsrc, ddate)
  let coreD: *i64 = sys_mmap(8 * 8) as *i64
  sset(coreD, 0, "video\x00" as *u8); sset(coreD, 1, "Reference clip\x00" as *u8)
  sset(coreD, 2, E()); sset(coreD, 3, E()); sset(coreD, 4, E()); sset(coreD, 5, E()); sset(coreD, 6, E())
  let provD: *i64 = sys_mmap(8 * 8) as *i64
  sset(provD, 0, dc); sset(provD, 1, da); sset(provD, 2, E()); sset(provD, 3, E()); sset(provD, 4, dsrc); sset(provD, 5, ddate)
  let mediaD: *i64 = sys_mmap(8 * 8) as *i64
  sset(mediaD, 0, "1280\x00" as *u8); sset(mediaD, 1, "720\x00" as *u8); sset(mediaD, 2, "00:02:31\x00" as *u8); sset(mediaD, 3, "video/mp4\x00" as *u8)
  let orgD: *i64 = sys_mmap(8 * 8) as *i64
  sset(orgD, 0, "reference\x00" as *u8); sset(orgD, 1, "/volume1/dl/clip.mp4\x00" as *u8)
  sset(orgD, 2, "ingest\x00" as *u8); sset(orgD, 3, "1\x00" as *u8); sset(orgD, 4, "private\x00" as *u8); sset(orgD, 5, E())
  let recD: *u8 = sys_mmap(8192)
  let lenD: i64 = mk_rec(coreD, provD, mediaD, orgD, recD)
  // round-trip through the STORE too (put -> get -> decode) to prove durability of a downloaded asset
  let cidD: *u8 = sys_mmap(128)
  ar_cid(recD, lenD, cidD)
  ar_put(prefix, recD, lenD)
  let dgp: *i64 = sys_mmap(16) as *i64
  let dgl: *i64 = sys_mmap(16) as *i64
  let dgr: i64 = ar_get_by_cid(prefix, cidD, dgp, dgl)
  let dkd: *i64 = sys_mmap(8 * 48) as *i64
  let dvd: *i64 = sys_mmap(8 * 48) as *i64
  var nfd: i64 = 0 - 1
  if dgr == 1 { nfd = ar_decode(dgp[0] as *u8, dgl[0], dkd, dvd, 40) }
  total = total + 1
  g_puts(logfd, "  (c3) DOWNLOADED class+source survive store r/t [class=\x00" as *u8)
  if nfd > 0 { g_puts(logfd, ar_get(dkd, dvd, nfd, "prov_class\x00" as *u8)) }
  g_puts(logfd, " source=\x00" as *u8)
  if nfd > 0 { g_puts(logfd, ar_get(dkd, dvd, nfd, "prov_source\x00" as *u8)) }
  g_puts(logfd, "]: \x00" as *u8)
  var dl_ok: i64 = 0
  if nfd > 0 {
      dl_ok = 1
      if g_streq(ar_get(dkd, dvd, nfd, "prov_class\x00" as *u8), "downloaded\x00" as *u8) == 0 { dl_ok = 0 }
      if g_streq(ar_get(dkd, dvd, nfd, "prov_source\x00" as *u8), "https://example.com/clip.mp4\x00" as *u8) == 0 { dl_ok = 0 }
      if g_streq(ar_get(dkd, dvd, nfd, "prov_date\x00" as *u8), "2026-06-17\x00" as *u8) == 0 { dl_ok = 0 }
      // a downloaded record carries NO tool/model
      if ar_present(ar_get(dkd, dvd, nfd, "prov_tool\x00" as *u8)) == 1 { dl_ok = 0 }
  }
  if dl_ok == 1 { pass = pass + 1; g_puts(logfd, "PASS\n\x00" as *u8) } else { g_puts(logfd, "FAIL\n\x00" as *u8) }
291
  // ============================================================================================
  // (d) INTEGRITY TEETH: flip ONE byte of the stored record -> recomputed CID != the stored key.
  // Copy the stored bytes, corrupt one byte in the middle, recompute its CID, assert mismatch.
  let n5: i64 = gl[0]
  let tampered: *u8 = sys_mmap(n5 + 16)
  var c5: i64 = 0
  // LM-031 fix: bind the cast to a local, then index. The inline form `(gp[0] as *u8)[c5]` SILENTLY MISCOMPILES
  // to a garbage pointer-sized value (found by nx_doc_ubscan, confirmed by nx_ub_verify: inline=garbage vs
  // bind-then-index=correct) -- so this tamper test was copying GARBAGE, passing for the wrong reason.
  let rec_src: *u8 = gp[0] as *u8
  while c5 < n5 { tampered[c5] = rec_src[c5]; c5 = c5 + 1 }
  let mid5: i64 = n5 / 2
  tampered[mid5] = (tampered[mid5] ^ (1 as u8)) as u8   // flip one bit of one byte
  let cidT: *u8 = sys_mmap(128)
  ar_cid(tampered, n5, cidT)
  g_puts(logfd, "  tampered byte@\x00" as *u8); g_putn(logfd, mid5); g_puts(logfd, " recomputed CID=\x00" as *u8); g_puts(logfd, cidT); g_puts(logfd, "\n\x00" as *u8)
  total = total + 1
  g_puts(logfd, "  (d) flipped byte -> CID no longer matches stored key (tamper detected): \x00" as *u8)
  if g_streq(cidT, cidA) == 0 { pass = pass + 1; g_puts(logfd, "PASS\n\x00" as *u8) } else { g_puts(logfd, "FAIL\n\x00" as *u8) }
311
  // also: the tampered bytes must NOT resolve in the store under the original key as themselves
  // (the store key IS cidA; the tampered content's own CID is cidT != cidA -> integrity by address)
  total = total + 1
  g_puts(logfd, "  (d2) tampered content's CID differs from BOTH stored keys (A,D): \x00" as *u8)
  var teeth2: i64 = 1
  if g_streq(cidT, cidA) == 1 { teeth2 = 0 }
  if g_streq(cidT, cidD) == 1 { teeth2 = 0 }
  if teeth2 == 1 { pass = pass + 1; g_puts(logfd, "PASS\n\x00" as *u8) } else { g_puts(logfd, "FAIL\n\x00" as *u8) }
320
  // ============================================================================================
  g_puts(logfd, "ASSET-RECORD-GATE passed \x00" as *u8); g_putn(logfd, pass); g_puts(logfd, "/\x00" as *u8); g_putn(logfd, total)
  // MIGRATED onto nx_gate_verdict by nx_gate_dry_apply (D001, minimal form): every check
  // row above is untouched, so the PASS/FAIL vector cannot change; only the hand-rolled
  // verdict emission is replaced by the ONE shared base class. Proven by nx_gate_migrate verify.
  let ctr__dry: *i64 = gv_ctr()
  ctr__dry[0] = pass
  ctr__dry[1] = total
  let rc__dry: i64 = gv_verdict("ASSET-RECORD-GATE" as *u8, ctr__dry, "teeth unchanged; verdict emission migrated onto the shared base class" as *u8)
  sys_exit(rc__dry)
  return rc__dry
332}
nx_asset_record_gate.nx source

`nx_asset_record_gate.nx` source
