nx_commons_ledger_e2e_gate.nx source
↩ module page · 114 lines · 5840 B
1// nx_commons_ledger_e2e_gate.nx -- PERSIST -> RELOAD -> AGGREGATE against the real seg-store.
2//
3// WHY THIS EXISTS: nx_commons_ledger_gate proved the aggregator over rows held in memory. That is NOT
4// evidence that the ledger survives a restart, and I nearly let "the ledger persists" stand on it.
5// AN AGGREGATOR PROVEN OVER AN IN-MEMORY FIXTURE HAS PROVEN NOTHING ABOUT DURABILITY.
6// Here the rows go through sts_seed / sts_append_row into a real plane, and come back through
7// sts_load_honest into a FRESH buffer that never saw the write side.
8//
9// sts_load_honest, not sts_load: it reports truncation. A bounded read that silently returns a prefix
10// is how this estate once served a log's HEAD as its TAIL and declared a live guard dead for 12.5 days.
11// If the plane outgrows the buffer this gate must say so, not quietly aggregate half a ledger.
12// ⚠ sts_seed RETURNS A COUNT -- positive is success, not failure.
13//
14// Throwaway prefix by construction; it never touches a production plane.
15// license_tier: ORIGINAL expect_exit: 0
16import "nx_gate_verdict.nx"
17import "nx_store_seed_lib.nx"
18import "nx_commons_ledger.nx"
19
20const E2_CAP: i64 = 65536
21const E2_MAXROWS: i64 = 32
22const E2_M: i64 = 3
23
24func main() -> i64 {
25 let ctr: *i64 = gv_ctr()
26 gv_head("nx_commons_ledger_e2e_gate -- does the ledger survive a round trip through the store?" as *u8)
27
28 let prefix: *u8 = "knowledge/store/cmnsE2E" as *u8
29
30 // ---- WRITE: seed two rows, then append two more (one an exact replay) ----------------------
31 let seedbuf: *u8 = sts_mm(E2_CAP)
32 var o: i64 = cl_emit_row(1, 2, 0, 100, 10, seedbuf, 0)
33 seedbuf[o] = 10 as u8; o = o + 1
34 o = cl_emit_row(1, 3, 0, 100, 11, seedbuf, o)
35 seedbuf[o] = 10 as u8; o = o + 1
36 let seeded: i64 = sts_seed(prefix, seedbuf, o)
37
38 let row3: *u8 = sts_mm(256)
39 let l3: i64 = cl_emit_row(2, 1, 0, 50, 12, row3, 0)
40 let a3: i64 = sts_append_row(prefix, row3, l3, E2_CAP)
41 let row4: *u8 = sts_mm(256)
42 let l4: i64 = cl_emit_row(1, 2, 0, 100, 10, row4, 0) // EXACT replay of the first row
43 let a4: i64 = sts_append_row(prefix, row4, l4, E2_CAP)
44
45 // ---- RELOAD: a fresh buffer that never saw the write side ----------------------------------
46 let back: *u8 = sts_mm(E2_CAP)
47 let flags: *i64 = sts_mm(32) as *i64
48 flags[0] = 0; flags[1] = 0; flags[2] = 0; flags[3] = 0
49 let n: i64 = sts_load_honest(prefix, back, E2_CAP, flags)
50
51 gv_puts(" seeded=" as *u8); gv_num(seeded); gv_puts(" append3=" as *u8); gv_num(a3)
52 gv_puts(" append4=" as *u8); gv_num(a4); gv_puts(" reloaded_bytes=" as *u8); gv_num(n)
53 gv_puts(" declared_qn=" as *u8); gv_num(flags[0]); gv_puts(" rows_loaded=" as *u8); gv_num(flags[1])
54 gv_puts(" reachable_beyond=" as *u8); gv_num(flags[2]); gv_puts("\n" as *u8)
55
56 // ---- PARSE + AGGREGATE from the reloaded bytes ----------------------------------------------
57 let gvr: *i64 = sts_mm(E2_MAXROWS * 8) as *i64
58 let rcv: *i64 = sts_mm(E2_MAXROWS * 8) as *i64
59 let unt: *i64 = sts_mm(E2_MAXROWS * 8) as *i64
60 let att: *i64 = sts_mm(E2_MAXROWS * 8) as *i64
61 let key: *i64 = sts_mm(E2_MAXROWS * 8) as *i64
62 let parsed: i64 = cl_parse_rows(back, n, gvr, rcv, unt, att, key, E2_MAXROWS)
63
64 let ids: *i64 = sts_mm(E2_M * 8) as *i64
65 ids[0] = 1; ids[1] = 2; ids[2] = 3
66 let gave: *i64 = sts_mm(E2_M * 8) as *i64
67 let took: *i64 = sts_mm(E2_M * 8) as *i64
68 let pas: *i64 = sts_mm(E2_M * 8) as *i64
69 let ptn: *i64 = sts_mm(E2_M * 8) as *i64
70 let counted: i64 = cl_aggregate(gvr, rcv, unt, key, parsed, ids, E2_M, gave, took, pas, ptn)
71
72 gv_puts(" parsed_rows=" as *u8); gv_num(parsed); gv_puts(" counted=" as *u8); gv_num(counted)
73 gv_puts(" | id1 gave=" as *u8); gv_num(gave[0]); gv_puts(" took=" as *u8); gv_num(took[0])
74 gv_puts(" passed=" as *u8); gv_num(pas[0]); gv_puts(" partners=" as *u8); gv_num(ptn[0]); gv_puts("\n\n" as *u8)
75
76 var t1: i64 = 0
77 if seeded > 0 { t1 = 1 }
78 gv_check("T1 the plane was seeded (sts_seed returns a COUNT -- positive is success)" as *u8, t1, ctr)
79
80 // CORRECTED 2026-08-06. This asserted flags[0]==0 and called a HEALTHY reload RED. flags[0] is
81 // NOT a truncation flag -- the lib says flags[0]=declared q:n, flags[1]=rows actually loaded,
82 // flags[2]=rows reachable BEYOND q:n. A 4-row plane correctly reports flags[0]=4.
83 // I GUESSED AN API'S SEMANTICS INSTEAD OF READING THEM, AND MY GATE RAISED A FALSE ALARM ON
84 // CORRECT DATA -- the precise failure mode that costs another seat a wasted investigation.
85 // Completeness is declared == loaded, with nothing stranded past the count.
86 var t2: i64 = 0
87 if flags[0] == flags[1] { if flags[2] == 0 { if n > 0 { t2 = 1 } } }
88 gv_check("T2 reload COMPLETE: declared q:n == rows loaded, none stranded beyond" as *u8, t2, ctr)
89
90 var t3: i64 = 0
91 if parsed == 4 { t3 = 1 }
92 gv_check("T3 all four written rows round-tripped through the store and re-parsed" as *u8, t3, ctr)
93
94 var t4: i64 = 0
95 if counted == 3 { t4 = 1 }
96 gv_check("T4 the replayed row is deduped AFTER the round trip, not just in memory" as *u8, t4, ctr)
97
98 var t5: i64 = 0
99 if gave[0] == 200 { if took[0] == 50 { t5 = 1 } }
100 gv_check("T5 totals from DISK match the in-memory fixture (gave=200 took=50)" as *u8, t5, ctr)
101
102 var t6: i64 = 0
103 if pas[0] == 100 { if ptn[0] == 2 { t6 = 1 } }
104 gv_check("T6 derived onward-circulation and partners survive the round trip" as *u8, t6, ctr)
105
106 var t7: i64 = 0
107 if cl_conserved(gave, took, E2_M) == 1 { t7 = 1 }
108 gv_check("T7 CONSERVATION holds on the reloaded ledger (the parts SUM)" as *u8, t7, ctr)
109
110 let rc: i64 = gv_verdict("COMMONS-LEDGER-E2E" as *u8, ctr,
111 "contributions persist to a real plane and re-aggregate identically off disk" as *u8)
112 sys_exit(rc)
113 return rc
114}