nx_nxa_tier_gate_pre_region_t143.nx source
↩ module page · 417 lines · 21947 B
1// nx_nxa_tier_gate.nx -- THE GATE FOR THE INGEST TIER LADDER (nx_nxa_tier, /compare/modding MD5).
2//
3// SUBJECT: the nx_nxa_tier ELF, forked for real on the banked pre-TEXM house asset (13 sections, TEXC present,
4// 14,164 verts) -- a real artifact that is READ, never written. Every tooth asserts an exit code or a byte read
5// back out of the emitted tier through the format's own verifier (nxa_find checks the TOC and every section
6// checksum before returning), so a tier that merely EXISTS cannot pass.
7//
8// THE DANGEROUS FAILURES THIS GATE EXISTS TO CATCH: a tier whose weights no longer sum to 4096 or name a joint
9// past the skeleton (the pose player would read that as a broken rig), a tier that quietly dropped SKEL or
10// TEXM (a rig-less or map-less cast member wearing a success receipt), a tier that grew or moved outside the
11// source's own bounding box, and a budget that silently UPSAMPLED. Each has a tooth; three have neg-controls.
12//
13// FIXTURES AT RUNTIME in /tmp/nx_nxa_tier_gate/, every output unlinked at SETUP and the unlink asserted, so the
14// gate is idempotent. The truncated fixture and the ladder conf are assembled here, never read from source.
15// license_tier: ORIGINAL No hw writes (Rule 26). expect_exit: 0
16import "nx_syscalls.nx"
17import "nx_gate_verdict.nx"
18import "nx_tool_run.nx"
19import "nx_nxa.nx"
20
21const TG_SUBJECT_DEFAULT: *u8 = "_offc/nx_nxa_tier.elf"
22// FIRST-SHIP LADDER (measured 2026-09-05): on the first nx_organ_ship there is no _offc twin yet -- the ship's PROVE
23// ran this gate with no argument, the default resolved to an absent file, every fork returned 127 and the ship
24// REFUSED a correct organ (5 of 20 RED, all three from exit 127). A gate must find the artifact under test in the
25// ship's own order -- the promoted offc twin, the artifact STAGED at the serving root, then the sovereign build
26// fossil -- and SAY which rung it took, so a proof about a stage is never mistaken for a proof about the twin.
27const TG_SUBJECT_STAGED: *u8 = "nx_nxa_tier.sov.elf.new"
28const TG_SUBJECT_STAGED_UP: *u8 = "../nx_nxa_tier.sov.elf.new"
29const TG_SUBJECT_BUILD: *u8 = "_build/nx_nxa_tier.sov.elf"
30const TG_SUBJECT_BUILD_DOWN: *u8 = "buildroot/_build/nx_nxa_tier.sov.elf"
31const TG_PLAYER: *u8 = "/volume1/homes/elderwesto/nishihost/nx_nxa_play.elf"
32const TG_ASSET: *u8 = "/volume1/homes/elderwesto/nishihost/knowledge/bank/ref9d.nxa.pretexm-20260823"
33const TG_DIR: *u8 = "/tmp/nx_nxa_tier_gate"
34const TG_OUT1: *u8 = "/tmp/nx_nxa_tier_gate/t1.nxa"
35const TG_OUT2: *u8 = "/tmp/nx_nxa_tier_gate/t2.nxa"
36const TG_OUT3: *u8 = "/tmp/nx_nxa_tier_gate/over.nxa"
37const TG_OUT4: *u8 = "/tmp/nx_nxa_tier_gate/tiny.nxa"
38const TG_OUT5: *u8 = "/tmp/nx_nxa_tier_gate/fromtrunc.nxa"
39const TG_TRUNC: *u8 = "/tmp/nx_nxa_tier_gate/trunc.nxa"
40const TG_LADDER: *u8 = "/tmp/nx_nxa_tier_gate/ladder.conf"
41const TG_PFX: *u8 = "/tmp/nx_nxa_tier_gate/lad"
42const TG_LAD16: *u8 = "/tmp/nx_nxa_tier_gate/lad_t16k.nxa"
43const TG_LAD4: *u8 = "/tmp/nx_nxa_tier_gate/lad_t4k.nxa"
44const TG_LAD1: *u8 = "/tmp/nx_nxa_tier_gate/lad_t1k.nxa"
45const TG_LADDER_ROWS: *u8 = "# runtime fixture\ntier|t16k|16384|above the source, must be skipped\ntier|t4k|4096|the rig floor\ntier|t1k|1024|the far tier\n"
46// the budget is the donor-derived rig floor (charsim bar, AF_VERT_MIN 4000): under the 14,164-vert source
47const TG_BUDGET: *u8 = "4000"
48const TG_BUDGET_N: i64 = 4000
49const TG_OVER: *u8 = "20000" // at or above the source vertex count: must REFUSE
50const TG_TINY: *u8 = "2" // under the 3-vertex floor: must REFUSE
51const TG_TRUNC_BYTES: i64 = 600 // TOC intact, payload gone -- the corrupt-input control
52const TG_LADDER_VERB: *u8 = "ladder"
53const TG_EXIT_OK: i64 = 0
54const TG_EXIT_REFUSE: i64 = 3
55const TG_EXEC_NOT_FOUND: i64 = 127
56const TG_CAPCAP: i64 = 262144
57const TG_ARGVN: i64 = 8
58const TG_MODEDIR: i64 = 493
59const TG_WORD: i64 = 8
60const TG_HDR: i64 = 32
61const TG_TOCE: i64 = 32
62const TG_SKIN_W: i64 = 8
63const TG_SKIN_J: i64 = 4
64const TG_Q12: i64 = 4096
65const TG_MIN_VERTS: i64 = 3
66const TG_ASCII_ZERO: i64 = 48
67const TG_ASCII_NINE: i64 = 57
68const TG_BBOX_W: i64 = 6
69
70func tg_slen(s: *u8) -> i64 { var n: i64 = 0; while s[n] != (0 as u8) { n = n + 1 } return n }
71func tg_rd64(b: *u8, off: i64) -> i64 { let p: *i64 = ((b as i64) + off) as *i64; return p[0] }
72func tg_exists(path: *u8) -> i64 {
73 let lp: *i64 = sys_mmap(TG_WORD*2) as *i64
74 let b: *u8 = sys_read_file(path, lp)
75 if (b as i64) == 0 { return 0 }
76 return 1
77}
78func tg_load(path: *u8, lenout: *i64) -> *u8 {
79 let lp: *i64 = sys_mmap(TG_WORD*2) as *i64
80 let b: *u8 = sys_read_file(path, lp)
81 if (b as i64) == 0 { lenout[0] = 0; return 0 as *u8 }
82 lenout[0] = lp[0]
83 return b
84}
85func tg_run3(subject: *u8, a1: *u8, a2: *u8, a3: *u8, out: *u8, olen: *i64) -> i64 {
86 let av: *i64 = sys_mmap(TG_WORD*TG_ARGVN) as *i64
87 av[0] = subject as i64
88 av[1] = a1 as i64
89 av[2] = a2 as i64
90 av[3] = a3 as i64
91 av[4] = 0
92 return tr_run_capture(subject, av, out, TG_CAPCAP, olen)
93}
94func tg_run4(subject: *u8, a1: *u8, a2: *u8, a3: *u8, a4: *u8, out: *u8, olen: *i64) -> i64 {
95 let av: *i64 = sys_mmap(TG_WORD*TG_ARGVN) as *i64
96 av[0] = subject as i64
97 av[1] = a1 as i64
98 av[2] = a2 as i64
99 av[3] = a3 as i64
100 av[4] = a4 as i64
101 av[5] = 0
102 return tr_run_capture(subject, av, out, TG_CAPCAP, olen)
103}
104func tg_run1(subject: *u8, a1: *u8, out: *u8, olen: *i64) -> i64 {
105 let av: *i64 = sys_mmap(TG_WORD*TG_ARGVN) as *i64
106 av[0] = subject as i64
107 av[1] = a1 as i64
108 av[2] = 0
109 return tr_run_capture(subject, av, out, TG_CAPCAP, olen)
110}
111// the integer that follows <key> in a captured receipt, or -1 when the key is absent
112func tg_kv(buf: *u8, n: i64, key: *u8) -> i64 {
113 let kl: i64 = tg_slen(key)
114 var i: i64 = 0
115 while i + kl <= n {
116 var m: i64 = 0
117 var j: i64 = 0
118 while j < kl { if buf[i + j] == key[j] { m = m + 1 } j = j + 1 }
119 if m == kl {
120 var v: i64 = 0
121 var p: i64 = i + kl
122 var any: i64 = 0
123 while p < n {
124 let c: i64 = buf[p] as i64
125 if c < TG_ASCII_ZERO { return v }
126 if c > TG_ASCII_NINE { return v }
127 v = v * 10 + (c - TG_ASCII_ZERO)
128 any = 1
129 p = p + 1
130 }
131 if any == 1 { return v }
132 return 0 - 1
133 }
134 i = i + 1
135 }
136 return 0 - 1
137}
138func tg_has(buf: *u8, n: i64, key: *u8) -> i64 { if tg_kv(buf, n, key) >= 0 { return 1 } return 0 }
139// the word length of section <tag> from a file's TOC, walking the whole table; -1 when absent
140func tg_toc_wl(b: *u8, tag: i64) -> i64 {
141 let ns: i64 = tg_rd64(b, 16)
142 var s: i64 = 0
143 while s < ns {
144 let e: i64 = TG_HDR + s*TG_TOCE
145 if tg_rd64(b, e) == tag { return tg_rd64(b, e + 16) }
146 s = s + 1
147 }
148 return 0 - 1
149}
150func tg_copyable(tag: i64) -> i64 {
151 if tag == nxa_tag4("SKEL" as *u8) { return 1 }
152 if tag == nxa_tag4("ANIM" as *u8) { return 1 }
153 if tag == nxa_tag4("POSE" as *u8) { return 1 }
154 if tag == nxa_tag4("MATL" as *u8) { return 1 }
155 if tag == nxa_tag4("TEXM" as *u8) { return 1 }
156 if tag == nxa_tag4("HSTR" as *u8) { return 1 }
157 return 0
158}
159// bbox of a verified VERT section into out[0..6) = minx maxx miny maxy minz maxz; returns nverts or -1
160func tg_bbox(b: *u8, flen: i64, out: *i64) -> i64 {
161 let vwo: i64 = nxa_find(b, flen, nxa_tag4("VERT" as *u8))
162 if vwo < 0 { return 0 - 1 }
163 let w: *i64 = b as *i64
164 let nv: i64 = w[vwo]
165 if nv < 1 { return 0 - 1 }
166 let vw: *i64 = ((w as i64) + (vwo + 1)*8) as *i64
167 out[0] = vw[0]; out[1] = vw[0]; out[2] = vw[1]; out[3] = vw[1]; out[4] = vw[2]; out[5] = vw[2]
168 var v: i64 = 1
169 while v < nv {
170 let x: i64 = vw[v*3]; let y: i64 = vw[v*3 + 1]; let z: i64 = vw[v*3 + 2]
171 if x < out[0] { out[0] = x }
172 if x > out[1] { out[1] = x }
173 if y < out[2] { out[2] = y }
174 if y > out[3] { out[3] = y }
175 if z < out[4] { out[4] = z }
176 if z > out[5] { out[5] = z }
177 v = v + 1
178 }
179 return nv
180}
181func tg_write_bytes(path: *u8, b: *u8, n: i64) -> i64 {
182 let fd: i64 = sys_openat_wr(path, MODE_0644)
183 if fd < 0 { return 0 - 1 }
184 let wr: i64 = sys_write(fd, b, n)
185 sys_close(fd)
186 if wr != n { return 0 - 1 }
187 return n
188}
189
190func main(argc: i64, argv: *i64) -> i64 {
191 let ctr: *i64 = gv_ctr()
192 gv_head("nx_nxa_tier gate -- a smaller NXA under a declared budget, the rig and maps intact, no upsample ever" as *u8)
193 var subject: *u8 = TG_SUBJECT_DEFAULT
194 var rung: *u8 = "argv" as *u8
195 if argc >= 2 { subject = argv[1] as *u8 } else {
196 rung = "offc-twin" as *u8
197 if tg_exists(TG_SUBJECT_DEFAULT) == 0 { subject = TG_SUBJECT_STAGED; rung = "staged-at-serving-root" as *u8 }
198 if tg_exists(subject) == 0 { subject = TG_SUBJECT_STAGED_UP; rung = "staged-at-serving-root-from-buildroot" as *u8 }
199 if tg_exists(subject) == 0 { subject = TG_SUBJECT_BUILD; rung = "sovereign-build-fossil" as *u8 }
200 if tg_exists(subject) == 0 { subject = TG_SUBJECT_BUILD_DOWN; rung = "sovereign-build-fossil-from-serving-root" as *u8 }
201 }
202 gv_puts(" subject: " as *u8); gv_puts(subject); gv_puts(" (rung=" as *u8); gv_puts(rung); gv_puts(")\n" as *u8)
203 gv_check("setup-subject-artifact-exists-on-the-first-ship-ladder (named rung, never a silent 127)" as *u8, tg_exists(subject), ctr)
204 gv_puts(" asset: " as *u8); gv_puts(TG_ASSET); gv_puts("\n\n" as *u8)
205
206 // ---- SETUP ----
207 sys_mkdir(TG_DIR, TG_MODEDIR)
208 sys_unlinkat(TG_OUT1); sys_unlinkat(TG_OUT2); sys_unlinkat(TG_OUT3); sys_unlinkat(TG_OUT4); sys_unlinkat(TG_OUT5)
209 sys_unlinkat(TG_TRUNC); sys_unlinkat(TG_LADDER); sys_unlinkat(TG_LAD16); sys_unlinkat(TG_LAD4); sys_unlinkat(TG_LAD1)
210 var clean: i64 = 0
211 if tg_exists(TG_OUT1) == 0 { if tg_exists(TG_OUT2) == 0 { if tg_exists(TG_OUT3) == 0 { if tg_exists(TG_LAD4) == 0 { clean = 1 } } } }
212 gv_check("setup-outputs-absent-before-measuring (gate is idempotent)" as *u8, clean, ctr)
213 let cap: *u8 = sys_mmap(TG_CAPCAP)
214 let olen: *i64 = sys_mmap(TG_WORD*2) as *i64
215 let lin: *i64 = sys_mmap(TG_WORD*2) as *i64
216 let bin: *u8 = tg_load(TG_ASSET, lin)
217 let inbox: *i64 = sys_mmap(TG_WORD*TG_BBOX_W) as *i64
218 let nv_in: i64 = tg_bbox(bin, lin[0], inbox)
219 let w_in: *i64 = bin as *i64
220 var in_ok: i64 = 0
221 if nv_in > TG_BUDGET_N { in_ok = 1 }
222 gv_puts(" input verts=" as *u8); gv_num(nv_in); gv_puts(" bytes=" as *u8); gv_num(lin[0]); gv_puts("\n" as *u8)
223 gv_check("setup-real-asset-readable-and-ABOVE-the-budget (a budget the source already meets cannot test a tier)" as *u8, in_ok, ctr)
224 var in_texc: i64 = 0
225 if nxa_find(bin, lin[0], nxa_tag4("TEXC" as *u8)) >= 0 { in_texc = 1 }
226 var in_skin: i64 = 0
227 if nxa_find(bin, lin[0], nxa_tag4("SKIN" as *u8)) >= 0 { in_skin = 1 }
228 var in_rig: i64 = 0
229 if in_texc == 1 { if in_skin == 1 { in_rig = 1 } }
230 gv_check("setup-asset-carries-SKIN-and-TEXC (the rows the tier must carry through)" as *u8, in_rig, ctr)
231
232 // ---- T1: one tier at the rig floor ----
233 let rc1: i64 = tg_run3(subject, TG_ASSET, TG_OUT1, TG_BUDGET, cap, olen)
234 gv_puts(" [T1] tier rc=" as *u8); gv_num(rc1); gv_puts(" receipt_bytes=" as *u8); gv_num(olen[0]); gv_puts("\n" as *u8)
235 var t1: i64 = 0
236 if rc1 == TG_EXIT_OK { t1 = 1 }
237 gv_check("tier-at-the-rig-floor-exits-OK" as *u8, t1, ctr)
238 let r_out_verts: i64 = tg_kv(cap, olen[0], "out_verts=" as *u8)
239 let r_in_tris: i64 = tg_kv(cap, olen[0], "in_tris=" as *u8)
240 let r_out_tris: i64 = tg_kv(cap, olen[0], " out_tris=" as *u8)
241 let r_coll: i64 = tg_kv(cap, olen[0], "collapsed_tris=" as *u8)
242 let r_secin: i64 = tg_kv(cap, olen[0], "sections_in=" as *u8)
243 let r_sum: i64 = tg_kv(cap, olen[0], " sum=" as *u8)
244
245 // ---- T2: the tier verifies through the format's own reader and is SMALLER, within budget ----
246 let l1: *i64 = sys_mmap(TG_WORD*2) as *i64
247 let b1: *u8 = tg_load(TG_OUT1, l1)
248 var nv1: i64 = 0 - 1
249 var nt1: i64 = 0 - 1
250 var nj1: i64 = 0 - 1
251 let w1: *i64 = b1 as *i64
252 if (b1 as i64) != 0 {
253 let vo: i64 = nxa_find(b1, l1[0], nxa_tag4("VERT" as *u8))
254 let to: i64 = nxa_find(b1, l1[0], nxa_tag4("TRIS" as *u8))
255 let so: i64 = nxa_find(b1, l1[0], nxa_tag4("SKEL" as *u8))
256 if vo >= 0 { nv1 = w1[vo] }
257 if to >= 0 { nt1 = w1[to] }
258 if so >= 0 { nj1 = w1[so] }
259 }
260 gv_puts(" [T2] tier verts=" as *u8); gv_num(nv1); gv_puts(" tris=" as *u8); gv_num(nt1); gv_puts(" joints=" as *u8); gv_num(nj1); gv_puts(" bytes=" as *u8); gv_num(l1[0]); gv_puts("\n" as *u8)
261 var t2: i64 = 0
262 if nv1 >= TG_MIN_VERTS { if nv1 <= TG_BUDGET_N { if nv1 < nv_in { if nt1 >= 1 { t2 = 1 } } } }
263 gv_check("tier-verifies-through-nxa_find-and-is-under-budget-and-under-the-source (checksums, count, shrink)" as *u8, t2, ctr)
264
265 // ---- T3: every SKIN row still sums to 4096 and names joints inside the carried SKEL, full population ----
266 var skin_ok: i64 = 0
267 var bad_rows: i64 = 0
268 var audited: i64 = 0
269 if (b1 as i64) != 0 {
270 let ko: i64 = nxa_find(b1, l1[0], nxa_tag4("SKIN" as *u8))
271 if ko >= 0 { if w1[ko] == nv1 { if nj1 > 0 {
272 var r: i64 = 0
273 while r < nv1 {
274 var sum: i64 = 0
275 var jbad: i64 = 0
276 var f: i64 = 0
277 while f < TG_SKIN_J {
278 let j: i64 = w1[ko + 1 + r*TG_SKIN_W + f]
279 let wq: i64 = w1[ko + 1 + r*TG_SKIN_W + TG_SKIN_J + f]
280 sum = sum + wq
281 if j < 0 { jbad = 1 }
282 if j >= nj1 { jbad = 1 }
283 f = f + 1
284 }
285 if sum != TG_Q12 { bad_rows = bad_rows + 1 } else { if jbad == 1 { bad_rows = bad_rows + 1 } }
286 audited = audited + 1
287 r = r + 1
288 }
289 if audited == nv1 { if bad_rows == 0 { skin_ok = 1 } }
290 } } }
291 }
292 gv_puts(" [T3] skin rows audited=" as *u8); gv_num(audited); gv_puts(" bad=" as *u8); gv_num(bad_rows); gv_puts("\n" as *u8)
293 gv_check("every-tier-vertex-weights-sum-4096-and-name-a-joint-inside-SKEL (full population, count equals verts)" as *u8, skin_ok, ctr)
294
295 // ---- T4: TEXC carried, one row per tier vertex ----
296 var texc_ok: i64 = 0
297 if (b1 as i64) != 0 {
298 let xo: i64 = nxa_find(b1, l1[0], nxa_tag4("TEXC" as *u8))
299 if xo >= 0 { if w1[xo] == nv1 { if w1[xo + 1] >= 1 { texc_ok = 1 } } }
300 }
301 gv_check("TEXC-carried-with-one-row-per-tier-vertex (the atlas still samples)" as *u8, texc_ok, ctr)
302
303 // ---- T5: the tier lies inside the source bbox (a centroid can never leave its members' hull) ----
304 let obox: *i64 = sys_mmap(TG_WORD*TG_BBOX_W) as *i64
305 var inside: i64 = 0
306 if (b1 as i64) != 0 { if tg_bbox(b1, l1[0], obox) > 0 {
307 if obox[0] >= inbox[0] { if obox[1] <= inbox[1] { if obox[2] >= inbox[2] { if obox[3] <= inbox[3] { if obox[4] >= inbox[4] { if obox[5] <= inbox[5] { inside = 1 } } } } } }
308 } }
309 gv_puts(" [T5] source bbox x=" as *u8); gv_num(inbox[0]); gv_puts(".." as *u8); gv_num(inbox[1]); gv_puts(" tier bbox x=" as *u8); gv_num(obox[0]); gv_puts(".." as *u8); gv_num(obox[1]); gv_puts("\n" as *u8)
310 gv_check("tier-bbox-inside-source-bbox-on-all-three-axes" as *u8, inside, ctr)
311
312 // ---- T6: every copyable section of the source survives with its exact wordlen (SKEL at least) ----
313 var copy_want: i64 = 0
314 var copy_got: i64 = 0
315 if (b1 as i64) != 0 {
316 let ns_in: i64 = tg_rd64(bin, 16)
317 var s: i64 = 0
318 while s < ns_in {
319 let e: i64 = TG_HDR + s*TG_TOCE
320 let tag: i64 = tg_rd64(bin, e)
321 if tg_copyable(tag) == 1 {
322 copy_want = copy_want + 1
323 if tg_toc_wl(b1, tag) == tg_rd64(bin, e + 16) { copy_got = copy_got + 1 }
324 }
325 s = s + 1
326 }
327 }
328 gv_puts(" [T6] copyable sections carried=" as *u8); gv_num(copy_got); gv_puts(" of " as *u8); gv_num(copy_want); gv_puts("\n" as *u8)
329 var t6: i64 = 0
330 if copy_want >= 1 { if copy_got == copy_want { t6 = 1 } }
331 gv_check("every-copyable-section-survives-with-its-exact-wordlen (SKEL ANIM POSE MATL TEXM HSTR, denominator from the source)" as *u8, t6, ctr)
332
333 // ---- T7: the receipt's arithmetic closes and agrees with the bytes ----
334 gv_puts(" [T7] receipt out_verts=" as *u8); gv_num(r_out_verts); gv_puts(" in_tris=" as *u8); gv_num(r_in_tris); gv_puts(" out_tris=" as *u8); gv_num(r_out_tris); gv_puts(" collapsed=" as *u8); gv_num(r_coll); gv_puts(" sections_in=" as *u8); gv_num(r_secin); gv_puts(" sum=" as *u8); gv_num(r_sum); gv_puts("\n" as *u8)
335 var t7: i64 = 0
336 if r_out_verts == nv1 { if r_out_tris == nt1 { if r_in_tris == r_out_tris + r_coll { if r_secin == r_sum { if r_secin >= 1 { t7 = 1 } } } } }
337 gv_check("receipt-partition-closes (kept + collapsed = source tris, remapped + copied + dropped = sections) and matches the bytes" as *u8, t7, ctr)
338
339 // ---- T8: determinism -- the same input and budget emit byte-identical bytes ----
340 let rc2: i64 = tg_run3(subject, TG_ASSET, TG_OUT2, TG_BUDGET, cap, olen)
341 let l2: *i64 = sys_mmap(TG_WORD*2) as *i64
342 let b2: *u8 = tg_load(TG_OUT2, l2)
343 var same: i64 = 0
344 if rc2 == TG_EXIT_OK { if (b2 as i64) != 0 { if l2[0] == l1[0] { if l1[0] > 0 {
345 var diff: i64 = 0
346 var k: i64 = 0
347 while k < l1[0] { if b1[k] != b2[k] { diff = diff + 1 } k = k + 1 }
348 if diff == 0 { same = 1 }
349 } } } }
350 gv_check("determinism-second-run-is-byte-identical" as *u8, same, ctr)
351
352 // ---- T9: neg-control -- a budget at or above the source REFUSES and writes nothing ----
353 let rc3: i64 = tg_run3(subject, TG_ASSET, TG_OUT3, TG_OVER, cap, olen)
354 gv_puts(" [T9] over-budget rc=" as *u8); gv_num(rc3); gv_puts("\n" as *u8)
355 var t9: i64 = 0
356 if rc3 == TG_EXIT_REFUSE { if tg_exists(TG_OUT3) == 0 { t9 = 1 } }
357 gv_check("neg-control-upsample-budget-refused-by-name-AND-writes-no-output" as *u8, t9, ctr)
358 var fired_bad: i64 = 0
359 if rc3 == TG_EXIT_REFUSE { fired_bad = 1 }
360 var fired_good: i64 = 0
361 if rc1 == TG_EXIT_REFUSE { fired_good = 1 }
362 gv_bite("neg-control-refusal-fires-on-the-upsample-and-not-on-the-real-budget" as *u8, fired_bad, fired_good, ctr)
363
364 // ---- T10: neg-control -- a budget under the 3-vertex floor REFUSES ----
365 let rc4: i64 = tg_run3(subject, TG_ASSET, TG_OUT4, TG_TINY, cap, olen)
366 var t10: i64 = 0
367 if rc4 == TG_EXIT_REFUSE { if tg_exists(TG_OUT4) == 0 { t10 = 1 } }
368 gv_check("neg-control-budget-under-three-vertices-refused-and-writes-no-output" as *u8, t10, ctr)
369
370 // ---- T11: neg-control -- a truncated container (TOC intact, payload cut) REFUSES ----
371 var trunc_ok: i64 = 0
372 if lin[0] > TG_TRUNC_BYTES { if tg_write_bytes(TG_TRUNC, bin, TG_TRUNC_BYTES) == TG_TRUNC_BYTES { trunc_ok = 1 } }
373 gv_check("setup-truncated-fixture-reached-the-condition (TOC intact, payload cut)" as *u8, trunc_ok, ctr)
374 let rc5: i64 = tg_run3(subject, TG_TRUNC, TG_OUT5, TG_BUDGET, cap, olen)
375 gv_puts(" [T11] truncated rc=" as *u8); gv_num(rc5); gv_puts("\n" as *u8)
376 var t11: i64 = 0
377 if rc5 == TG_EXIT_REFUSE { if tg_exists(TG_OUT5) == 0 { t11 = 1 } }
378 gv_check("neg-control-truncated-input-refused-by-name-and-writes-no-output" as *u8, t11, ctr)
379
380 // ---- T12: the tier PLAYS -- the independent pose player evaluates it with zero unweighted vertices ----
381 let rc6: i64 = tg_run1(TG_PLAYER, TG_OUT1, cap, olen)
382 let zw: i64 = tg_kv(cap, olen[0], "zero_weight_verts=" as *u8)
383 let pj: i64 = tg_kv(cap, olen[0], "joints=" as *u8)
384 let pv: i64 = tg_kv(cap, olen[0], "verts=" as *u8)
385 gv_puts(" [T12] player rc=" as *u8); gv_num(rc6); gv_puts(" joints=" as *u8); gv_num(pj); gv_puts(" verts=" as *u8); gv_num(pv); gv_puts(" zero_weight_verts=" as *u8); gv_num(zw); gv_puts("\n" as *u8)
386 var t12: i64 = 0
387 if rc6 == TG_EXIT_OK { if zw == 0 { if pv == nv1 { if pj == nj1 { t12 = 1 } } } }
388 gv_check("independent-pose-player-plays-the-tier-with-zero-unweighted-vertices-and-the-same-counts" as *u8, t12, ctr)
389
390 // ---- T13: the ladder verb -- tiers under the source emitted, the tier above it skipped, partition printed ----
391 let lw: i64 = tg_write_bytes(TG_LADDER, TG_LADDER_ROWS, tg_slen(TG_LADDER_ROWS))
392 var lad_setup: i64 = 0
393 if lw > 0 { lad_setup = 1 }
394 gv_check("setup-ladder-conf-written-at-runtime" as *u8, lad_setup, ctr)
395 let rc7: i64 = tg_run4(subject, TG_LADDER_VERB, TG_ASSET, TG_PFX, TG_LADDER, cap, olen)
396 let em: i64 = tg_kv(cap, olen[0], "emitted=" as *u8)
397 let sk: i64 = tg_kv(cap, olen[0], "skipped=" as *u8)
398 let fl: i64 = tg_kv(cap, olen[0], "failed=" as *u8)
399 gv_puts(" [T13] ladder rc=" as *u8); gv_num(rc7); gv_puts(" emitted=" as *u8); gv_num(em); gv_puts(" skipped=" as *u8); gv_num(sk); gv_puts(" failed=" as *u8); gv_num(fl); gv_puts("\n" as *u8)
400 var t13: i64 = 0
401 if rc7 == TG_EXIT_OK { if em == 2 { if sk == 1 { if fl == 0 { if tg_exists(TG_LAD4) == 1 { if tg_exists(TG_LAD1) == 1 { if tg_exists(TG_LAD16) == 0 { t13 = 1 } } } } } } }
402 gv_check("ladder-emits-every-tier-under-the-source-skips-the-one-above-and-the-partition-sums" as *u8, t13, ctr)
403
404 // ---- the subject actually ran ----
405 var ran: i64 = 1
406 if rc1 < 0 { ran = 0 }
407 if rc1 == TG_EXEC_NOT_FOUND { ran = 0 }
408 gv_check("neg-control-subject-actually-executed (not 127, not a harness sentinel)" as *u8, ran, ctr)
409
410 gv_kv("tier_verts" as *u8, nv1)
411 gv_kv("tier_tris" as *u8, nt1)
412 gv_kv("source_verts" as *u8, nv_in)
413 gv_kv("collapsed_tris" as *u8, r_coll)
414 let rc: i64 = gv_verdict("NXA-TIER" as *u8, ctr, "a smaller verified NXA under the budget, rig and atlas rows carried, no upsample and no silent section loss" as *u8)
415 sys_exit(rc)
416 return rc
417}