code wiki / _hdl_build / nx_data_source_ladder.nx
nx_data_source_ladder.nx source
↩ module page · 150 lines · 7306 B
1// nx_data_source_ladder.nx -- MANHEIM-BUILD (ingestion): reads the vehicle-data source registry and emits
2// the INGESTION ORDER cheapest-first (operator: "ingest first public, then private, then expensive as the
3// last mile"). Sovereign (nx_cc->nxasm, no gcc), deterministic. Author-by-organ: the team COMPUTES the
4// order from the registry DATA -- adding a source = a registry row, zero rebuild.
5//
6// reads knowledge/registry/vehicle_data_sources.tsv (cost_tier<TAB>source<TAB>...; # comments skipped)
7// emits sources ordered by cost_tier ascending (0=public -> 1=private -> 2=paid) and the FREE-BACKBONE
8// coverage = tier0 / total (how far public-first gets us before we pay).
9//
10// GATE (self-validating): the emitted order is COST-MONOTONE non-decreasing (the cheapest-first guarantee),
11// tier0>0 (public-first is actually viable), the tier counts sum to the parsed total; and a NEG-CONTROL
12// hand-built out-of-order sequence MUST be flagged not-monotone (proves the monotone check has teeth, not
13// vacuous). A broken rule -> verdict=RED. Evidence -> knowledge/status/data_source_ladder.log.
14// license_tier: ORIGINAL
15import "nx_syscalls.nx"
16const DSL_MAGIC_65536: i64 = 65536
17const DSL_MAGIC_65535: i64 = 65535
18
19const DSL_SRC: *u8 = "knowledge/registry/vehicle_data_sources.tsv"
20const DSL_LOG: *u8 = "knowledge/status/data_source_ladder.log"
21const DSL_MAXR: i64 = 256
22
23func dsl_w(fd: i64, s: *u8) -> i64 { var n: i64 = 0; while s[n] != (0 as u8) { n = n + 1 } sys_write(fd, s, n); return 0 }
24func dsl_wn(fd: i64, v: i64) -> i64 { let bb: *u8 = sys_mmap(28); var m: i64=v; if m<0 {m=0-m; sys_write(fd,"-" as *u8,1)}; let t: *u8 = sys_mmap(28); var k: i64=0; if m==0 {t[0]=48;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 }
25func dsl_wr(fd: i64, buf: *u8, a: i64, b: i64) -> i64 { var i: i64 = a; while i < b { sys_write(fd, (((buf as i64)+i) as *u8), 1); i = i + 1 } return 0 }
26
27func dsl_read(path: *u8, buf: *u8, cap: i64) -> i64 {
28 let fd: i64 = sys_openat_rd(path)
29 if fd < 0 { return 0 - 1 }
30 var tot: i64 = 0
31 var r: i64 = 1
32 while r > 0 { let dst: *u8 = ((buf as i64) + tot) as *u8; r = sys_read(fd, dst, cap - tot); if r > 0 { tot = tot + r } }
33 sys_close(fd)
34 return tot
35}
36func dsl_eol(buf: *u8, n: i64, i: i64) -> i64 { var j: i64 = i; while j < n { if buf[j] == (10 as u8) { return j } j = j + 1 } return n }
37
38// emitted order is non-decreasing in tier? 1=yes 0=inversion found
39func dsl_monotone(tiers: *i64, n: i64) -> i64 {
40 var i: i64 = 1
41 while i < n { if tiers[i] < tiers[i-1] { return 0 } i = i + 1 }
42 return 1
43}
44
45func main() -> i64 {
46 let buf: *u8 = sys_mmap(DSL_MAGIC_65536)
47 let n: i64 = dsl_read(DSL_SRC, buf, DSL_MAGIC_65535)
48 if n <= 0 { dsl_w(1, "LADDERGATE verdict=RED reason=registry-unreadable\n" as *u8); return 1 }
49
50 let r_tier: *i64 = sys_mmap(8 * DSL_MAXR) as *i64
51 let r_off: *i64 = sys_mmap(8 * DSL_MAXR) as *i64
52 let r_end: *i64 = sys_mmap(8 * DSL_MAXR) as *i64
53 var nr: i64 = 0
54 var t0: i64 = 0
55 var t1: i64 = 0
56 var t2: i64 = 0
57
58 var i: i64 = 0
59 while i < n {
60 let le: i64 = dsl_eol(buf, n, i)
61 if le > i {
62 let c0: i64 = buf[i]
63 // data row iff first char is a tier digit 0/1/2 (comments start '#', blanks have le==i)
64 if c0 >= (48 as u8) { if c0 <= (50 as u8) {
65 let tier: i64 = c0 - (48 as u8)
66 // find first tab in [i,le) -> source starts after it
67 var p: i64 = i
68 var have_tab: i64 = 0
69 while p < le { if buf[p] == (9 as u8) { have_tab = 1; p = le } else { p = p + 1 } }
70 if have_tab == 1 {
71 var t1i: i64 = i
72 while buf[t1i] != (9 as u8) { t1i = t1i + 1 } // index of first tab
73 let soff: i64 = t1i + 1
74 var send: i64 = soff
75 var sdone: i64 = 0
76 while sdone == 0 {
77 if send >= le { sdone = 1 }
78 else { if buf[send] == (9 as u8) { sdone = 1 } else { send = send + 1 } }
79 }
80 if nr < DSL_MAXR {
81 r_tier[nr] = tier; r_off[nr] = soff; r_end[nr] = send; nr = nr + 1
82 if tier == 0 { t0 = t0 + 1 }
83 if tier == 1 { t1 = t1 + 1 }
84 if tier == 2 { t2 = t2 + 1 }
85 }
86 }
87 } }
88 }
89 i = le + 1
90 }
91
92 // emit cheapest-first + build the emitted-tier sequence for the monotone proof
93 let emit: *i64 = sys_mmap(8 * DSL_MAXR) as *i64
94 var ne: i64 = 0
95 dsl_w(1, "=== INGESTION LADDER (cheapest-first: public -> private -> paid) ===\n" as *u8)
96 var tier: i64 = 0
97 while tier <= 2 {
98 if tier == 0 { dsl_w(1, "[TIER 0 PUBLIC/free -- ingest first]\n" as *u8) }
99 if tier == 1 { dsl_w(1, "[TIER 1 PRIVATE/partnership -- ingest second]\n" as *u8) }
100 if tier == 2 { dsl_w(1, "[TIER 2 PAID/expensive -- last mile only]\n" as *u8) }
101 var k: i64 = 0
102 while k < nr {
103 if r_tier[k] == tier {
104 dsl_w(1, " - " as *u8); dsl_wr(1, buf, r_off[k], r_end[k]); dsl_w(1, "\n" as *u8)
105 emit[ne] = tier; ne = ne + 1
106 }
107 k = k + 1
108 }
109 tier = tier + 1
110 }
111
112 let total: i64 = t0 + t1 + t2
113 var free_permil: i64 = 0
114 if total > 0 { free_permil = t0 * 1000 / total }
115
116 let ours_mono: i64 = dsl_monotone(emit, ne)
117 // NEG-CONTROL: a deliberately out-of-order sequence MUST be flagged not-monotone (check has teeth)
118 let bad: *i64 = sys_mmap(8 * 3) as *i64
119 bad[0]=2; bad[1]=0; bad[2]=1
120 let bad_mono: i64 = dsl_monotone(bad, 3)
121
122 var ok: i64 = 1
123 if nr <= 0 { ok = 0 }
124 if total != nr { ok = 0 }
125 if t0 <= 0 { ok = 0 } // public-first must be viable
126 if ours_mono != 1 { ok = 0 } // emitted order is cost-monotone (cheapest-first guaranteed)
127 if bad_mono != 0 { ok = 0 } // the monotone check actually catches disorder
128
129 dsl_w(1, "LADDERGATE sources=" as *u8); dsl_wn(1, nr)
130 dsl_w(1, " tier0_public=" as *u8); dsl_wn(1, t0)
131 dsl_w(1, " tier1_private=" as *u8); dsl_wn(1, t1)
132 dsl_w(1, " tier2_paid=" as *u8); dsl_wn(1, t2)
133 dsl_w(1, " free_backbone_permil=" as *u8); dsl_wn(1, free_permil)
134 dsl_w(1, " order_monotone=" as *u8); dsl_wn(1, ours_mono)
135 dsl_w(1, " negctrl_caught=" as *u8); if bad_mono == 0 { dsl_wn(1, 1) } else { dsl_wn(1, 0) }
136 if ok == 1 { dsl_w(1, " verdict=GREEN\n" as *u8) } else { dsl_w(1, " verdict=RED\n" as *u8) }
137
138 let lf: i64 = sys_openat_append(DSL_LOG, 420)
139 if lf >= 0 {
140 dsl_w(lf, "LADDERGATE sources=" as *u8); dsl_wn(lf, nr)
141 dsl_w(lf, " tier0=" as *u8); dsl_wn(lf, t0); dsl_w(lf, " tier1=" as *u8); dsl_wn(lf, t1)
142 dsl_w(lf, " tier2=" as *u8); dsl_wn(lf, t2); dsl_w(lf, " free_backbone_permil=" as *u8); dsl_wn(lf, free_permil)
143 dsl_w(lf, " order_monotone=" as *u8); dsl_wn(lf, ours_mono)
144 if ok == 1 { dsl_w(lf, " verdict=GREEN\n" as *u8) } else { dsl_w(lf, " verdict=RED\n" as *u8) }
145 sys_close(lf)
146 }
147
148 if ok == 1 { return 0 }
149 return 1
150}