code wiki / _hdl_build / nx_media_inventory_lib.nx
nx_media_inventory_lib.nx source
↩ module page · 489 lines · 27289 B
1// nx_media_inventory_lib.nx -- the audited 'what media we have' surface (Phase 1A organ, per SPEC
2// knowledge/store/media-inventory/nx_media_inventory.SPEC.txt). Sovereign census over recordings + movies +
3// books: OWNS its seg_store keys (store-law), emits VIEW files, reconciles catalog-vs-disk into an id-STABLE
4// stale-set (the gallery serve consults it to skip rotated recordings WITHOUT renumbering ids), and tags a
5// privacy CATEGORY (recordings default NSFW, fail-closed). LOCAL only, metadata-only, ZERO external calls.
6// The count is whatever the getdents WALK measures -- nothing hardcoded (anti-fabrication). license_tier: ORIGINAL
7import "nx_syscalls.nx"
8import "nx_seg_store.nx"
9const INV_MAGIC_1048576: i64 = 1048576
10const INV_MAGIC_8192: i64 = 8192
11const INV_MAGIC_4000000: i64 = 4000000
12const INV_MAGIC_1048640: i64 = 1048640
13const INV_MAGIC_8388608: i64 = 8388608
14const INV_MAGIC_2097152: i64 = 2097152
15const INV_MAGIC_524288: i64 = 524288
16const INV_MAGIC_65536: i64 = 65536
17const INV_MAGIC_2097000: i64 = 2097000
18const INV_MAGIC_12582912: i64 = 12582912
19const INV_MAGIC_8190: i64 = 8190
20const INV_MAGIC_4194304: i64 = 4194304
21const INV_MAGIC_4096: i64 = 4096
22const INV_MAGIC_1024: i64 = 1024
23
24// ---- data-driven config (rule 11: roots/paths/exts, no magic buried in logic) ----
25const INV_PREFIX: *u8 = "knowledge/store/media-inventory/inv-" as *u8
26const INV_ROOT_LOGS: *u8 = "/volume1/logs" as *u8
27const INV_ROOT_LOGGING:*u8 = "/volume1/logging" as *u8
28const INV_ROOT_MOVIES: *u8 = "/volume1/movies" as *u8
29const INV_ROOT_BOOKS: *u8 = "/volume1/homes/elderwesto/books" as *u8
30const INV_CATALOG: *u8 = "/volume1/ai/galx/knowledge/status/galx_vid_paths.tsv" as *u8
31const INV_STALEBIN: *u8 = "/volume1/ai/galx/knowledge/status/galx_stale.bin" as *u8
32const INV_STALEBIN_ALT:*u8 = "knowledge/store/media-inventory/galx_stale.bin" as *u8
33const INV_VIEW_REC: *u8 = "knowledge/store/media-inventory/rec_by_performer.tsv" as *u8
34const INV_VIEW_SUM: *u8 = "knowledge/store/media-inventory/inventory_summary.txt" as *u8
35
36// ---- basic string helpers (mirror the proven nx_nas_book_census bc_* / nx_media_census mc_* idioms) ----
37func iv_slen(s: *u8) -> i64 { var n: i64 = 0; while s[n] != (0 as u8) { n = n + 1 } return n }
38func iv_cat(dst: *u8, off: i64, s: *u8) -> i64 { var i: i64 = 0; while s[i] != (0 as u8) { dst[off+i] = s[i]; i = i + 1 } return off + i }
39func iv_streq(a: *u8, b: *u8) -> i64 { var i: i64 = 0; while a[i] != (0 as u8) { if a[i] != b[i] { return 0 } i = i + 1 } if b[i] != (0 as u8) { return 0 } return 1 }
40func iv_w(fd: i64, s: *u8) -> i64 { sys_write(fd, s, iv_slen(s)); return 0 }
41func iv_n(fd: i64, v: i64) -> i64 { let bb: *u8 = sys_mmap(32); var m: i64 = v; if m < 0 { m = 0 - m; sys_write(fd, "-" as *u8, 1) } let t: *u8 = sys_mmap(32); 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(fd, bb, k); return 0 }
42func iv_p(s: *u8) -> i64 { iv_w(1, s); return 0 }
43func iv_pn(v: i64) -> i64 { iv_n(1, v); return 0 }
44// write integer v into dst at off; return new off (radix-10)
45func iv_ntoa(dst: *u8, off: i64, v: i64) -> i64 { var o: i64 = off; var m: i64 = v; if m < 0 { dst[o] = 45 as u8; o = o + 1; m = 0 - m } let t: *u8 = sys_mmap(32); 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 { dst[o+i] = t[k-1-i]; i = i + 1 } return o + k }
46// 1 if NUL-term name ends with the 3-byte suffix .ts (case-sensitive; recordings are lowercase .ts)
47func iv_ends_ts(nm: *u8) -> i64 { let n: i64 = iv_slen(nm); if n < 3 { return 0 } if nm[n-3] != (46 as u8) { return 0 } if nm[n-1] != (115 as u8) { return 0 } if nm[n-2] != (116 as u8) { return 0 } return 1 }
48// 1 if name ends with a recording video ext (.ts .mkv .mp4 .flv) -- cam captures are multi-format (catalog confirms).
49func iv_is_recext(nm: *u8) -> i64 {
50 let n: i64 = iv_slen(nm)
51 if n >= 3 { if nm[n-3]==(46 as u8) { if nm[n-2]==(116 as u8) { if nm[n-1]==(115 as u8) { return 1 } } } }
52 if n >= 4 { if nm[n-4]==(46 as u8) {
53 let a: i64 = nm[n-3] as i64; let b: i64 = nm[n-2] as i64; let c: i64 = nm[n-1] as i64
54 if a==109 { if b==107 { if c==118 { return 1 } } }
55 if a==109 { if b==112 { if c==52 { return 1 } } }
56 if a==102 { if b==108 { if c==118 { return 1 } } }
57 } }
58 return 0
59}
60// does the path exist + open? (openat_rd; mirrors mc_exists -- fd<0 => absent)
61func iv_exists(path: *u8) -> i64 { let fd: i64 = sys_openat_rd(path); if fd < 0 { return 0 } sys_close(fd); return 1 }
62// full read of path into buf up to cap (read loop -- native NAS files may return partial). returns bytes, -1 on open-fail
63func iv_read_all(path: *u8, buf: *u8, cap: i64) -> i64 { let fd: i64 = sys_openat_rd(path); if fd < 0 { return 0 - 1 } var tot: i64 = 0; var done: i64 = 0; while done == 0 { if tot >= cap { done = 1 } else { let n: i64 = sys_read(fd, (buf as i64 + tot) as *u8, cap - tot); if n <= 0 { done = 1 } else { tot = tot + n } } } sys_close(fd); return tot }
64
65// count *.ts files directly inside directory dpath (depth-1; dirbuf reused, no per-call mmap). a FILE arg
66// getdents<0 => returns 0, so this is safe to call on every root entry without trusting dirent_type.
67func iv_count_ts(dpath: *u8, dirbuf: *u8) -> i64 {
68 let dfd: i64 = sys_openat_rd(dpath)
69 if dfd < 0 { return 0 }
70 var cnt: i64 = 0
71 var done: i64 = 0
72 while done == 0 {
73 let nb: i64 = sys_getdents64(dfd, dirbuf, INV_MAGIC_1048576)
74 if nb <= 0 { done = 1 }
75 else {
76 var off: i64 = 0
77 while off < nb {
78 let rec: *u8 = (dirbuf as i64 + off) as *u8
79 let rl: i64 = dirent_reclen(rec)
80 if rl <= 0 { off = nb }
81 else {
82 if iv_is_recext(dirent_name(rec)) == 1 { cnt = cnt + 1 }
83 off = off + rl
84 }
85 }
86 }
87 }
88 sys_close(dfd)
89 return cnt
90}
91
92// merge one performer into the parallel-array table (union across roots). rootbit: 1=logs 2=logging.
93// npc[0]=count of performers, pusedc[0]=bytes used in names arena. linear search = the union dedupe (T2).
94func iv_merge_perf(name: *u8, cnt: i64, rootbit: i64, pnames: *u8, pnoff: *i64, pcount: *i64, pmask: *i64, npc: *i64, pusedc: *i64) -> i64 {
95 var k: i64 = 0
96 let np: i64 = npc[0]
97 while k < np {
98 if iv_streq((pnames as i64 + pnoff[k]) as *u8, name) == 1 {
99 pcount[k] = pcount[k] + cnt
100 pmask[k] = pmask[k] | rootbit
101 return 0
102 }
103 k = k + 1
104 }
105 let base: i64 = pusedc[0]
106 var i: i64 = 0
107 while name[i] != (0 as u8) { pnames[base+i] = name[i]; i = i + 1 }
108 pnames[base+i] = 0 as u8
109 pnoff[np] = base
110 pcount[np] = cnt
111 pmask[np] = rootbit
112 npc[0] = np + 1
113 pusedc[0] = base + i + 1
114 return 0
115}
116
117// walk one recordings root: each entry that holds >=1 .ts is a performer. returns #performer-dirs found here.
118func iv_walk_rec_root(root: *u8, rootbit: i64, dirbuf: *u8, cbuf: *u8, child: *u8, pnames: *u8, pnoff: *i64, pcount: *i64, pmask: *i64, npc: *i64, pusedc: *i64) -> i64 {
119 let rfd: i64 = sys_openat_rd(root)
120 if rfd < 0 { return 0 }
121 let rlen: i64 = iv_slen(root)
122 var found: i64 = 0
123 var done: i64 = 0
124 while done == 0 {
125 let nb: i64 = sys_getdents64(rfd, dirbuf, INV_MAGIC_1048576)
126 if nb <= 0 { done = 1 }
127 else {
128 var off: i64 = 0
129 while off < nb {
130 let rec: *u8 = (dirbuf as i64 + off) as *u8
131 let rl: i64 = dirent_reclen(rec)
132 if rl <= 0 { off = nb }
133 else {
134 let nm: *u8 = dirent_name(rec)
135 var skip: i64 = 0
136 if nm[0] == (46 as u8) { if nm[1] == (0 as u8) { skip = 1 } else { if nm[1] == (46 as u8) { if nm[2] == (0 as u8) { skip = 1 } } } }
137 if skip == 0 {
138 var w: i64 = 0
139 while w < rlen { child[w] = root[w]; w = w + 1 }
140 child[w] = 47 as u8; w = w + 1
141 var z: i64 = 0
142 while nm[z] != (0 as u8) { child[w] = nm[z]; w = w + 1; z = z + 1 }
143 child[w] = 0 as u8
144 let c: i64 = iv_count_ts(child, cbuf)
145 if c > 0 { iv_merge_perf(nm, c, rootbit, pnames, pnoff, pcount, pmask, npc, pusedc); found = found + 1 }
146 }
147 off = off + rl
148 }
149 }
150 }
151 }
152 sys_close(rfd)
153 return found
154}
155
156// extension match against a data-driven set. kind 0 = video container, 1 = book/document. extlc = lowercased, no dot.
157func iv_ext_match(extlc: *u8, kind: i64) -> i64 {
158 if kind == 0 {
159 if iv_streq(extlc, "mp4" as *u8) == 1 { return 1 }
160 if iv_streq(extlc, "mkv" as *u8) == 1 { return 1 }
161 if iv_streq(extlc, "avi" as *u8) == 1 { return 1 }
162 if iv_streq(extlc, "ts" as *u8) == 1 { return 1 }
163 if iv_streq(extlc, "m4v" as *u8) == 1 { return 1 }
164 if iv_streq(extlc, "webm" as *u8) == 1 { return 1 }
165 if iv_streq(extlc, "mov" as *u8) == 1 { return 1 }
166 if iv_streq(extlc, "mpg" as *u8) == 1 { return 1 }
167 if iv_streq(extlc, "mpeg" as *u8) == 1 { return 1 }
168 if iv_streq(extlc, "flv" as *u8) == 1 { return 1 }
169 if iv_streq(extlc, "wmv" as *u8) == 1 { return 1 }
170 return 0
171 }
172 if iv_streq(extlc, "epub" as *u8) == 1 { return 1 }
173 if iv_streq(extlc, "mobi" as *u8) == 1 { return 1 }
174 if iv_streq(extlc, "azw" as *u8) == 1 { return 1 }
175 if iv_streq(extlc, "azw3" as *u8) == 1 { return 1 }
176 if iv_streq(extlc, "kfx" as *u8) == 1 { return 1 }
177 if iv_streq(extlc, "cbz" as *u8) == 1 { return 1 }
178 if iv_streq(extlc, "cbr" as *u8) == 1 { return 1 }
179 if iv_streq(extlc, "pdf" as *u8) == 1 { return 1 }
180 if iv_streq(extlc, "djvu" as *u8) == 1 { return 1 }
181 if iv_streq(extlc, "fb2" as *u8) == 1 { return 1 }
182 if iv_streq(extlc, "htmlz" as *u8) == 1 { return 1 }
183 return 0
184}
185
186// bounded-stack recursive file counter under root (JPL-style explicit work-stack, NOT self-recursion). dirbuf =
187// this walk's OWN getdents buffer (caller must NOT alias it with an outer iteration). parena/stkoff = scratch.
188func iv_walk_count(root: *u8, kind: i64, dirbuf: *u8, parena: *u8, stkoff: *i64, arenacap: i64, stkcap: i64) -> i64 {
189 let child: *u8 = sys_mmap(INV_MAGIC_8192)
190 let extbuf: *u8 = sys_mmap(64)
191 var pused: i64 = 0
192 var q: i64 = 0
193 while root[q] != (0 as u8) { parena[pused] = root[q]; pused = pused + 1; q = q + 1 }
194 parena[pused] = 0 as u8; pused = pused + 1
195 stkoff[0] = 0
196 var sp: i64 = 1
197 var total: i64 = 0
198 var iters: i64 = 0
199 while sp > 0 {
200 if iters >= INV_MAGIC_4000000 { sp = 0 } else {
201 iters = iters + 1
202 sp = sp - 1
203 let doff: i64 = stkoff[sp]
204 let dpath: *u8 = (parena as i64 + doff) as *u8
205 let dlen: i64 = iv_slen(dpath)
206 let dfd: i64 = sys_openat_rd(dpath)
207 if dfd >= 0 {
208 var done: i64 = 0
209 while done == 0 {
210 let nb: i64 = sys_getdents64(dfd, dirbuf, INV_MAGIC_1048576)
211 if nb <= 0 { done = 1 } else {
212 var off: i64 = 0
213 while off < nb {
214 let rec: *u8 = (dirbuf as i64 + off) as *u8
215 let rl: i64 = dirent_reclen(rec)
216 if rl <= 0 { off = nb } else {
217 let nm: *u8 = dirent_name(rec)
218 let dt: i64 = dirent_type(rec)
219 var skip: i64 = 0
220 if nm[0] == (46 as u8) { if nm[1] == (0 as u8) { skip = 1 } else { if nm[1] == (46 as u8) { if nm[2] == (0 as u8) { skip = 1 } } } }
221 if skip == 0 {
222 var w: i64 = 0
223 while w < dlen { child[w] = dpath[w]; w = w + 1 }
224 child[w] = 47 as u8; w = w + 1
225 var z: i64 = 0
226 while nm[z] != (0 as u8) { child[w] = nm[z]; w = w + 1; z = z + 1 }
227 child[w] = 0 as u8
228 let clen: i64 = w
229 if dt == 4 {
230 if sp < stkcap { if pused + clen + 1 < arenacap {
231 let cbase: i64 = pused
232 var qq: i64 = 0
233 while qq < clen { parena[pused] = child[qq]; pused = pused + 1; qq = qq + 1 }
234 parena[pused] = 0 as u8; pused = pused + 1
235 stkoff[sp] = cbase; sp = sp + 1
236 } }
237 } else {
238 if dt == 10 { } else {
239 var dotp: i64 = 0 - 1
240 var x: i64 = 0
241 while nm[x] != (0 as u8) { if nm[x] == (46 as u8) { dotp = x } x = x + 1 }
242 if dotp >= 0 {
243 var e: i64 = 0
244 var y: i64 = dotp + 1
245 while nm[y] != (0 as u8) { if e < 62 { var cc: i64 = nm[y] as i64; if cc >= 65 { if cc <= 90 { cc = cc + 32 } } extbuf[e] = cc as u8; e = e + 1 } y = y + 1 }
246 extbuf[e] = 0 as u8
247 if iv_ext_match(extbuf, kind) == 1 { total = total + 1 }
248 }
249 }
250 }
251 }
252 off = off + rl
253 }
254 }
255 }
256 }
257 sys_close(dfd)
258 }
259 }
260 }
261 return total
262}
263
264// privacy category: recordings default NSFW (fail-closed, rule 12 defensive default); movies/books general.
265func iv_category(kind: *u8) -> i64 { if iv_streq(kind, "recordings" as *u8) == 1 { return 1 } return 0 }
266// producer store read (store-law: this organ owns the inv- prefix).
267func iv_get(key: *u8, ptrout: *i64, lenout: *i64) -> i64 { return ss_get(INV_PREFIX, key, ptrout, lenout) }
268// write i64 v as 8 little-endian bytes at buf[off]; return off+8 (v assumed >= 0 -- catalog sizes/counts).
269func iv_put_i64(buf: *u8, off: i64, v: i64) -> i64 { var i: i64 = 0; var m: i64 = v; while i < 8 { buf[off+i] = (m & 255) as u8; m = m / 256; i = i + 1 } return off + 8 }
270
271// bounded caps for the movies/books walk (rule 11: named, not buried literals)
272const IV_ARENA_CAP: i64 = 33554432
273const IV_STK_CAP: i64 = 1000000
274
275// the census orchestrator: getdents WALK -> seg_store (store-law) + VIEW files + id-STABLE stale-set sidecar.
276// idempotent (rule 10): a re-run rewrites the same keys/views from a fresh walk. mode reserved (holistic today).
277func iv_build(mode: *u8) -> i64 {
278 let t0: i64 = sys_now_realtime_sec()
279 let dirbuf: *u8 = sys_mmap(INV_MAGIC_1048640)
280 let cbuf: *u8 = sys_mmap(INV_MAGIC_1048640)
281 let child: *u8 = sys_mmap(INV_MAGIC_8192)
282 let pnames: *u8 = sys_mmap(INV_MAGIC_8388608)
283 let pnoff: *i64 = sys_mmap(INV_MAGIC_1048576) as *i64
284 let pcount: *i64 = sys_mmap(INV_MAGIC_1048576) as *i64
285 let pmask: *i64 = sys_mmap(INV_MAGIC_1048576) as *i64
286 let npc: *i64 = sys_mmap(16) as *i64
287 let pusedc: *i64 = sys_mmap(16) as *i64
288 npc[0] = 0; pusedc[0] = 0
289 // recordings: union across both roots (T2 dedupe by performer name)
290 let logs_perf: i64 = iv_walk_rec_root(INV_ROOT_LOGS, 1, dirbuf, cbuf, child, pnames, pnoff, pcount, pmask, npc, pusedc)
291 let logging_perf: i64 = iv_walk_rec_root(INV_ROOT_LOGGING, 2, dirbuf, cbuf, child, pnames, pnoff, pcount, pmask, npc, pusedc)
292 let np: i64 = npc[0]
293 var total_rec: i64 = 0
294 var both: i64 = 0
295 var pi: i64 = 0
296 while pi < np { total_rec = total_rec + pcount[pi]; if pmask[pi] == 3 { both = both + 1 } pi = pi + 1 }
297 // movies: per-title recursive video-file count
298 let parena: *u8 = sys_mmap(IV_ARENA_CAP)
299 let stkoff2: *i64 = sys_mmap(INV_MAGIC_8388608) as *i64
300 let movbuf: *u8 = sys_mmap(INV_MAGIC_1048576)
301 var movoff: i64 = 0
302 var mov_files: i64 = 0
303 var mov_titles: i64 = 0
304 // collect title names FIRST, close the dir, THEN walk each (no getdents-during-getdents interleaving).
305 let titlebuf: *u8 = sys_mmap(INV_MAGIC_2097152)
306 let titleoff: *i64 = sys_mmap(INV_MAGIC_524288) as *i64
307 var ntitles: i64 = 0
308 var tused: i64 = 0
309 let mfd: i64 = sys_openat_rd(INV_ROOT_MOVIES)
310 if mfd >= 0 {
311 var mdone: i64 = 0
312 while mdone == 0 {
313 let nb: i64 = sys_getdents64(mfd, dirbuf, INV_MAGIC_1048576)
314 if nb <= 0 { mdone = 1 } else {
315 var off: i64 = 0
316 while off < nb {
317 let rec: *u8 = (dirbuf as i64 + off) as *u8
318 let rl: i64 = dirent_reclen(rec)
319 if rl <= 0 { off = nb } else {
320 let nm: *u8 = dirent_name(rec)
321 var skip: i64 = 0
322 if nm[0] == (46 as u8) { skip = 1 }
323 if nm[0] == (64 as u8) { skip = 1 }
324 if nm[0] == (35 as u8) { skip = 1 }
325 if skip == 0 { if ntitles < INV_MAGIC_65536 { if tused < INV_MAGIC_2097000 {
326 titleoff[ntitles] = tused
327 var z: i64 = 0
328 while nm[z] != (0 as u8) { titlebuf[tused] = nm[z]; tused = tused + 1; z = z + 1 }
329 titlebuf[tused] = 0 as u8; tused = tused + 1
330 ntitles = ntitles + 1
331 } } }
332 off = off + rl
333 }
334 }
335 }
336 }
337 sys_close(mfd)
338 }
339 // NOTE: directly indexing a global const *u8 (INV_ROOT_MOVIES[w]) with a runtime index MISCOMPILES under
340 // nx_cc (yields '1' bytes); copy via iv_cat (const passed as a PARAM, which indexes correctly). Root-caused 2026-07-17.
341 var ti: i64 = 0
342 while ti < ntitles {
343 let tnm: *u8 = (titlebuf as i64 + titleoff[ti]) as *u8
344 var w: i64 = iv_cat(child, 0, INV_ROOT_MOVIES)
345 child[w] = 47 as u8; w = w + 1
346 w = iv_cat(child, w, tnm)
347 child[w] = 0 as u8
348 let fc: i64 = iv_walk_count(child, 0, cbuf, parena, stkoff2, IV_ARENA_CAP, IV_STK_CAP)
349 if fc > 0 {
350 movoff = iv_cat(movbuf, movoff, tnm)
351 movbuf[movoff] = 9 as u8; movoff = movoff + 1
352 movoff = iv_ntoa(movbuf, movoff, fc)
353 movbuf[movoff] = 10 as u8; movoff = movoff + 1
354 mov_files = mov_files + fc
355 mov_titles = mov_titles + 1
356 }
357 ti = ti + 1
358 }
359 // books: recursive book-file count under the Calibre root
360 let books_total: i64 = iv_walk_count(INV_ROOT_BOOKS, 1, cbuf, parena, stkoff2, IV_ARENA_CAP, IV_STK_CAP)
361 // reconcile / id-STABLE stale-set: stat every catalog line (id = 0-based line number, matches the serve)
362 let catbuf: *u8 = sys_mmap(INV_MAGIC_12582912)
363 let catn: i64 = iv_read_all(INV_CATALOG, catbuf, INV_MAGIC_12582912)
364 let bits: *u8 = sys_mmap(INV_MAGIC_1048576)
365 let linebuf: *u8 = sys_mmap(INV_MAGIC_8192)
366 var catalog_lines: i64 = 0
367 var stale_count: i64 = 0
368 if catn > 0 {
369 var i: i64 = 0
370 var ls: i64 = 0
371 while i < catn {
372 if catbuf[i] == (10 as u8) {
373 var ce: i64 = i
374 if ce > ls { if catbuf[ce-1] == (13 as u8) { ce = ce - 1 } }
375 if ce > ls {
376 var k: i64 = ls
377 var w: i64 = 0
378 while k < ce { if w < INV_MAGIC_8190 { linebuf[w] = catbuf[k]; w = w + 1 } k = k + 1 }
379 linebuf[w] = 0 as u8
380 if iv_exists(linebuf) == 0 {
381 let byi: i64 = catalog_lines / 8
382 let bii: i64 = catalog_lines - (byi * 8)
383 bits[byi] = ((bits[byi] as i64) | (1 << bii)) as u8
384 stale_count = stale_count + 1
385 }
386 }
387 catalog_lines = catalog_lines + 1
388 ls = i + 1
389 }
390 i = i + 1
391 }
392 }
393 // emit galx_stale.bin: [tsv_size i64 LE][n_lines i64 LE][bitset ceil(n/8) bytes] -- serve-consumable sidecar
394 let hdr: *u8 = sys_mmap(32)
395 var ho: i64 = iv_put_i64(hdr, 0, catn)
396 ho = iv_put_i64(hdr, ho, catalog_lines)
397 let bitbytes: i64 = (catalog_lines + 7) / 8
398 var stalepath: i64 = 0
399 let sbf: i64 = sys_openat_wr(INV_STALEBIN, 0x1a4)
400 if sbf >= 0 { sys_write(sbf, hdr, ho); sys_write(sbf, bits, bitbytes); sys_close(sbf) } else {
401 let sbf2: i64 = sys_openat_wr(INV_STALEBIN_ALT, 0x1a4)
402 if sbf2 >= 0 { sys_write(sbf2, hdr, ho); sys_write(sbf2, bits, bitbytes); sys_close(sbf2); stalepath = 1 }
403 }
404 // recordings view/store table: performer<TAB>count<TAB>roots<TAB>category
405 let recbuf: *u8 = sys_mmap(INV_MAGIC_4194304)
406 var recoff: i64 = 0
407 var pj: i64 = 0
408 while pj < np {
409 recoff = iv_cat(recbuf, recoff, (pnames as i64 + pnoff[pj]) as *u8)
410 recbuf[recoff] = 9 as u8; recoff = recoff + 1
411 recoff = iv_ntoa(recbuf, recoff, pcount[pj])
412 recbuf[recoff] = 9 as u8; recoff = recoff + 1
413 if pmask[pj] == 3 { recoff = iv_cat(recbuf, recoff, "both" as *u8) } else { if pmask[pj] == 1 { recoff = iv_cat(recbuf, recoff, "logs" as *u8) } else { recoff = iv_cat(recbuf, recoff, "logging" as *u8) } }
414 recbuf[recoff] = 9 as u8; recoff = recoff + 1
415 recoff = iv_cat(recbuf, recoff, "NSFW" as *u8)
416 recbuf[recoff] = 10 as u8; recoff = recoff + 1
417 pj = pj + 1
418 }
419 let exist: i64 = catalog_lines - stale_count
420 let sumbuf: *u8 = sys_mmap(INV_MAGIC_4096)
421 var so: i64 = 0
422 so = iv_cat(sumbuf, so, "# NISHI MEDIA INVENTORY (sovereign census; metadata-only; nx_media_inventory)\n" as *u8)
423 so = iv_cat(sumbuf, so, "recordings_on_disk=" as *u8); so = iv_ntoa(sumbuf, so, total_rec); sumbuf[so]=10 as u8; so=so+1
424 so = iv_cat(sumbuf, so, "performers=" as *u8); so = iv_ntoa(sumbuf, so, np); sumbuf[so]=10 as u8; so=so+1
425 so = iv_cat(sumbuf, so, "performers_logs=" as *u8); so = iv_ntoa(sumbuf, so, logs_perf); sumbuf[so]=10 as u8; so=so+1
426 so = iv_cat(sumbuf, so, "performers_logging=" as *u8); so = iv_ntoa(sumbuf, so, logging_perf); sumbuf[so]=10 as u8; so=so+1
427 so = iv_cat(sumbuf, so, "performers_both_roots=" as *u8); so = iv_ntoa(sumbuf, so, both); sumbuf[so]=10 as u8; so=so+1
428 so = iv_cat(sumbuf, so, "catalog_lines=" as *u8); so = iv_ntoa(sumbuf, so, catalog_lines); sumbuf[so]=10 as u8; so=so+1
429 so = iv_cat(sumbuf, so, "stale_count=" as *u8); so = iv_ntoa(sumbuf, so, stale_count); sumbuf[so]=10 as u8; so=so+1
430 so = iv_cat(sumbuf, so, "recordings_exist_in_catalog=" as *u8); so = iv_ntoa(sumbuf, so, exist); sumbuf[so]=10 as u8; so=so+1
431 so = iv_cat(sumbuf, so, "movies_files=" as *u8); so = iv_ntoa(sumbuf, so, mov_files); sumbuf[so]=10 as u8; so=so+1
432 so = iv_cat(sumbuf, so, "movies_titles=" as *u8); so = iv_ntoa(sumbuf, so, mov_titles); sumbuf[so]=10 as u8; so=so+1
433 so = iv_cat(sumbuf, so, "books_files=" as *u8); so = iv_ntoa(sumbuf, so, books_total); sumbuf[so]=10 as u8; so=so+1
434 so = iv_cat(sumbuf, so, "recordings_category=NSFW\n" as *u8)
435 so = iv_cat(sumbuf, so, "tsv_size=" as *u8); so = iv_ntoa(sumbuf, so, catn); sumbuf[so]=10 as u8; so=so+1
436 so = iv_cat(sumbuf, so, "generated_at=" as *u8); so = iv_ntoa(sumbuf, so, t0); sumbuf[so]=10 as u8; so=so+1
437 so = iv_cat(sumbuf, so, "provenance=getdents-walk+openat-stat; no shell; counts measured not hardcoded\n" as *u8)
438 let stbuf: *u8 = sys_mmap(INV_MAGIC_1024)
439 var sto: i64 = 0
440 sto = iv_cat(stbuf, sto, "catalog_lines=" as *u8); sto = iv_ntoa(stbuf, sto, catalog_lines)
441 sto = iv_cat(stbuf, sto, " stale_count=" as *u8); sto = iv_ntoa(stbuf, sto, stale_count)
442 sto = iv_cat(stbuf, sto, " tsv_size=" as *u8); sto = iv_ntoa(stbuf, sto, catn)
443 sto = iv_cat(stbuf, sto, " stalebin=" as *u8); if stalepath == 0 { sto = iv_cat(stbuf, sto, INV_STALEBIN) } else { sto = iv_cat(stbuf, sto, INV_STALEBIN_ALT) }
444 sto = iv_cat(stbuf, sto, " generated_at=" as *u8); sto = iv_ntoa(stbuf, sto, t0)
445 // commit the store (one segment, additive history preserved by seg_store)
446 let segid: i64 = ss_next_segid(INV_PREFIX)
447 let wr: *i64 = ss_begin()
448 ss_add(wr, 1, "inv:rec:table" as *u8, recbuf, recoff)
449 ss_add(wr, 1, "inv:mov:table" as *u8, movbuf, movoff)
450 ss_add(wr, 1, "inv:summary" as *u8, sumbuf, so)
451 ss_add(wr, 1, "inv:stale" as *u8, stbuf, sto)
452 let idxs: *u8 = "inv:rec:table\ninv:mov:table\ninv:summary\ninv:stale\n" as *u8
453 ss_add(wr, 1, "__invidx__" as *u8, idxs, iv_slen(idxs))
454 let crc: i64 = ss_commit(INV_PREFIX, wr, segid)
455 // store-emitted VIEW files (secondary; the store is the truth)
456 let vr: i64 = sys_openat_wr(INV_VIEW_REC, 0x1a4)
457 if vr >= 0 { sys_write(vr, recbuf, recoff); sys_close(vr) }
458 let vs: i64 = sys_openat_wr(INV_VIEW_SUM, 0x1a4)
459 if vs >= 0 { sys_write(vs, sumbuf, so); sys_close(vs) }
460 iv_p("=== nx_media_inventory build (sovereign census) ===\n" as *u8)
461 sys_write(1, sumbuf, so)
462 if crc == 0 { iv_p("store=OK\n" as *u8) } else { iv_p("store=ERR\n" as *u8) }
463 if total_rec <= 0 { iv_p("MEDIA-INVENTORY-FAIL: recordings walk measured 0 (root perms?)\n" as *u8); return 1 }
464 iv_p("MEDIA-INVENTORY-OK\n" as *u8)
465 return 0
466}
467
468func iv_show(kind: *u8) -> i64 {
469 let po: *i64 = sys_mmap(16) as *i64
470 let lo: *i64 = sys_mmap(16) as *i64
471 let key: *u8 = sys_mmap(64)
472 var o: i64 = 0
473 if iv_streq(kind, "recordings" as *u8) == 1 { o = iv_cat(key, 0, "inv:rec:table" as *u8) } else { if iv_streq(kind, "movies" as *u8) == 1 { o = iv_cat(key, 0, "inv:mov:table" as *u8) } else { if iv_streq(kind, "stale" as *u8) == 1 { o = iv_cat(key, 0, "inv:stale" as *u8) } else { o = iv_cat(key, 0, "inv:summary" as *u8) } } }
474 key[o] = 0 as u8
475 let g: i64 = iv_get(key, po, lo)
476 if g < 1 { iv_p("MEDIA-INVENTORY: no store record for " as *u8); iv_p(key); iv_p(" (run build first)\n" as *u8); return 1 }
477 sys_write(1, po[0] as *u8, lo[0]); iv_p("\n" as *u8)
478 return 0
479}
480
481func iv_audit() -> i64 {
482 let po: *i64 = sys_mmap(16) as *i64
483 let lo: *i64 = sys_mmap(16) as *i64
484 iv_p("=== nx_media_inventory audit -- catalog vs disk reconcile (id-stable stale-set) ===\n" as *u8)
485 if iv_get("inv:stale" as *u8, po, lo) < 1 { iv_p("no inv:stale record -- run build first\n" as *u8); return 1 }
486 sys_write(1, po[0] as *u8, lo[0]); iv_p("\n" as *u8)
487 if iv_get("inv:summary" as *u8, po, lo) >= 1 { sys_write(1, po[0] as *u8, lo[0]); iv_p("\n" as *u8) }
488 return 0
489}