nx_asset_catalog_gate.nx source
↩ module page · 369 lines · 20305 B
1// nx_asset_catalog_gate.nx -- KAT + TEETH for nx_asset_catalog (R1 of the universal org-tooling arc).
2//
3// Proves the content-addressed CATALOG over REAL R0 asset records through the REAL durable store:
4// (a) INGEST 3 DISTINCT records -> cat_count==3, and each cat_get returns the byte-faithful
5// original record bytes (the SSOT inventory round-trips)
6// (b) DEDUP teeth -> ingest a 4th record whose bytes EQUAL record #1: status==DUP
7// and count STAYS 3 (no second copy stored = content-addressed
8// dedup, the load-bearing R1 claim)
9// (c) IDEMPOTENT teeth -> re-ingest all 3: every one returns DUP, count STAYS 3 (#10)
10// (d) LIST -> cat_list returns exactly the 3 member CIDs (set complete)
11// (e) GET-UNKNOWN teeth -> cat_get on a CID never ingested -> not-found (graceful, no crash)
12//
13// Plus an OPTIONAL real-records demo (machine image + downloaded video + human doc via R0 prov
14// helpers) in a separate catalog prefix, reporting count + that a re-ingest is DUP.
15//
16// Verdict appended to knowledge/status/asset_catalog_gate.log (additive law #13).
17// expect_exit: 0 license_tier: ORIGINAL
18import "nx_syscalls.nx"
19import "nx_canon_cid.nx"
20import "nx_seg_store.nx"
21import "nx_asset_record.nx"
22import "nx_asset_catalog.nx"
23import "nx_gate_verdict.nx"
24
25// log fd THREADED as a parameter (compiler supports const globals but not reassigning a module-level
26// var from inside a function -- match the nx_asset_record_gate / nx_blob_gate idiom).
27func g_puts(logfd: i64, s: *u8) -> i64 {
28 var n: i64 = 0
29 while s[n] != (0 as u8) { n = n + 1 }
30 sys_write(1, s, n)
31 if logfd > 0 { sys_write(logfd, s, n) }
32 return 0
33}
34
35func g_putn(logfd: i64, v: i64) -> i64 {
36 let bb: *u8 = sys_mmap(28)
37 var m: i64 = v
38 if m < 0 { g_puts(logfd, "-\x00" as *u8); m = 0 - m }
39 let t: *u8 = sys_mmap(28)
40 var k: i64 = 0
41 if m == 0 { t[0] = 48 as u8; k = 1 }
42 while m > 0 { t[k] = (48 + (m % 10)) as u8; m = m / 10; k = k + 1 }
43 var i: i64 = 0
44 while i < k { bb[i] = t[k - 1 - i]; i = i + 1 }
45 sys_write(1, bb, k)
46 if logfd > 0 { sys_write(logfd, bb, k) }
47 return 0
48}
49
50func g_streq(a: *u8, b: *u8) -> i64 {
51 var i: i64 = 0
52 while 1 == 1 {
53 if a[i] != b[i] { return 0 }
54 if a[i] == (0 as u8) { return 1 }
55 i = i + 1
56 }
57 return 1
58}
59
60// raw byte-for-byte equality of two buffers of equal length
61func g_memeq(a: *u8, b: *u8, n: i64) -> i64 {
62 var i: i64 = 0
63 while i < n { if a[i] != b[i] { return 0 } i = i + 1 }
64 return 1
65}
66
67// empty-string sentinel for omitted optional fields
68func E() -> *u8 { return "\x00" as *u8 }
69
70// set one slot of an i64 ptr-array to a string pointer
71func sset(a: *i64, i: i64, s: *u8) -> i64 { a[i] = s as i64; return 0 }
72
73// build a record from grouped core/prov/media/org field arrays -> canonical bytes into `out`;
74// returns byte length. (Same DRY helper idiom as the R0 gate; under the 16-arg call cap.)
75func mk_rec(core: *i64, prov: *i64, media: *i64, org: *i64, out: *u8) -> i64 {
76 let keys: *i64 = sys_mmap(8 * 48) as *i64
77 let vals: *i64 = sys_mmap(8 * 48) as *i64
78 let n: i64 = ar_fields(core, prov, media, org, keys, vals)
79 return ar_encode(keys, vals, n, out)
80}
81
82// build a UNIQUE fresh-prefix store path "<base><stamp>-" into `prefix` so each run starts clean +
83// idempotent (identical idiom to the R0 gate). stamp = sys_now_ms() + a caller salt to separate the
84// two catalogs created in one run (same-ms collisions otherwise share a store).
85func mk_prefix(prefix: *u8, base: *u8, salt: i64) -> i64 {
86 var po: i64 = 0
87 while base[po] != (0 as u8) { prefix[po] = base[po]; po = po + 1 }
88 var m: i64 = sys_now_ms() + salt
89 let ds: *u8 = sys_mmap(28)
90 var k: i64 = 0
91 if m == 0 { ds[0] = 48 as u8; k = 1 }
92 while m > 0 { ds[k] = (48 + (m % 10)) as u8; m = m / 10; k = k + 1 }
93 var j: i64 = 0
94 while j < k { prefix[po] = ds[k - 1 - j]; po = po + 1; j = j + 1 }
95 prefix[po] = 45 as u8; po = po + 1 // '-'
96 prefix[po] = 0 as u8
97 return po
98}
99
100func main() -> i64 {
101 let logfd: i64 = sys_openat_append("knowledge/status/asset_catalog_gate.log\x00" as *u8, 0x1a4)
102 g_puts(logfd, "=== ASSET-CATALOG-GATE (R1: content-addressed SSOT catalog, dedup + idempotent) ===\n\x00" as *u8)
103
104 var pass: i64 = 0
105 var total: i64 = 0
106
107 let prefix: *u8 = sys_mmap(256)
108 mk_prefix(prefix, "/tmp/cat-\x00" as *u8, 0)
109 g_puts(logfd, " store prefix=\x00" as *u8); g_puts(logfd, prefix); g_puts(logfd, "\n\x00" as *u8)
110
111 // ============================================================================================
112 // Build 3 DISTINCT records (3 different titles -> 3 different CIDs by construction).
113 let core1: *i64 = sys_mmap(8 * 8) as *i64
114 sset(core1, 0, "image\x00" as *u8); sset(core1, 1, "Record one\x00" as *u8)
115 sset(core1, 2, "Nishi\x00" as *u8); sset(core1, 3, "2026-06-18\x00" as *u8)
116 sset(core1, 4, "id-1\x00" as *u8); sset(core1, 5, E()); sset(core1, 6, E())
117 let core2: *i64 = sys_mmap(8 * 8) as *i64
118 sset(core2, 0, "doc\x00" as *u8); sset(core2, 1, "Record two\x00" as *u8)
119 sset(core2, 2, "Nishi\x00" as *u8); sset(core2, 3, "2026-06-18\x00" as *u8)
120 sset(core2, 4, "id-2\x00" as *u8); sset(core2, 5, E()); sset(core2, 6, E())
121 let core3: *i64 = sys_mmap(8 * 8) as *i64
122 sset(core3, 0, "video\x00" as *u8); sset(core3, 1, "Record three\x00" as *u8)
123 sset(core3, 2, "Nishi\x00" as *u8); sset(core3, 3, "2026-06-18\x00" as *u8)
124 sset(core3, 4, "id-3\x00" as *u8); sset(core3, 5, E()); sset(core3, 6, E())
125 // shared empty prov/media/org for the fixtures
126 let pz: *i64 = sys_mmap(8 * 8) as *i64
127 sset(pz, 0, E()); sset(pz, 1, E()); sset(pz, 2, E()); sset(pz, 3, E()); sset(pz, 4, E()); sset(pz, 5, E())
128 let mz: *i64 = sys_mmap(8 * 8) as *i64
129 sset(mz, 0, E()); sset(mz, 1, E()); sset(mz, 2, E()); sset(mz, 3, E())
130 let oz: *i64 = sys_mmap(8 * 8) as *i64
131 sset(oz, 0, E()); sset(oz, 1, E()); sset(oz, 2, E()); sset(oz, 3, E()); sset(oz, 4, E()); sset(oz, 5, E())
132
133 let rec1: *u8 = sys_mmap(8192)
134 let len1: i64 = mk_rec(core1, pz, mz, oz, rec1)
135 let rec2: *u8 = sys_mmap(8192)
136 let len2: i64 = mk_rec(core2, pz, mz, oz, rec2)
137 let rec3: *u8 = sys_mmap(8192)
138 let len3: i64 = mk_rec(core3, pz, mz, oz, rec3)
139
140 let cid1: *u8 = sys_mmap(128)
141 let cid2: *u8 = sys_mmap(128)
142 let cid3: *u8 = sys_mmap(128)
143 ar_cid(rec1, len1, cid1)
144 ar_cid(rec2, len2, cid2)
145 ar_cid(rec3, len3, cid3)
146 g_puts(logfd, " cid1=\x00" as *u8); g_puts(logfd, cid1); g_puts(logfd, "\n\x00" as *u8)
147 g_puts(logfd, " cid2=\x00" as *u8); g_puts(logfd, cid2); g_puts(logfd, "\n\x00" as *u8)
148 g_puts(logfd, " cid3=\x00" as *u8); g_puts(logfd, cid3); g_puts(logfd, "\n\x00" as *u8)
149
150 // ============================================================================================
151 // (a) INGEST 3 DISTINCT -> all NEW, count==3, byte-faithful cat_get each
152 let st: *i64 = sys_mmap(16) as *i64
153 let r1: i64 = cat_ingest(prefix, rec1, len1, st)
154 let s1: i64 = st[0]
155 let r2: i64 = cat_ingest(prefix, rec2, len2, st)
156 let s2: i64 = st[0]
157 let r3: i64 = cat_ingest(prefix, rec3, len3, st)
158 let s3: i64 = st[0]
159 g_puts(logfd, " ingest statuses (want NEW=1 each): \x00" as *u8)
160 g_putn(logfd, s1); g_puts(logfd, ",\x00" as *u8); g_putn(logfd, s2); g_puts(logfd, ",\x00" as *u8); g_putn(logfd, s3); g_puts(logfd, "\n\x00" as *u8)
161
162 total = total + 1
163 g_puts(logfd, " (a1) 3 distinct ingest all rc==0 && status==NEW: \x00" as *u8)
164 var a1: i64 = 1
165 if r1 != 0 { a1 = 0 }
166 if r2 != 0 { a1 = 0 }
167 if r3 != 0 { a1 = 0 }
168 if s1 != CAT_NEW() { a1 = 0 }
169 if s2 != CAT_NEW() { a1 = 0 }
170 if s3 != CAT_NEW() { a1 = 0 }
171 if a1 == 1 { pass = pass + 1; g_puts(logfd, "PASS\n\x00" as *u8) } else { g_puts(logfd, "FAIL\n\x00" as *u8) }
172
173 let c_after3: i64 = cat_count(prefix)
174 total = total + 1
175 g_puts(logfd, " (a2) cat_count==3 (got \x00" as *u8); g_putn(logfd, c_after3); g_puts(logfd, "): \x00" as *u8)
176 if c_after3 == 3 { pass = pass + 1; g_puts(logfd, "PASS\n\x00" as *u8) } else { g_puts(logfd, "FAIL\n\x00" as *u8) }
177
178 // byte-faithful cat_get of each of the 3
179 let gp: *i64 = sys_mmap(16) as *i64
180 let gl: *i64 = sys_mmap(16) as *i64
181 total = total + 1
182 g_puts(logfd, " (a3) cat_get each returns byte-faithful original: \x00" as *u8)
183 var a3: i64 = 1
184 var gr: i64 = cat_get(prefix, cid1, gp, gl)
185 if gr != 1 { a3 = 0 } else { if gl[0] != len1 { a3 = 0 } else { if g_memeq(gp[0] as *u8, rec1, len1) == 0 { a3 = 0 } } }
186 gr = cat_get(prefix, cid2, gp, gl)
187 if gr != 1 { a3 = 0 } else { if gl[0] != len2 { a3 = 0 } else { if g_memeq(gp[0] as *u8, rec2, len2) == 0 { a3 = 0 } } }
188 gr = cat_get(prefix, cid3, gp, gl)
189 if gr != 1 { a3 = 0 } else { if gl[0] != len3 { a3 = 0 } else { if g_memeq(gp[0] as *u8, rec3, len3) == 0 { a3 = 0 } } }
190 if a3 == 1 { pass = pass + 1; g_puts(logfd, "PASS\n\x00" as *u8) } else { g_puts(logfd, "FAIL\n\x00" as *u8) }
191
192 // ============================================================================================
193 // (b) DEDUP: ingest a 4th record whose bytes EQUAL record #1 -> status==DUP, count STAYS 3.
194 // Re-build record #1 from FRESH arrays (different memory, identical fields) to prove the dedup is
195 // by CONTENT/CID, not pointer identity.
196 let core1b: *i64 = sys_mmap(8 * 8) as *i64
197 sset(core1b, 0, "image\x00" as *u8); sset(core1b, 1, "Record one\x00" as *u8)
198 sset(core1b, 2, "Nishi\x00" as *u8); sset(core1b, 3, "2026-06-18\x00" as *u8)
199 sset(core1b, 4, "id-1\x00" as *u8); sset(core1b, 5, E()); sset(core1b, 6, E())
200 let rec1b: *u8 = sys_mmap(8192)
201 let len1b: i64 = mk_rec(core1b, pz, mz, oz, rec1b)
202 // sanity: these bytes really do equal rec1 (same CID) -- the precondition of the dedup test
203 let cid1b: *u8 = sys_mmap(128)
204 ar_cid(rec1b, len1b, cid1b)
205 let dup_cid: i64 = g_streq(cid1b, cid1)
206 let st2: *i64 = sys_mmap(16) as *i64
207 let r4: i64 = cat_ingest(prefix, rec1b, len1b, st2)
208 let s4: i64 = st2[0]
209 let c_after_dup: i64 = cat_count(prefix)
210 g_puts(logfd, " 4th-ingest(==rec1) status (want DUP=2)=\x00" as *u8); g_putn(logfd, s4)
211 g_puts(logfd, " count-after=\x00" as *u8); g_putn(logfd, c_after_dup)
212 g_puts(logfd, " (precondition cid1b==cid1=\x00" as *u8); g_putn(logfd, dup_cid); g_puts(logfd, ")\n\x00" as *u8)
213 total = total + 1
214 g_puts(logfd, " (b) DEDUP: identical bytes -> status==DUP && count STAYS 3 (no 2nd copy): \x00" as *u8)
215 var b_ok: i64 = 1
216 if dup_cid != 1 { b_ok = 0 } // precondition must hold
217 if r4 != 0 { b_ok = 0 }
218 if s4 != CAT_DUP() { b_ok = 0 }
219 if c_after_dup != 3 { b_ok = 0 }
220 if b_ok == 1 { pass = pass + 1; g_puts(logfd, "PASS\n\x00" as *u8) } else { g_puts(logfd, "FAIL\n\x00" as *u8) }
221
222 // ============================================================================================
223 // (c) IDEMPOTENT: re-ingest all 3 -> every one DUP, count STAYS 3.
224 let ri1: i64 = cat_ingest(prefix, rec1, len1, st); let si1: i64 = st[0]
225 let ri2: i64 = cat_ingest(prefix, rec2, len2, st); let si2: i64 = st[0]
226 let ri3: i64 = cat_ingest(prefix, rec3, len3, st); let si3: i64 = st[0]
227 let c_after_re: i64 = cat_count(prefix)
228 g_puts(logfd, " re-ingest statuses (want DUP=2 each): \x00" as *u8)
229 g_putn(logfd, si1); g_puts(logfd, ",\x00" as *u8); g_putn(logfd, si2); g_puts(logfd, ",\x00" as *u8); g_putn(logfd, si3)
230 g_puts(logfd, " count-after=\x00" as *u8); g_putn(logfd, c_after_re); g_puts(logfd, "\n\x00" as *u8)
231 total = total + 1
232 g_puts(logfd, " (c) IDEMPOTENT: re-ingest all 3 -> all DUP && count STAYS 3: \x00" as *u8)
233 var c_ok: i64 = 1
234 if ri1 != 0 { c_ok = 0 }
235 if ri2 != 0 { c_ok = 0 }
236 if ri3 != 0 { c_ok = 0 }
237 if si1 != CAT_DUP() { c_ok = 0 }
238 if si2 != CAT_DUP() { c_ok = 0 }
239 if si3 != CAT_DUP() { c_ok = 0 }
240 if c_after_re != 3 { c_ok = 0 }
241 if c_ok == 1 { pass = pass + 1; g_puts(logfd, "PASS\n\x00" as *u8) } else { g_puts(logfd, "FAIL\n\x00" as *u8) }
242
243 // ============================================================================================
244 // (d) LIST returns exactly the 3 CIDs (set complete -- each of cid1/cid2/cid3 present, count==3).
245 let lst: *i64 = sys_mmap(8 * 64) as *i64
246 let nl: i64 = cat_list(prefix, lst, 64)
247 g_puts(logfd, " cat_list count=\x00" as *u8); g_putn(logfd, nl); g_puts(logfd, "\n\x00" as *u8)
248 total = total + 1
249 g_puts(logfd, " (d) cat_list == exactly {cid1,cid2,cid3}: \x00" as *u8)
250 var d_ok: i64 = 1
251 if nl != 3 { d_ok = 0 }
252 if cat_idx_has(lst, nl, cid1) == 0 { d_ok = 0 }
253 if cat_idx_has(lst, nl, cid2) == 0 { d_ok = 0 }
254 if cat_idx_has(lst, nl, cid3) == 0 { d_ok = 0 }
255 if d_ok == 1 { pass = pass + 1; g_puts(logfd, "PASS\n\x00" as *u8) } else { g_puts(logfd, "FAIL\n\x00" as *u8) }
256
257 // ============================================================================================
258 // (e) GET-UNKNOWN: a CID never ingested -> not-found (graceful, no crash). Use a well-formed but
259 // absent CID (rec1's CID with its last hex nibble flipped).
260 let unk: *u8 = sys_mmap(128)
261 var u: i64 = 0
262 while cid1[u] != (0 as u8) { unk[u] = cid1[u]; u = u + 1 }
263 unk[u] = 0 as u8
264 let last: i64 = u - 1
265 if unk[last] == (97 as u8) { unk[last] = 98 as u8 } else { unk[last] = 97 as u8 } // 'a'<->'b'
266 let ug: i64 = cat_get(prefix, unk, gp, gl)
267 g_puts(logfd, " cat_get(unknown CID) rc=\x00" as *u8); g_putn(logfd, ug); g_puts(logfd, " (want -1 absent)\n\x00" as *u8)
268 total = total + 1
269 g_puts(logfd, " (e) get-unknown-CID -> not-found (rc<=0, graceful): \x00" as *u8)
270 if ug <= 0 { pass = pass + 1; g_puts(logfd, "PASS\n\x00" as *u8) } else { g_puts(logfd, "FAIL\n\x00" as *u8) }
271
272 // ============================================================================================
273 // OPTIONAL: REAL sample records via R0's provenance helpers in a SEPARATE catalog prefix.
274 // (machine-generated image + downloaded video + human-authored doc) -> count==3, re-ingest DUP.
275 g_puts(logfd, " --- real-records demo (machine img / downloaded video / human doc) ---\n\x00" as *u8)
276 let dpfx: *u8 = sys_mmap(256)
277 mk_prefix(dpfx, "/tmp/catdemo-\x00" as *u8, 7)
278
279 // machine-generated image
280 let mpc: *u8 = sys_mmap(64)
281 let mpa: *u8 = sys_mmap(64)
282 let mpt: *u8 = sys_mmap(128)
283 let mpm: *u8 = sys_mmap(128)
284 ar_prov_machine("nishi-gen-img\x00" as *u8, "sdxl-v1\x00" as *u8, mpc, mpa, mpt, mpm)
285 let dcore1: *i64 = sys_mmap(8 * 8) as *i64
286 sset(dcore1, 0, "image\x00" as *u8); sset(dcore1, 1, "Generated sunset\x00" as *u8)
287 sset(dcore1, 2, "Nishi Studio\x00" as *u8); sset(dcore1, 3, "2026-06-18\x00" as *u8)
288 sset(dcore1, 4, E()); sset(dcore1, 5, E()); sset(dcore1, 6, E())
289 let dprov1: *i64 = sys_mmap(8 * 8) as *i64
290 sset(dprov1, 0, mpc); sset(dprov1, 1, mpa); sset(dprov1, 2, mpt); sset(dprov1, 3, mpm); sset(dprov1, 4, E()); sset(dprov1, 5, E())
291 let dmed1: *i64 = sys_mmap(8 * 8) as *i64
292 sset(dmed1, 0, "1920\x00" as *u8); sset(dmed1, 1, "1080\x00" as *u8); sset(dmed1, 2, E()); sset(dmed1, 3, "image/png\x00" as *u8)
293 let dorg1: *i64 = sys_mmap(8 * 8) as *i64
294 sset(dorg1, 0, "sunset\x00" as *u8); sset(dorg1, 1, "/volume1/assets/gen.png\x00" as *u8)
295 sset(dorg1, 2, "manage\x00" as *u8); sset(dorg1, 3, "1\x00" as *u8); sset(dorg1, 4, "private\x00" as *u8); sset(dorg1, 5, E())
296 let drecI: *u8 = sys_mmap(8192)
297 let dlenI: i64 = mk_rec(dcore1, dprov1, dmed1, dorg1, drecI)
298
299 // downloaded video
300 let dvc: *u8 = sys_mmap(64)
301 let dva: *u8 = sys_mmap(64)
302 let dvs: *u8 = sys_mmap(256)
303 let dvd: *u8 = sys_mmap(64)
304 ar_prov_downloaded("https://example.com/clip.mp4\x00" as *u8, "2026-06-17\x00" as *u8, dvc, dva, dvs, dvd)
305 let dcore2: *i64 = sys_mmap(8 * 8) as *i64
306 sset(dcore2, 0, "video\x00" as *u8); sset(dcore2, 1, "Reference clip\x00" as *u8)
307 sset(dcore2, 2, E()); sset(dcore2, 3, E()); sset(dcore2, 4, E()); sset(dcore2, 5, E()); sset(dcore2, 6, E())
308 let dprov2: *i64 = sys_mmap(8 * 8) as *i64
309 sset(dprov2, 0, dvc); sset(dprov2, 1, dva); sset(dprov2, 2, E()); sset(dprov2, 3, E()); sset(dprov2, 4, dvs); sset(dprov2, 5, dvd)
310 let dmed2: *i64 = sys_mmap(8 * 8) as *i64
311 sset(dmed2, 0, "1280\x00" as *u8); sset(dmed2, 1, "720\x00" as *u8); sset(dmed2, 2, "00:02:31\x00" as *u8); sset(dmed2, 3, "video/mp4\x00" as *u8)
312 let dorg2: *i64 = sys_mmap(8 * 8) as *i64
313 sset(dorg2, 0, "reference\x00" as *u8); sset(dorg2, 1, "/volume1/dl/clip.mp4\x00" as *u8)
314 sset(dorg2, 2, "ingest\x00" as *u8); sset(dorg2, 3, "1\x00" as *u8); sset(dorg2, 4, "private\x00" as *u8); sset(dorg2, 5, E())
315 let drecV: *u8 = sys_mmap(8192)
316 let dlenV: i64 = mk_rec(dcore2, dprov2, dmed2, dorg2, drecV)
317
318 // human-authored doc
319 let dhc: *u8 = sys_mmap(64)
320 let dha: *u8 = sys_mmap(64)
321 ar_prov_human("Elder Westover\x00" as *u8, dhc, dha)
322 let dcore3: *i64 = sys_mmap(8 * 8) as *i64
323 sset(dcore3, 0, "doc\x00" as *u8); sset(dcore3, 1, "Family charter\x00" as *u8)
324 sset(dcore3, 2, "Elder Westover\x00" as *u8); sset(dcore3, 3, "2026-06-18\x00" as *u8)
325 sset(dcore3, 4, E()); sset(dcore3, 5, "governance\x00" as *u8); sset(dcore3, 6, E())
326 let dprov3: *i64 = sys_mmap(8 * 8) as *i64
327 sset(dprov3, 0, dhc); sset(dprov3, 1, dha); sset(dprov3, 2, E()); sset(dprov3, 3, E()); sset(dprov3, 4, E()); sset(dprov3, 5, E())
328 let dmed3: *i64 = sys_mmap(8 * 8) as *i64
329 sset(dmed3, 0, E()); sset(dmed3, 1, E()); sset(dmed3, 2, E()); sset(dmed3, 3, E())
330 let dorg3: *i64 = sys_mmap(8 * 8) as *i64
331 sset(dorg3, 0, "charter,family\x00" as *u8); sset(dorg3, 1, "/volume1/docs/charter.md\x00" as *u8)
332 sset(dorg3, 2, "use\x00" as *u8); sset(dorg3, 3, "1\x00" as *u8); sset(dorg3, 4, "professional\x00" as *u8); sset(dorg3, 5, E())
333 let drecD: *u8 = sys_mmap(8192)
334 let dlenD: i64 = mk_rec(dcore3, dprov3, dmed3, dorg3, drecD)
335
336 let dst: *i64 = sys_mmap(16) as *i64
337 cat_ingest(dpfx, drecI, dlenI, dst); let ds1: i64 = dst[0]
338 cat_ingest(dpfx, drecV, dlenV, dst); let ds2: i64 = dst[0]
339 cat_ingest(dpfx, drecD, dlenD, dst); let ds3: i64 = dst[0]
340 let dcount: i64 = cat_count(dpfx)
341 // re-ingest the image -> must be DUP, count unchanged
342 cat_ingest(dpfx, drecI, dlenI, dst); let ds_re: i64 = dst[0]
343 let dcount2: i64 = cat_count(dpfx)
344 g_puts(logfd, " demo ingest statuses=\x00" as *u8); g_putn(logfd, ds1); g_puts(logfd, ",\x00" as *u8); g_putn(logfd, ds2)
345 g_puts(logfd, ",\x00" as *u8); g_putn(logfd, ds3); g_puts(logfd, " demo count=\x00" as *u8); g_putn(logfd, dcount)
346 g_puts(logfd, " re-ingest-status=\x00" as *u8); g_putn(logfd, ds_re); g_puts(logfd, " count-after=\x00" as *u8); g_putn(logfd, dcount2); g_puts(logfd, "\n\x00" as *u8)
347 total = total + 1
348 g_puts(logfd, " (f) REAL records: 3 NEW -> count==3, re-ingest DUP -> count stays 3: \x00" as *u8)
349 var f_ok: i64 = 1
350 if ds1 != CAT_NEW() { f_ok = 0 }
351 if ds2 != CAT_NEW() { f_ok = 0 }
352 if ds3 != CAT_NEW() { f_ok = 0 }
353 if dcount != 3 { f_ok = 0 }
354 if ds_re != CAT_DUP() { f_ok = 0 }
355 if dcount2 != 3 { f_ok = 0 }
356 if f_ok == 1 { pass = pass + 1; g_puts(logfd, "PASS\n\x00" as *u8) } else { g_puts(logfd, "FAIL\n\x00" as *u8) }
357
358 // ============================================================================================
359 g_puts(logfd, "ASSET-CATALOG-GATE passed \x00" as *u8); g_putn(logfd, pass); g_puts(logfd, "/\x00" as *u8); g_putn(logfd, total)
360 // MIGRATED onto nx_gate_verdict by nx_gate_dry_apply (D001, minimal form): every check
361 // row above is untouched, so the PASS/FAIL vector cannot change; only the hand-rolled
362 // verdict emission is replaced by the ONE shared base class. Proven by nx_gate_migrate verify.
363 let ctr__dry: *i64 = gv_ctr()
364 ctr__dry[0] = pass
365 ctr__dry[1] = total
366 let rc__dry: i64 = gv_verdict("ASSET-CATALOG-GATE" as *u8, ctr__dry, "teeth unchanged; verdict emission migrated onto the shared base class" as *u8)
367 sys_exit(rc__dry)
368 return rc__dry
369}