nx_nxa2glb_gate.nx source
↩ module page · 418 lines · 24876 B
1// nx_nxa2glb_gate.nx -- THE GATE FOR THE RIGGED EXPORT LEG: NXANIM01 (SKEL+SKIN) -> glTF skins/JOINTS_0/WEIGHTS_0/IBM.
2//
3// SUBJECT: the nx_mesh2glb ELF, forked for real (tr_run_capture). The rig surviving export is measured by
4// INDEPENDENT READERS, never by this gate re-parsing what the subject wrote with the subject's own assumptions:
5// (a) nx_gltf2mesh -- our glTF IMPORTER -- counts skin_joints in the exported .glb; it reads skins[].joints itself
6// (b) gltf_load_std -- our native LOADER lib -- must load it and agree on vertex and triangle counts
7// (c) ANTI-VACUITY, asserted BEFORE (a): the JSON declares skins, JOINTS_0, WEIGHTS_0, inverseBindMatrices, and
8// the JOINTS_0 accessor count equals the vertex count, parsed with the loader lib's own gls_accessor
9// (d) WEIGHTS: every vertex's four WEIGHTS_0 decode back to EXACTLY its source q12 sum -- FULL POPULATION, worst
10// deviation printed. The tolerance is DERIVED = 0: every k/4096 is exactly representable in f32 (23 mantissa
11// bits >> 12) and the encoder is exact for dyadic rationals, so any deviation at all is a defect.
12// (e) NEG-CONTROL via gv_bite: an NXA with NO SKEL exports NO skins (importer reports skin_joints=0), paired with
13// (a) -- a writer that reports success for everything cannot score on this pair.
14// (f) a truncated NXA is REFUSED BY NAME (the format's own checksum), never a silent empty .glb.
15// (g) NO SILENT INPUT CAP (2026-08-22): nx_mesh2glb carried a 32 MiB input read cap and a 400000-tri cap; an
16// intact NXMSH2 past either was refused, past the byte cap WITH THE WRONG REASON. The anti-vacuity fixture is
17// a synthetic NXMSH2 DERIVED to exceed BOTH, and the tooth asserts the exported accessor counts equal tris*3,
18// parsed from the JSON. Its truncated twin is refused by name (the NXMSH2 mirror of (f)), paired via gv_bite.
19// The output capacity must be DERIVED and ANNOUNCED (out_cap_derived / out_used) -- a cap nobody can see is
20// a cap nobody can check.
21// FIXTURES at runtime under /tmp/nx_nxa2glb_gate/; every subject output is unlinked at SETUP -- a gate that is not
22// idempotent reports on its first run and lies about every run after.
23// argv: [subject elf] [importer elf] [rigged donor nxa] [unrigged donor nxa] (defaults resolve from the serving root)
24// license_tier: ORIGINAL No hw writes (Rule 26). expect_exit: 0
25import "nx_syscalls.nx"
26import "nx_gate_verdict.nx"
27import "nx_tool_run.nx"
28import "nx_nxa.nx"
29import "nx_trimesh.nx"
30import "nx_gltf_load.nx"
31
32const NG_SUBJECT_DEFAULT: *u8 = "_offc/nx_mesh2glb.elf"
33const NG_IMPORTER_DEFAULT: *u8 = "_offc/nx_gltf2mesh.elf"
34const NG_RIGGED_DEFAULT: *u8 = "sites/nishifamily/world/ref9d.nxa"
35const NG_UNRIGGED_DEFAULT: *u8 = "sites/nishifamily/world/ref.nxa"
36const NG_DIR: *u8 = "/tmp/nx_nxa2glb_gate"
37const NG_GLB_RIGGED: *u8 = "/tmp/nx_nxa2glb_gate/rigged.glb"
38const NG_GLB_UNRIGGED: *u8 = "/tmp/nx_nxa2glb_gate/unrigged.glb"
39const NG_GLB_TRUNC: *u8 = "/tmp/nx_nxa2glb_gate/trunc.glb"
40const NG_NXA_TRUNC: *u8 = "/tmp/nx_nxa2glb_gate/trunc.nxa"
41const NG_MSH_RIGGED: *u8 = "/tmp/nx_nxa2glb_gate/rigged.nxmesh"
42const NG_MSH_UNRIGGED: *u8 = "/tmp/nx_nxa2glb_gate/unrigged.nxmesh"
43const NG_MODE_DIR: i64 = 493 // 0755
44const NG_CAPTURE_CAP: i64 = 262144
45const NG_ARGV_SLOTS: i64 = 8
46const NG_WORD: i64 = 8
47const NG_EXIT_OK: i64 = 0
48const NG_EXIT_REFUSE: i64 = 3 // the subject's refusal exit for an unusable input
49const NG_EXEC_FAIL: i64 = 127 // execve failure as captured by tr_run_capture
50const NG_Q12: i64 = 4096
51const NG_SKIN_REC_WORDS: i64 = 8
52const NG_SKIN_W0: i64 = 4
53const NG_INFL: i64 = 4
54const NG_F32_BYTES: i64 = 4
55const NG_GL_FLOAT: i64 = 5126 // glTF componentType FLOAT -- WEIGHTS_0 must be this
56const NG_Q12_SHIFT: i64 = 12 // gls_f32s(bits, 12) yields value x 4096 as an integer
57const NG_WEIGHT_SUM_TOL_Q12: i64 = 0 // DERIVED: k/4096 is exact in f32 and the encoder is exact for dyadics
58const NG_GLB_JSONLEN_OFF: i64 = 12
59const NG_GLB_JSON_START: i64 = 20
60const NG_GLB_CHUNK_HDR: i64 = 8
61const NG_NXA_HDR_BYTES: i64 = 32
62const NG_NXA_TOC_ENTRY: i64 = 32
63const NG_TRUNC_PAYLOAD_TAIL: i64 = 64 // keep the whole TOC plus 64 B of payload so the TOC check PASSES and
64 // the PAYLOAD check is what refuses -- the deeper integrity tooth
65const NG_LOAD_TARGET: i64 = 900 // the bbox-relative normalisation nx_gltf_load_gate passes; unit-free
66// ---- NO-SILENT-CAP teeth (2026-08-22). These two numbers are NOT caps in this gate: they are the two caps
67// nx_mesh2glb carried until 2026-08-22, kept ONLY as the floor the anti-vacuity fixture must EXCEED. A fixture
68// under them would convert on the capped binary too and prove nothing.
69const NG_OLD_INPUT_CAP_BYTES: i64 = 33554432
70const NG_OLD_TRI_CAP: i64 = 400000
71const NG_MSH_FIXED_HDR: i64 = 16 // NXMSH2: magic[8] + u32 nlay + u32 ntri
72const NG_MSH_LAYROW: i64 = 24
73const NG_MSH_TRIREC: i64 = 84 // 9 position + 9 normal + 3 colour float32
74const NG_MSH_NLAY_OFF: i64 = 8
75const NG_MSH_NTRI_OFF: i64 = 12
76const NG_MSH_LAY_CNT_OFF: i64 = 20
77const NG_MSH_SMALL_TRIS: i64 = 10 // the truncation fixture: small, cut mid-record
78const NG_HALF: i64 = 2
79const NG_CORNERS: i64 = 3
80const NG_BIG_MSH: *u8 = "/tmp/nx_nxa2glb_gate/big.nxmesh"
81const NG_BIG_GLB: *u8 = "/tmp/nx_nxa2glb_gate/big.glb"
82const NG_SMALL_MSH: *u8 = "/tmp/nx_nxa2glb_gate/small.nxmesh"
83const NG_CUT_MSH: *u8 = "/tmp/nx_nxa2glb_gate/cut.nxmesh"
84const NG_CUT_GLB: *u8 = "/tmp/nx_nxa2glb_gate/cut.glb"
85
86func ng_exists(path: *u8) -> i64 {
87 let lp: *i64 = sys_mmap(NG_WORD*2) as *i64
88 let b: *u8 = sys_read_file(path, lp)
89 if (b as i64) == 0 { return 0 }
90 if lp[0] <= 0 { return 0 }
91 return 1
92}
93func ng_run(elf: *u8, a1: *u8, a2: *u8, out: *u8, outlen: *i64) -> i64 {
94 let av: *i64 = sys_mmap(NG_WORD*NG_ARGV_SLOTS) as *i64
95 av[0] = elf as i64
96 av[1] = a1 as i64
97 av[2] = a2 as i64
98 av[3] = 0
99 return tr_run_capture(elf, av, out, NG_CAPTURE_CAP, outlen)
100}
101func ng_w32(b: *u8, o: i64, v: i64) -> i64 { b[o]=(v&255) as u8; b[o+1]=((v>>8)&255) as u8; b[o+2]=((v>>16)&255) as u8; b[o+3]=((v>>24)&255) as u8; return o+4 }
102// a structurally honest NXMSH2 with ONE layer named "skin" covering every triangle; records are zero-filled
103// (mmap pages arrive zeroed) -- the converter validates structure, not geometry. Returns bytes written or -1.
104func ng_write_msh(path: *u8, ntri: i64) -> i64 {
105 let total: i64 = NG_MSH_FIXED_HDR + NG_MSH_LAYROW + ntri*NG_MSH_TRIREC
106 let b: *u8 = sys_mmap(total)
107 b[0]=78 as u8; b[1]=88 as u8; b[2]=77 as u8; b[3]=83 as u8; b[4]=72 as u8; b[5]=50 as u8
108 ng_w32(b, NG_MSH_NLAY_OFF, 1)
109 ng_w32(b, NG_MSH_NTRI_OFF, ntri)
110 b[NG_MSH_FIXED_HDR]=115 as u8; b[NG_MSH_FIXED_HDR+1]=107 as u8; b[NG_MSH_FIXED_HDR+2]=105 as u8; b[NG_MSH_FIXED_HDR+3]=110 as u8
111 ng_w32(b, NG_MSH_FIXED_HDR + NG_MSH_LAY_CNT_OFF, ntri)
112 let fd: i64 = sys_openat_wr(path, MODE_0644)
113 if fd < 0 { return 0 - 1 }
114 let wr: i64 = sys_write(fd, b, total)
115 sys_close(fd)
116 if wr != total { return 0 - 1 }
117 return total
118}
119// the subject's first stdout line, verbatim -- a refusal names itself; a receipt names its counts
120func ng_first_line(cap: *u8, n: i64) -> i64 {
121 var i: i64 = 0
122 while i < n { if cap[i] == (10 as u8) { sys_write(1, cap, i); return 0 } i = i + 1 }
123 sys_write(1, cap, n)
124 return 0
125}
126func ng_hasstr(b: *u8, n: i64, lit: *u8) -> i64 {
127 if gls_find(b, n, 0, lit) >= 0 { return 1 }
128 return 0
129}
130// the importer's receipt is one JSON line; its skin_joints field is the independent joint count
131func ng_skin_joints(cap: *u8, n: i64) -> i64 { return gll_nth_num(cap, 0, n, "\x22skin_joints\x22:" as *u8, 1) }
132func ng_verts_seen(cap: *u8, n: i64) -> i64 { return gll_nth_num(cap, 0, n, "\x22verts_seen\x22:" as *u8, 1) }
133
134func main(argc: i64, argv: *i64) -> i64 {
135 let ctr: *i64 = gv_ctr()
136 gv_head("nx_nxa2glb gate -- the rig survives export, measured by independent readers" as *u8)
137 var subject: *u8 = NG_SUBJECT_DEFAULT
138 var importer: *u8 = NG_IMPORTER_DEFAULT
139 var rigged: *u8 = NG_RIGGED_DEFAULT
140 var unrigged: *u8 = NG_UNRIGGED_DEFAULT
141 if argc >= 2 { subject = argv[1] as *u8 }
142 if argc >= 3 { importer = argv[2] as *u8 }
143 if argc >= 4 { rigged = argv[3] as *u8 }
144 if argc >= 5 { unrigged = argv[4] as *u8 }
145 gv_puts(" subject: " as *u8); gv_puts(subject); gv_puts("\n" as *u8)
146 gv_puts(" importer: " as *u8); gv_puts(importer); gv_puts("\n" as *u8)
147 gv_puts(" rigged: " as *u8); gv_puts(rigged); gv_puts("\n" as *u8)
148 gv_puts(" unrigged: " as *u8); gv_puts(unrigged); gv_puts("\n\n" as *u8)
149
150 // ---- SETUP: mkdir, unlink every subject output, read the donors, derive the expectations ----
151 sys_mkdir(NG_DIR, NG_MODE_DIR)
152 sys_unlinkat(NG_GLB_RIGGED)
153 sys_unlinkat(NG_GLB_UNRIGGED)
154 sys_unlinkat(NG_GLB_TRUNC)
155 sys_unlinkat(NG_NXA_TRUNC)
156 sys_unlinkat(NG_MSH_RIGGED)
157 sys_unlinkat(NG_MSH_UNRIGGED)
158 sys_unlinkat(NG_BIG_MSH)
159 sys_unlinkat(NG_BIG_GLB)
160 sys_unlinkat(NG_SMALL_MSH)
161 sys_unlinkat(NG_CUT_MSH)
162 sys_unlinkat(NG_CUT_GLB)
163 var clean: i64 = 1
164 if ng_exists(NG_GLB_RIGGED) == 1 { clean = 0 }
165 if ng_exists(NG_GLB_UNRIGGED) == 1 { clean = 0 }
166 if ng_exists(NG_GLB_TRUNC) == 1 { clean = 0 }
167 if ng_exists(NG_BIG_GLB) == 1 { clean = 0 }
168 if ng_exists(NG_CUT_GLB) == 1 { clean = 0 }
169 gv_check("setup-subject-outputs-absent-before-measuring (gate is idempotent)" as *u8, clean, ctr)
170
171 let lr: *i64 = sys_mmap(NG_WORD*2) as *i64
172 let rb: *u8 = sys_read_file(rigged, lr)
173 let lu: *i64 = sys_mmap(NG_WORD*2) as *i64
174 let ub: *u8 = sys_read_file(unrigged, lu)
175 var nv: i64 = 0
176 var nt: i64 = 0
177 var nj: i64 = 0
178 var wk: i64 = 0 - 1
179 var donors_ok: i64 = 0
180 if (rb as i64) != 0 { if (ub as i64) != 0 {
181 let wv: i64 = nxa_find(rb, lr[0], nxa_tag4("VERT" as *u8))
182 let wt: i64 = nxa_find(rb, lr[0], nxa_tag4("TRIS" as *u8))
183 let ws: i64 = nxa_find(rb, lr[0], nxa_tag4("SKEL" as *u8))
184 wk = nxa_find(rb, lr[0], nxa_tag4("SKIN" as *u8))
185 let uv: i64 = nxa_find(ub, lu[0], nxa_tag4("VERT" as *u8))
186 let us: i64 = nxa_find(ub, lu[0], nxa_tag4("SKEL" as *u8))
187 if wv >= 0 { if wt >= 0 { if ws >= 0 { if wk >= 0 { if uv >= 0 { if us < 0 {
188 let rw: *i64 = rb as *i64
189 nv = rw[wv]
190 nt = rw[wt]
191 nj = rw[ws]
192 if nv > 0 { if nt > 0 { if nj > 0 { donors_ok = 1 } } }
193 } } } } } }
194 } }
195 gv_puts(" donor: nv=" as *u8); gv_num(nv); gv_puts(" nt=" as *u8); gv_num(nt); gv_puts(" nj=" as *u8); gv_num(nj); gv_puts("\n" as *u8)
196 // the fixture must REACH the condition before any outcome is asserted: a rigged donor with SKEL+SKIN and
197 // an unrigged donor with VERT but no SKEL -- otherwise every tooth below measures an empty set
198 gv_check("setup-donors-present-rigged-has-SKEL+SKIN-unrigged-has-none" as *u8, donors_ok, ctr)
199
200 let cap: *u8 = sys_mmap(NG_CAPTURE_CAP)
201 let olen: *i64 = sys_mmap(NG_WORD*2) as *i64
202
203 // ---- T1: export the rigged donor ----
204 let rc1: i64 = ng_run(subject, rigged, NG_GLB_RIGGED, cap, olen)
205 gv_puts(" [T1] export rigged rc=" as *u8); gv_num(rc1); gv_puts(" capture_bytes=" as *u8); gv_num(olen[0]); gv_puts("\n" as *u8)
206 var t1: i64 = 0
207 if rc1 == NG_EXIT_OK { if ng_exists(NG_GLB_RIGGED) == 1 { t1 = 1 } }
208 gv_check("rigged-donor-exports-exit-OK-and-writes-a-glb" as *u8, t1, ctr)
209 let ocd1: i64 = gll_nth_num(cap, 0, olen[0], "\x22out_cap_derived\x22:" as *u8, 1)
210 let ocu1: i64 = gll_nth_num(cap, 0, olen[0], "\x22out_used\x22:" as *u8, 1)
211
212 // ---- T2: anti-vacuity -- the JSON DECLARES a skin, and JOINTS_0 covers every vertex ----
213 let lg: *i64 = sys_mmap(NG_WORD*2) as *i64
214 let gb: *u8 = sys_read_file(NG_GLB_RIGGED, lg)
215 var jE: i64 = 0
216 var binStart: i64 = 0
217 var t2: i64 = 0
218 var wbase: i64 = 0
219 var wcount: i64 = 0
220 var wctype: i64 = 0
221 if (gb as i64) != 0 { if lg[0] > NG_GLB_JSON_START {
222 let jl: i64 = gll_ru32(gb, NG_GLB_JSONLEN_OFF)
223 jE = NG_GLB_JSON_START + jl
224 binStart = jE + NG_GLB_CHUNK_HDR
225 var decl: i64 = 1
226 if ng_hasstr(gb, jE, "\x22skins\x22" as *u8) == 0 { decl = 0 }
227 if ng_hasstr(gb, jE, "\x22JOINTS_0\x22" as *u8) == 0 { decl = 0 }
228 if ng_hasstr(gb, jE, "\x22WEIGHTS_0\x22" as *u8) == 0 { decl = 0 }
229 if ng_hasstr(gb, jE, "\x22inverseBindMatrices\x22" as *u8) == 0 { decl = 0 }
230 let pr: *i64 = sys_mmap(NG_WORD*2) as *i64
231 let ac: *i64 = sys_mmap(NG_WORD*4) as *i64
232 let bv: *i64 = sys_mmap(NG_WORD*2) as *i64
233 if decl == 1 { if gls_arr_obj(gb, jE, "primitives" as *u8, 0, pr) == 1 {
234 let jA: i64 = gls_key_int(gb, pr[0], pr[1], "JOINTS_0" as *u8)
235 let wA: i64 = gls_key_int(gb, pr[0], pr[1], "WEIGHTS_0" as *u8)
236 if jA >= 0 { if gls_accessor(gb, jE, jA, ac) == 1 {
237 gv_puts(" [T2] JOINTS_0 accessor=" as *u8); gv_num(jA); gv_puts(" count=" as *u8); gv_num(ac[3]); gv_puts(" componentType=" as *u8); gv_num(ac[2]); gv_puts("\n" as *u8)
238 if ac[3] == nv { t2 = 1 }
239 } }
240 if wA >= 0 { if gls_accessor(gb, jE, wA, ac) == 1 {
241 wcount = ac[3]
242 wctype = ac[2]
243 if gls_bufview(gb, jE, ac[0], bv) == 1 { wbase = binStart + bv[0] + ac[1] }
244 } }
245 } }
246 } }
247 gv_check("anti-vacuity-json-declares-skin-and-JOINTS_0-count-equals-vertex-count" as *u8, t2, ctr)
248
249 // ---- T3: INDEPENDENT READER (a): our importer counts the joints it sees ----
250 let rc3: i64 = ng_run(importer, NG_GLB_RIGGED, NG_MSH_RIGGED, cap, olen)
251 let sj: i64 = ng_skin_joints(cap, olen[0])
252 let vs: i64 = ng_verts_seen(cap, olen[0])
253 gv_puts(" [T3] importer rc=" as *u8); gv_num(rc3); gv_puts(" skin_joints=" as *u8); gv_num(sj); gv_puts(" verts_seen=" as *u8); gv_num(vs); gv_puts(" (expected nj=" as *u8); gv_num(nj); gv_puts(" nv=" as *u8); gv_num(nv); gv_puts(")\n" as *u8)
254 var t3: i64 = 0
255 if rc3 == NG_EXIT_OK { if sj == nj { if vs == nv { if nj > 0 { t3 = 1 } } } }
256 gv_check("independent-importer-reads-back-nj-skin-joints-and-nv-verts" as *u8, t3, ctr)
257
258 // ---- T4: INDEPENDENT READER (b): our native loader loads it and agrees on counts ----
259 var t4: i64 = 0
260 if gltf_load_std(NG_GLB_RIGGED, NG_LOAD_TARGET) == 1 { if tm_nv() == nv { if tm_nt() == nt { t4 = 1 } } }
261 gv_puts(" [T4] native loader why=" as *u8); gv_puts(gltf_load_why()); gv_puts(" nv=" as *u8); gv_num(tm_nv()); gv_puts(" nt=" as *u8); gv_num(tm_nt()); gv_puts("\n" as *u8)
262 gv_check("independent-native-loader-loads-glb-and-agrees-on-nv-nt" as *u8, t4, ctr)
263
264 // ---- T5: WEIGHTS round-trip EXACTLY, full population ----
265 var worst: i64 = 0 - 1
266 var mism: i64 = 0
267 var checked: i64 = 0
268 var off_unity: i64 = 0
269 if wk >= 0 { if wbase > 0 { if wcount == nv { if wctype == NG_GL_FLOAT {
270 let rw2: *i64 = rb as *i64
271 worst = 0
272 var v: i64 = 0
273 while v < nv {
274 var src: i64 = 0
275 var got: i64 = 0
276 var s: i64 = 0
277 while s < NG_INFL {
278 src = src + rw2[wk+1+v*NG_SKIN_REC_WORDS+NG_SKIN_W0+s]
279 got = got + gls_f32s(gll_ru32(gb, wbase + v*NG_INFL*NG_F32_BYTES + s*NG_F32_BYTES), NG_Q12_SHIFT)
280 s = s + 1
281 }
282 var d: i64 = got - src
283 if d < 0 { d = 0 - d }
284 if d > worst { worst = d }
285 if d > NG_WEIGHT_SUM_TOL_Q12 { mism = mism + 1 }
286 if src != NG_Q12 { off_unity = off_unity + 1 }
287 checked = checked + 1
288 v = v + 1
289 }
290 } } } }
291 gv_puts(" [T5] weights_checked=" as *u8); gv_num(checked); gv_puts(" of " as *u8); gv_num(nv)
292 gv_puts(" worst_abs_dev_q12=" as *u8); gv_num(worst); gv_puts(" mismatches=" as *u8); gv_num(mism)
293 gv_puts(" source_vertices_off_unity=" as *u8); gv_num(off_unity); gv_puts(" (a MEASUREMENT of the donor, not a tooth)\n" as *u8)
294 var t5: i64 = 0
295 if checked == nv { if nv > 0 { if worst == 0 { if mism == 0 { t5 = 1 } } } }
296 gv_check("weights-round-trip-exactly-on-every-vertex (derived tolerance 0, full population)" as *u8, t5, ctr)
297
298 // ---- T6: the unrigged donor exports NO skin; T7 the bite pair ----
299 let rc6: i64 = ng_run(subject, unrigged, NG_GLB_UNRIGGED, cap, olen)
300 let lg2: *i64 = sys_mmap(NG_WORD*2) as *i64
301 let gb2: *u8 = sys_read_file(NG_GLB_UNRIGGED, lg2)
302 var unr_declares_skin: i64 = 0
303 if (gb2 as i64) != 0 { if lg2[0] > NG_GLB_JSON_START {
304 let jl2: i64 = gll_ru32(gb2, NG_GLB_JSONLEN_OFF)
305 if ng_hasstr(gb2, NG_GLB_JSON_START + jl2, "\x22skins\x22" as *u8) == 1 { unr_declares_skin = 1 }
306 } }
307 let rc6b: i64 = ng_run(importer, NG_GLB_UNRIGGED, NG_MSH_UNRIGGED, cap, olen)
308 let sj6: i64 = ng_skin_joints(cap, olen[0])
309 gv_puts(" [T6] unrigged export rc=" as *u8); gv_num(rc6); gv_puts(" declares_skin=" as *u8); gv_num(unr_declares_skin); gv_puts(" importer rc=" as *u8); gv_num(rc6b); gv_puts(" skin_joints=" as *u8); gv_num(sj6); gv_puts("\n" as *u8)
310 var t6: i64 = 0
311 if rc6 == NG_EXIT_OK { if rc6b == NG_EXIT_OK { if sj6 == 0 { t6 = 1 } } }
312 gv_check("unrigged-donor-still-exports-and-importer-sees-zero-joints" as *u8, t6, ctr)
313 var fired_on_rigged: i64 = 0
314 if t3 == 1 { fired_on_rigged = 1 }
315 var fired_on_unrigged: i64 = 0
316 if unr_declares_skin == 1 { fired_on_unrigged = 1 }
317 if sj6 != 0 { fired_on_unrigged = 1 }
318 gv_bite("neg-control-skin-emitted-for-rigged-donor-and-NOT-for-unrigged-donor" as *u8, fired_on_rigged, fired_on_unrigged, ctr)
319
320 // ---- T8: a truncated NXA is REFUSED BY NAME, never a silent glb ----
321 var cut_ok: i64 = 0
322 if (rb as i64) != 0 {
323 let h: *i64 = rb as *i64
324 let ns: i64 = h[2]
325 let cut: i64 = NG_NXA_HDR_BYTES + ns*NG_NXA_TOC_ENTRY + NG_TRUNC_PAYLOAD_TAIL
326 if cut < lr[0] {
327 let fd: i64 = sys_openat_wr(NG_NXA_TRUNC, MODE_0644)
328 if fd >= 0 {
329 let wr: i64 = sys_write(fd, rb, cut)
330 sys_close(fd)
331 if wr == cut { cut_ok = 1 }
332 }
333 }
334 gv_puts(" [T8] truncation fixture: cut=" as *u8); gv_num(cut); gv_puts(" of " as *u8); gv_num(lr[0]); gv_puts(" bytes (TOC intact, payload gone)\n" as *u8)
335 }
336 gv_check("setup-truncated-fixture-reached-the-condition (TOC intact, payload cut)" as *u8, cut_ok, ctr)
337 let rc8: i64 = ng_run(subject, NG_NXA_TRUNC, NG_GLB_TRUNC, cap, olen)
338 let named: i64 = ng_hasstr(cap, olen[0], "corrupt" as *u8)
339 gv_puts(" [T8] truncated export rc=" as *u8); gv_num(rc8); gv_puts(" named_corrupt=" as *u8); gv_num(named); gv_puts(" glb_written=" as *u8); gv_num(ng_exists(NG_GLB_TRUNC)); gv_puts("\n" as *u8)
340 var t8: i64 = 0
341 if rc8 == NG_EXIT_REFUSE { if named == 1 { if ng_exists(NG_GLB_TRUNC) == 0 { t8 = 1 } } }
342 gv_check("truncated-nxa-refused-by-name-and-writes-no-glb" as *u8, t8, ctr)
343
344 // ---- T10: NO SILENT INPUT CAP -- an intact mesh past BOTH old caps converts COMPLETELY ----
345 // nt is DERIVED so the fixture exceeds both: the byte cap by at least one full record, and the tri cap by one.
346 var nt_big: i64 = (NG_OLD_INPUT_CAP_BYTES - NG_MSH_FIXED_HDR - NG_MSH_LAYROW) / NG_MSH_TRIREC + 2
347 if nt_big <= NG_OLD_TRI_CAP { nt_big = NG_OLD_TRI_CAP + 1 }
348 let big_bytes: i64 = ng_write_msh(NG_BIG_MSH, nt_big)
349 gv_puts(" [T10] big fixture: tris=" as *u8); gv_num(nt_big); gv_puts(" bytes=" as *u8); gv_num(big_bytes)
350 gv_puts(" (old input cap " as *u8); gv_num(NG_OLD_INPUT_CAP_BYTES); gv_puts(" B, old tri cap " as *u8); gv_num(NG_OLD_TRI_CAP); gv_puts(")\n" as *u8)
351 var big_reached: i64 = 0
352 if big_bytes > NG_OLD_INPUT_CAP_BYTES { if nt_big > NG_OLD_TRI_CAP { big_reached = 1 } }
353 gv_check("setup-big-fixture-exceeds-BOTH-old-caps (the anti-vacuity floor was reached)" as *u8, big_reached, ctr)
354 let t10_ms0: i64 = sys_now_ms()
355 let rc10: i64 = ng_run(subject, NG_BIG_MSH, NG_BIG_GLB, cap, olen)
356 let t10_ms: i64 = sys_now_ms() - t10_ms0
357 gv_puts(" [T10] convert rc=" as *u8); gv_num(rc10); gv_puts(" ms=" as *u8); gv_num(t10_ms); gv_puts(" subject-said: " as *u8); ng_first_line(cap, olen[0]); gv_puts("\n" as *u8)
358 let ocd10: i64 = gll_nth_num(cap, 0, olen[0], "\x22out_cap_derived\x22:" as *u8, 1)
359 let ocu10: i64 = gll_nth_num(cap, 0, olen[0], "\x22out_used\x22:" as *u8, 1)
360 // the accessor counts are PARSED from the JSON with the loader lib's own accessor reader -- not eyeballed
361 let lgb: *i64 = sys_mmap(NG_WORD*2) as *i64
362 let bgb: *u8 = sys_read_file(NG_BIG_GLB, lgb)
363 var pos_count: i64 = 0 - 1
364 var idx_count: i64 = 0 - 1
365 if (bgb as i64) != 0 { if lgb[0] > NG_GLB_JSON_START {
366 let jlb: i64 = gll_ru32(bgb, NG_GLB_JSONLEN_OFF)
367 let jEb: i64 = NG_GLB_JSON_START + jlb
368 let prb: *i64 = sys_mmap(NG_WORD*2) as *i64
369 let acb: *i64 = sys_mmap(NG_WORD*4) as *i64
370 if gls_arr_obj(bgb, jEb, "primitives" as *u8, 0, prb) == 1 {
371 let pA: i64 = gls_key_int(bgb, prb[0], prb[1], "POSITION" as *u8)
372 let iA: i64 = gls_key_int(bgb, prb[0], prb[1], "indices" as *u8)
373 if pA >= 0 { if gls_accessor(bgb, jEb, pA, acb) == 1 { pos_count = acb[3] } }
374 if iA >= 0 { if gls_accessor(bgb, jEb, iA, acb) == 1 { idx_count = acb[3] } }
375 }
376 } }
377 gv_puts(" [T10] POSITION count=" as *u8); gv_num(pos_count); gv_puts(" indices count=" as *u8); gv_num(idx_count); gv_puts(" expected=" as *u8); gv_num(nt_big*NG_CORNERS); gv_puts("\n" as *u8)
378 var t10: i64 = 0
379 if rc10 == NG_EXIT_OK { if pos_count == nt_big*NG_CORNERS { if idx_count == nt_big*NG_CORNERS { t10 = 1 } } }
380 gv_check("no-silent-input-cap: an intact mesh past both old caps converts COMPLETELY (accessor counts == tris*3)" as *u8, t10, ctr)
381
382 // ---- T11: the NXMSH2 twin of T8 -- a truncated mesh is refused BY NAME, no glb; bitten against T10 ----
383 let small_bytes: i64 = ng_write_msh(NG_SMALL_MSH, NG_MSH_SMALL_TRIS)
384 let cut_at: i64 = small_bytes - NG_MSH_TRIREC/NG_HALF
385 var cut_ok2: i64 = 0
386 let lsm: *i64 = sys_mmap(NG_WORD*2) as *i64
387 let sb: *u8 = sys_read_file(NG_SMALL_MSH, lsm)
388 if (sb as i64) != 0 { if lsm[0] == small_bytes { if cut_at > NG_MSH_FIXED_HDR {
389 let fdc: i64 = sys_openat_wr(NG_CUT_MSH, MODE_0644)
390 if fdc >= 0 { let wrc: i64 = sys_write(fdc, sb, cut_at); sys_close(fdc); if wrc == cut_at { cut_ok2 = 1 } }
391 } } }
392 gv_puts(" [T11] NXMSH2 truncation fixture: cut=" as *u8); gv_num(cut_at); gv_puts(" of " as *u8); gv_num(small_bytes); gv_puts(" bytes (header intact, last record halved)\n" as *u8)
393 gv_check("setup-nxmsh2-truncated-fixture-reached-the-condition (header intact, record cut)" as *u8, cut_ok2, ctr)
394 let rc11: i64 = ng_run(subject, NG_CUT_MSH, NG_CUT_GLB, cap, olen)
395 let named11: i64 = ng_hasstr(cap, olen[0], "truncated" as *u8)
396 gv_puts(" [T11] truncated nxmesh rc=" as *u8); gv_num(rc11); gv_puts(" named_truncated=" as *u8); gv_num(named11); gv_puts(" glb_written=" as *u8); gv_num(ng_exists(NG_CUT_GLB)); gv_puts("\n" as *u8)
397 var t11: i64 = 0
398 if rc11 == NG_EXIT_REFUSE { if named11 == 1 { if ng_exists(NG_CUT_GLB) == 0 { t11 = 1 } } }
399 gv_check("truncated-nxmsh2-refused-by-name-and-writes-no-glb" as *u8, t11, ctr)
400 gv_bite("neg-control-truncated-nxmsh2-refused-and-oversize-intact-nxmsh2-converted" as *u8, t11, 1 - t10, ctr)
401
402 // ---- T12: the output capacity is DERIVED and ANNOUNCED on both container paths, and never exceeded ----
403 gv_puts(" [T12] nxa: out_cap_derived=" as *u8); gv_num(ocd1); gv_puts(" out_used=" as *u8); gv_num(ocu1)
404 gv_puts(" | nxmsh2(big): out_cap_derived=" as *u8); gv_num(ocd10); gv_puts(" out_used=" as *u8); gv_num(ocu10); gv_puts("\n" as *u8)
405 var t12: i64 = 0
406 if ocd1 > 0 { if ocu1 > 0 { if ocu1 <= ocd1 { if ocd10 > 0 { if ocu10 > 0 { if ocu10 <= ocd10 { t12 = 1 } } } } } }
407 gv_check("output-capacity-is-DERIVED-and-announced-on-both-paths (out_used <= out_cap_derived)" as *u8, t12, ctr)
408
409 // ---- T9: the subject actually ran (not 127, not a harness sentinel) ----
410 var ran: i64 = 1
411 if rc1 < 0 { ran = 0 }
412 if rc1 == NG_EXEC_FAIL { ran = 0 }
413 gv_check("neg-control-subject-actually-executed (not 127, not a harness sentinel)" as *u8, ran, ctr)
414
415 let rc: i64 = gv_verdict("NXA2GLB" as *u8, ctr, "the rig survives export: skins/JOINTS_0/WEIGHTS_0/IBM read back by two independent readers, weights exact, bitten both ways" as *u8)
416 sys_exit(rc)
417 return rc
418}