code wiki / _hdl_build / nx_vnsprite_gate.nx
nx_vnsprite_gate.nx source
↩ module page · 416 lines · 18470 B
1// nx_vnsprite_gate.nx -- liar-kill gate for the VN sprite compositor (gamebench bit 13).
2// T1 Z-ORDER is real: at an overlap the higher-z layer's pixel wins; swapping z swaps the winner.
3// T2 ALPHA + KEY are exact: a 50% blend lands on the exact integer mix per channel, and a key-color
4// pixel is fully transparent (background shows through untouched).
5// T3 CLIPPING cannot write out of bounds: blits hanging off every edge leave 8 canary cells intact.
6// T4 EXPRESSION SWAP IS VISIBLE: base+smile vs base+frown differ in >=20 pixels; recomposing the
7// same expression twice differs in 0 (visible AND deterministic -- the VN beat that matters).
8// T5 SCENE STATE ROUND-TRIPS: the layer table through gs_save -> ZEROED -> gs_load -> recompose is
9// frame-checksum identical (parts doctrine: everything persists through the save part).
10// T6 DETERMINISM: the full scene composed twice is checksum-identical.
11// T7 ANTI-VACUITY: the composed scene differs from the bare background in >=500 px with >=5
12// distinct sprite colors (a compositor that draws nothing cannot pass).
13// T8 SCENE ARTIFACT: a full VN frame (gradient bg + two characters + alpha textbox + name tag) is
14// written as a sovereign PNG to knowledge/nx_vnsprite_scene.png -- the board's evidence.
15// T9 GROUP EXCLUSIVITY (the Ren'Py layeredimage bar, researched 2026-07-29): smile and frown are
16// two attributes of ONE group; a single vsp_setg call swaps them with no manual bookkeeping,
17// and exactly one is ever composed (probed at pixel level both ways).
18// T10 DISSOLVE EXACT: the core VN transition -- t=0 equals frame A, t=256 equals frame B (full-frame
19// checksums), and the t=128 midpoint is the exact integer channel mix at a probed pixel.
20// license_tier: ORIGINAL expect_exit: 0
21import "nx_syscalls.nx"
22import "nx_estate_path.nx" // ep_anchor: the CWD must not decide this organ's verdict
23import "nx_vnsprite.nx"
24import "nx_gamesave.nx"
25import "nx_png.nx"
26import "nx_gate_verdict.nx"
27const VG_B: i64 = 65536
28const VG_CANARY: i64 = 12345678
29const VG_STAMP: i64 = 20260729
30const VG_SCHEMA: i64 = 78
31const VG_W: i64 = 640
32const VG_H: i64 = 360
33
34func hw3(s: *u8) -> i64 { var n: i64 = 0; while s[n] != (0 as u8) { n = n + 1 } sys_write(1, s, n); return 0 }
35func hn3(v: i64) -> i64 {
36 let t: *u8 = sys_mmap(32)
37 var m: i64 = v
38 if m == 0 { sys_write(1, "0" as *u8, 1); return 0 }
39 if m < 0 { sys_write(1, "-" as *u8, 1); m = 0 - m }
40 var k: i64 = 0
41 while m > 0 { t[k] = (48 + (m % 10)) as u8; m = m/10; k = k + 1 }
42 while k > 0 { k = k - 1; sys_write(1, (t as i64 + k) as *u8, 1) }
43 return 0
44}
45// procedural character sprite: key-filled, head circle + torso rect (art quality is NOT this axis)
46func mk_body(spr: *i64, sw: i64, sh: i64, key: i64, skin: i64, shirt: i64) -> i64 {
47 var i: i64 = 0
48 while i < sw*sh { spr[i] = key; i = i + 1 }
49 let cx: i64 = sw/2
50 let r: i64 = sw/3
51 var y: i64 = 0
52 while y < sh {
53 var x: i64 = 0
54 while x < sw {
55 let dy: i64 = y - r
56 let dx: i64 = x - cx
57 if dx*dx + dy*dy <= r*r { spr[y*sw + x] = skin }
58 if y > 2*r { if x > sw/5 { if x < sw - sw/5 { spr[y*sw + x] = shirt } } }
59 x = x + 1
60 }
61 y = y + 1
62 }
63 return 0
64}
65// expression sprite: mode 0 = smile (corners up), mode 1 = frown (corners down)
66func mk_expr(spr: *i64, sw: i64, sh: i64, key: i64, ink: i64, mode: i64) -> i64 {
67 var i: i64 = 0
68 while i < sw*sh { spr[i] = key; i = i + 1 }
69 var x: i64 = 1
70 while x < sw - 1 {
71 var y: i64 = sh/2
72 let edge: i64 = sw/4
73 var off: i64 = 0
74 if x < edge { off = 1 }
75 if x >= sw - edge { off = 1 }
76 if mode == 0 { y = y - off + 1 }
77 if mode == 1 { y = y + off - 1 }
78 if y >= 0 { if y < sh { spr[y*sw + x] = ink } }
79 x = x + 1
80 }
81 return 0
82}
83func fill_rect(fb: *i64, W: i64, H: i64, x0: i64, y0: i64, x1: i64, y1: i64, c: i64) -> i64 {
84 var y: i64 = y0
85 if y < 0 { y = 0 }
86 while y < y1 {
87 if y >= H { y = y1 } else {
88 var x: i64 = x0
89 if x < 0 { x = 0 }
90 while x < x1 {
91 if x >= W { x = x1 } else { fb[y*W + x] = c; x = x + 1 }
92 }
93 y = y + 1
94 }
95 }
96 return 0
97}
98// scene layer table, Ren'Py-shaped: 5 rows x 7 fields [spr,x,y,alpha,z,vis,group].
99// rows 2+3 = smile+frown, BOTH declared, in exclusive group 1 (attributes, not separate scenes);
100// selection happens via vsp_setg -- never by editing the table by hand.
101func fs_layers(lay: *i64) -> i64 {
102 lay[0]=0; lay[1]=140; lay[2]=140; lay[3]=256; lay[4]=10; lay[5]=1; lay[6]=0
103 lay[7]=1; lay[8]=430; lay[9]=150; lay[10]=256; lay[11]=11; lay[12]=1; lay[13]=0
104 lay[14]=2; lay[15]=160; lay[16]=175; lay[17]=256; lay[18]=20; lay[19]=1; lay[20]=1
105 lay[21]=3; lay[22]=160; lay[23]=175; lay[24]=256; lay[25]=20; lay[26]=0; lay[27]=1
106 lay[28]=6; lay[29]=20; lay[30]=282; lay[31]=210; lay[32]=30; lay[33]=1; lay[34]=0
107 return 0
108}
109// bare background: vertical dusk gradient (shared by the scene and the T7 baseline)
110func fs_bg(fb: *i64) -> i64 {
111 var y: i64 = 0
112 while y < VG_H {
113 var x: i64 = 0
114 let rr: i64 = 24 + 40*(VG_H - y)/VG_H
115 let gg: i64 = 26 + 52*(VG_H - y)/VG_H
116 let bb: i64 = 40 + 90*(VG_H - y)/VG_H
117 let c: i64 = rr + gg*256 + bb*VG_B
118 while x < VG_W { fb[y*VG_W + x] = c; x = x + 1 }
119 y = y + 1
120 }
121 return 0
122}
123// full scene: gradient bg, the composed layer table, then a name tag block
124func fs_scene(fb: *i64, sprites: *i64, sprw: *i64, sprh: *i64, lay: *i64, key: i64) -> i64 {
125 fs_bg(fb)
126 vsp_compose(fb, VG_W, VG_H, sprites, sprw, sprh, lay, 5, key)
127 fill_rect(fb, VG_W, VG_H, 24, 262, 140, 284, 70 + 50*256 + 110*VG_B)
128 return 0
129}
130
131func main() -> i64 {
132 // ANCHOR FIRST (2026-08-04, nx_cwdguard finding): this organ reads a RELATIVE
133 // knowledge/ path, so its answer depended on where it was launched. No-op when
134 // already at the estate root, so the cron/MCP context is unchanged.
135 ep_anchor()
136 hw3("=== nx_vnsprite_gate: VN sprite compositing -- real, or a rubber stamp? ===\n\n" as *u8)
137 var pass: i64 = 0
138 var checks: i64 = 0
139 let key: i64 = 255 + 0*256 + 255*VG_B // magenta key
140 let npx: i64 = VG_W*VG_H
141 let fb: *i64 = sys_mmap((npx + 8)*8) as *i64
142 let fb2: *i64 = sys_mmap((npx + 8)*8) as *i64
143
144 // sprite tables: 0 bodyA 1 bodyB 2 smile 3 frown 4 red patch 5 blue patch 6 textbox
145 let sprites: *i64 = sys_mmap(8*8) as *i64
146 let sprw: *i64 = sys_mmap(8*8) as *i64
147 let sprh: *i64 = sys_mmap(8*8) as *i64
148 let bodyA: *i64 = sys_mmap(60*140*8) as *i64
149 mk_body(bodyA, 60, 140, key, 244 + 214*256 + 196*VG_B, 60 + 90*256 + 170*VG_B)
150 sprites[0] = bodyA as i64; sprw[0] = 60; sprh[0] = 140
151 let bodyB: *i64 = sys_mmap(60*140*8) as *i64
152 mk_body(bodyB, 60, 140, key, 232 + 190*256 + 170*VG_B, 160 + 60*256 + 80*VG_B)
153 sprites[1] = bodyB as i64; sprw[1] = 60; sprh[1] = 140
154 let sm: *i64 = sys_mmap(20*10*8) as *i64
155 mk_expr(sm, 20, 10, key, 120 + 30*256 + 30*VG_B, 0)
156 sprites[2] = sm as i64; sprw[2] = 20; sprh[2] = 10
157 let fr: *i64 = sys_mmap(20*10*8) as *i64
158 mk_expr(fr, 20, 10, key, 120 + 30*256 + 30*VG_B, 1)
159 sprites[3] = fr as i64; sprw[3] = 20; sprh[3] = 10
160 let redp: *i64 = sys_mmap(30*30*8) as *i64
161 var i: i64 = 0
162 while i < 900 { redp[i] = 200 + 60*256 + 60*VG_B; i = i + 1 }
163 sprites[4] = redp as i64; sprw[4] = 30; sprh[4] = 30
164 let blup: *i64 = sys_mmap(30*30*8) as *i64
165 i = 0
166 while i < 900 { blup[i] = 20 + 40*256 + 80*VG_B; i = i + 1 }
167 sprites[5] = blup as i64; sprw[5] = 30; sprh[5] = 30
168 let tbox: *i64 = sys_mmap(600*70*8) as *i64
169 i = 0
170 while i < 600*70 { tbox[i] = 18 + 22*256 + 40*VG_B; i = i + 1 }
171 sprites[6] = tbox as i64; sprw[6] = 600; sprh[6] = 70
172
173 // ---------- T1 z-order ----------
174 checks = checks + 1
175 let bgc: i64 = 30 + 34*256 + 44*VG_B
176 let lay: *i64 = sys_mmap(16*VSP_LROW*8) as *i64
177 vsp_clear(fb, VG_W, VG_H, bgc)
178 lay[0]=4; lay[1]=100; lay[2]=100; lay[3]=256; lay[4]=1; lay[5]=1; lay[6]=0
179 lay[7]=5; lay[8]=110; lay[9]=100; lay[10]=256; lay[11]=2; lay[12]=1; lay[13]=0
180 vsp_compose(fb, VG_W, VG_H, sprites, sprw, sprh, lay, 2, key)
181 let pA: i64 = fb[105*VG_W + 115]
182 lay[4]=2; lay[11]=1
183 vsp_clear(fb, VG_W, VG_H, bgc)
184 vsp_compose(fb, VG_W, VG_H, sprites, sprw, sprh, lay, 2, key)
185 let pB: i64 = fb[105*VG_W + 115]
186 var t1ok: i64 = 0
187 if pA == 20 + 40*256 + 80*VG_B { if pB == 200 + 60*256 + 60*VG_B { t1ok = 1 } }
188 if t1ok == 1 {
189 hw3("T1 GREEN z-order real: overlap pixel = top layer both ways (blue on top, then red after the z swap)\n" as *u8)
190 pass = pass + 1
191 } else {
192 hw3("T1 RED z-order broken: got " as *u8); hn3(pA); hw3(" then " as *u8); hn3(pB); hw3("\n" as *u8)
193 }
194
195 // ---------- T2 alpha exact + key transparent ----------
196 checks = checks + 1
197 vsp_clear(fb, VG_W, VG_H, 20 + 40*256 + 80*VG_B)
198 vsp_blit(fb, VG_W, VG_H, redp, 30, 30, 50, 50, key, 128)
199 let pm: i64 = fb[65*VG_W + 65]
200 let expct: i64 = 110 + 50*256 + 70*VG_B
201 vsp_blit(fb, VG_W, VG_H, sm, 20, 10, 300, 50, key, 256)
202 let pk: i64 = fb[51*VG_W + 305]
203 var t2ok: i64 = 0
204 if pm == expct { if pk == 20 + 40*256 + 80*VG_B { t2ok = 1 } }
205 if t2ok == 1 {
206 hw3("T2 GREEN alpha exact ((200,60,60) at 128 over (20,40,80) = (110,50,70)) and key pixels fully transparent\n" as *u8)
207 pass = pass + 1
208 } else {
209 hw3("T2 RED blend/key broken: mix=" as *u8); hn3(pm); hw3(" want " as *u8); hn3(expct)
210 hw3(" keyprobe=" as *u8); hn3(pk); hw3("\n" as *u8)
211 }
212
213 // ---------- T3 clip canaries ----------
214 checks = checks + 1
215 i = 0
216 while i < 8 { fb[npx + i] = VG_CANARY; i = i + 1 }
217 vsp_blit(fb, VG_W, VG_H, tbox, 600, 70, VG_W - 20, VG_H - 20, key, 256)
218 vsp_blit(fb, VG_W, VG_H, tbox, 600, 70, 0 - 500, 0 - 30, key, 256)
219 vsp_blit(fb, VG_W, VG_H, redp, 30, 30, VG_W + 5, 10, key, 256)
220 var canok: i64 = 1
221 i = 0
222 while i < 8 { if fb[npx + i] != VG_CANARY { canok = 0 } i = i + 1 }
223 if canok == 1 {
224 hw3("T3 GREEN clipped blits: off-edge sprites on all sides, 8 canary cells intact\n" as *u8)
225 pass = pass + 1
226 } else {
227 hw3("T3 RED OUT-OF-BOUNDS WRITE past the framebuffer\n" as *u8)
228 }
229
230 // ---------- T4 expression swap visible (via the GROUP call, never hand-editing the table) ----------
231 checks = checks + 1
232 fs_layers(lay)
233 vsp_setg(lay, 5, 1, 2)
234 fs_scene(fb, sprites, sprw, sprh, lay, key)
235 vsp_setg(lay, 5, 1, 3)
236 fs_scene(fb2, sprites, sprw, sprh, lay, key)
237 var diff: i64 = 0
238 i = 0
239 while i < npx { if fb[i] != fb2[i] { diff = diff + 1 } i = i + 1 }
240 vsp_setg(lay, 5, 1, 3)
241 fs_scene(fb, sprites, sprw, sprh, lay, key)
242 var same: i64 = 0
243 i = 0
244 while i < npx { if fb[i] != fb2[i] { same = same + 1 } i = i + 1 }
245 var t4ok: i64 = 0
246 if diff >= 20 { if same == 0 { t4ok = 1 } }
247 if t4ok == 1 {
248 hw3("T4 GREEN expression swap visible: smile vs frown differ in " as *u8); hn3(diff)
249 hw3(" px; same expression twice differs in 0\n" as *u8)
250 pass = pass + 1
251 } else {
252 hw3("T4 RED expression change invisible or nondeterministic: diff=" as *u8); hn3(diff)
253 hw3(" same=" as *u8); hn3(same); hw3("\n" as *u8)
254 }
255
256 // ---------- T5 scene state round-trip through gs_save ----------
257 checks = checks + 1
258 fs_layers(lay)
259 vsp_setg(lay, 5, 1, 2)
260 fs_scene(fb, sprites, sprw, sprh, lay, key)
261 let ck0: i64 = vsp_fbck(fb, VG_W, VG_H)
262 let sret: i64 = gs_save("knowledge/nx_vnsprite_scene.sav" as *u8, VG_SCHEMA, lay, 35, VG_STAMP)
263 i = 0
264 while i < 35 { lay[i] = 0; i = i + 1 }
265 let atp: *i64 = sys_mmap(32) as *i64
266 let lret: i64 = gs_load("knowledge/nx_vnsprite_scene.sav" as *u8, lay, 35, atp)
267 fs_scene(fb2, sprites, sprw, sprh, lay, key)
268 let ck1: i64 = vsp_fbck(fb2, VG_W, VG_H)
269 var t5ok: i64 = 0
270 if sret > 0 { if lret >= 35 { if ck0 == ck1 { t5ok = 1 } } }
271 if t5ok == 1 {
272 hw3("T5 GREEN scene state round-trips: gs_save -> ZEROED -> gs_load -> recompose, frame ck " as *u8)
273 hn3(ck1); hw3(" identical\n" as *u8)
274 pass = pass + 1
275 } else {
276 hw3("T5 RED save round-trip broke the scene: ck " as *u8); hn3(ck0); hw3(" vs " as *u8); hn3(ck1)
277 hw3(" (save rc=" as *u8); hn3(sret); hw3(" load rc=" as *u8); hn3(lret); hw3(")\n" as *u8)
278 }
279
280 // ---------- T6 determinism ----------
281 checks = checks + 1
282 fs_scene(fb, sprites, sprw, sprh, lay, key)
283 fs_scene(fb2, sprites, sprw, sprh, lay, key)
284 let ckd1: i64 = vsp_fbck(fb, VG_W, VG_H)
285 let ckd2: i64 = vsp_fbck(fb2, VG_W, VG_H)
286 if ckd1 == ckd2 {
287 hw3("T6 GREEN deterministic: full scene composed twice, identical ck " as *u8); hn3(ckd1); hw3("\n" as *u8)
288 pass = pass + 1
289 } else {
290 hw3("T6 RED nondeterministic composition\n" as *u8)
291 }
292
293 // ---------- T7 anti-vacuity: scene vs bare background ----------
294 checks = checks + 1
295 fs_bg(fb2)
296 var ink: i64 = 0
297 var c1: i64 = 0 - 1
298 var c2: i64 = 0 - 1
299 var c3: i64 = 0 - 1
300 var c4: i64 = 0 - 1
301 var c5: i64 = 0 - 1
302 var ncol: i64 = 0
303 i = 0
304 while i < npx {
305 if fb[i] != fb2[i] {
306 ink = ink + 1
307 let v: i64 = fb[i]
308 var seen: i64 = 0
309 if v == c1 { seen = 1 }
310 if v == c2 { seen = 1 }
311 if v == c3 { seen = 1 }
312 if v == c4 { seen = 1 }
313 if v == c5 { seen = 1 }
314 if seen == 0 { if ncol < 5 {
315 if ncol == 0 { c1 = v }
316 if ncol == 1 { c2 = v }
317 if ncol == 2 { c3 = v }
318 if ncol == 3 { c4 = v }
319 if ncol == 4 { c5 = v }
320 ncol = ncol + 1
321 } }
322 }
323 i = i + 1
324 }
325 var t7ok: i64 = 0
326 if ink >= 500 { if ncol >= 5 { t7ok = 1 } }
327 if t7ok == 1 {
328 hw3("T7 GREEN anti-vacuity: scene differs from bare bg in " as *u8); hn3(ink)
329 hw3(" px with >=5 distinct sprite colors\n" as *u8)
330 pass = pass + 1
331 } else {
332 hw3("T7 RED vacuous scene: ink=" as *u8); hn3(ink); hw3(" colors=" as *u8); hn3(ncol); hw3("\n" as *u8)
333 }
334
335 // ---------- T8 scene artifact ----------
336 checks = checks + 1
337 write_png(fb, VG_W, VG_H, "knowledge/nx_vnsprite_scene.png" as *u8)
338 let lenp: *i64 = sys_mmap(8) as *i64
339 lenp[0] = 0
340 let pb: *u8 = sys_read_file("knowledge/nx_vnsprite_scene.png" as *u8, lenp)
341 var t8ok: i64 = 0
342 if (pb as i64) != 0 { if lenp[0] > 2000 { t8ok = 1 } }
343 if t8ok == 1 {
344 hw3("T8 GREEN scene artifact written: knowledge/nx_vnsprite_scene.png " as *u8); hn3(lenp[0])
345 hw3(" bytes (gradient bg + 2 characters + alpha textbox + name tag)\n" as *u8)
346 pass = pass + 1
347 } else {
348 hw3("T8 RED scene artifact missing or trivial: bytes=" as *u8); hn3(lenp[0]); hw3("\n" as *u8)
349 }
350
351 // ---------- T9 group exclusivity (the layeredimage bar) ----------
352 checks = checks + 1
353 // smile's middle-row ink sits at scene y=175+6, frown's at y=175+4 (mk_expr geometry), x=170
354 let inkc: i64 = 120 + 30*256 + 30*VG_B
355 fs_layers(lay)
356 let sh1: i64 = vsp_setg(lay, 5, 1, 2)
357 fs_scene(fb, sprites, sprw, sprh, lay, key)
358 let sA: i64 = fb[181*VG_W + 170]
359 let sB: i64 = fb[179*VG_W + 170]
360 let sh2: i64 = vsp_setg(lay, 5, 1, 3)
361 fs_scene(fb2, sprites, sprw, sprh, lay, key)
362 let fA: i64 = fb2[181*VG_W + 170]
363 let fB: i64 = fb2[179*VG_W + 170]
364 var t9ok: i64 = 0
365 if sh1 == 1 { if sh2 == 1 { if sA == inkc { if sB != inkc { if fB == inkc { if fA != inkc { t9ok = 1 } } } } } }
366 if t9ok == 1 {
367 hw3("T9 GREEN group-exclusive attributes: ONE vsp_setg call swaps smile<->frown; exactly one\n" as *u8)
368 hw3(" attribute of the group composes each time (pixel-probed both ways)\n" as *u8)
369 pass = pass + 1
370 } else {
371 hw3("T9 RED attribute group broken: shown=" as *u8); hn3(sh1); hn3(sh2)
372 hw3(" probes " as *u8); hn3(sA); hw3(" " as *u8); hn3(sB); hw3(" " as *u8); hn3(fA)
373 hw3(" " as *u8); hn3(fB); hw3("\n" as *u8)
374 }
375
376 // ---------- T10 dissolve exact ----------
377 checks = checks + 1
378 let fbd: *i64 = sys_mmap(npx*8) as *i64
379 vsp_dissolve(fb, fb2, fbd, npx, 0)
380 let ckda: i64 = vsp_fbck(fbd, VG_W, VG_H)
381 let ckfa: i64 = vsp_fbck(fb, VG_W, VG_H)
382 vsp_dissolve(fb, fb2, fbd, npx, 256)
383 let ckdb: i64 = vsp_fbck(fbd, VG_W, VG_H)
384 let ckfb: i64 = vsp_fbck(fb2, VG_W, VG_H)
385 vsp_dissolve(fb, fb2, fbd, npx, 128)
386 // probe the smile-ink pixel: A=ink(120,30,30) B=underlying skin/shirt -- expect the exact 50/50 mix
387 let a1: i64 = fb[181*VG_W + 170]
388 let b1: i64 = fb2[181*VG_W + 170]
389 let mr: i64 = ((a1 % 256) + (b1 % 256))/2
390 let mg: i64 = (((a1/256) % 256) + ((b1/256) % 256))/2
391 let mb2: i64 = (((a1/VG_B) % 256) + ((b1/VG_B) % 256))/2
392 let want: i64 = mr + mg*256 + mb2*VG_B
393 let got: i64 = fbd[181*VG_W + 170]
394 var t10ok: i64 = 0
395 if ckda == ckfa { if ckdb == ckfb { if got == want { t10ok = 1 } } }
396 if t10ok == 1 {
397 hw3("T10 GREEN dissolve exact: t=0 == frame A, t=256 == frame B (full-frame cks), t=128 = exact\n" as *u8)
398 hw3(" integer channel mix at the probed pixel\n" as *u8)
399 pass = pass + 1
400 } else {
401 hw3("T10 RED dissolve broken: endpoints " as *u8); hn3(ckda); hw3("/" as *u8); hn3(ckfa)
402 hw3(" " as *u8); hn3(ckdb); hw3("/" as *u8); hn3(ckfb)
403 hw3(" mid got " as *u8); hn3(got); hw3(" want " as *u8); hn3(want); hw3("\n" as *u8)
404 }
405
406 hw3("\n=== nx_vnsprite_gate " as *u8); hn3(pass); hw3("/" as *u8); hn3(checks)
407 // MIGRATED onto nx_gate_verdict by nx_gate_dry_apply (D001, minimal form): every check
408 // row above is untouched, so the PASS/FAIL vector cannot change; only the hand-rolled
409 // verdict emission is replaced by the ONE shared base class. Proven by nx_gate_migrate verify.
410 let ctr__dry: *i64 = gv_ctr()
411 ctr__dry[0] = pass
412 ctr__dry[1] = checks
413 let rc__dry: i64 = gv_verdict("VNSPRITE-GATE" as *u8, ctr__dry, "teeth unchanged; verdict emission migrated onto the shared base class" as *u8)
414 sys_exit(rc__dry)
415 return rc__dry
416}