nx_mod_manifest_gate.nx source
↩ module page · 260 lines · 17176 B
1// nx_mod_manifest_gate.nx -- THE MOD PACKAGE MANIFEST GATE (/compare/modding MD18, 2026-09-06). A three-member package (an OBJ, a
2// PNG under a subdirectory, a VMD) is written under /tmp/nx_mod_manifest_gate/pkg/ at runtime; one member carries a provenance
3// row on a SCRATCH journal (cc0-1.0, the MD9 composition), the others have none. The manifest must emit deterministically
4// (two emits byte-identical), parse back to the same fields, verify ACCEPT, and then every tamper the rung names must be
5// REFUSED BY NAME: a member's bytes changed (TAMPERED, the head of the files moves while the declared chain still verifies),
6// a member removed (MISSING), the audit head forged (HEAD), a content row forged (the chain no longer matches). A licence the
7// rights table lacks refuses at emit; a non-redistributable licence still emits with redist=0 because private use is allowed
8// and the publish door is MD23's refusal; unsafe member paths refuse. The command is the second witness through the ladder.
9// usage: nx_mod_manifest_gate (no args)
10// license_tier: ORIGINAL No hw writes (Rule 26). expect_exit: 0
11import "nx_syscalls.nx"
12import "nx_gate_verdict.nx"
13import "nx_gatekit_lib.nx"
14import "nx_mod_manifest_lib.nx"
15
16const MG_DIR: *u8 = "/tmp/nx_mod_manifest_gate"
17const MG_PKG: *u8 = "/tmp/nx_mod_manifest_gate/pkg"
18const MG_TEX: *u8 = "/tmp/nx_mod_manifest_gate/pkg/textures"
19const MG_A_REL: *u8 = "a.obj"
20const MG_B_REL: *u8 = "textures/b.png"
21const MG_C_REL: *u8 = "c.vmd"
22const MG_A: *u8 = "/tmp/nx_mod_manifest_gate/pkg/a.obj"
23const MG_B: *u8 = "/tmp/nx_mod_manifest_gate/pkg/textures/b.png"
24const MG_C: *u8 = "/tmp/nx_mod_manifest_gate/pkg/c.vmd"
25const MG_JRNL: *u8 = "/tmp/nx_mod_manifest_gate/assets.jrnl"
26const MG_OUT1: *u8 = "/tmp/nx_mod_manifest_gate/one.nxmod"
27const MG_OUT2: *u8 = "/tmp/nx_mod_manifest_gate/two.nxmod"
28const MG_OUT3: *u8 = "/tmp/nx_mod_manifest_gate/three.nxmod"
29const MG_OUT4: *u8 = "/tmp/nx_mod_manifest_gate/forgedhead.nxmod"
30const MG_OUT5: *u8 = "/tmp/nx_mod_manifest_gate/forgedrow.nxmod"
31const MG_OUT6: *u8 = "/tmp/nx_mod_manifest_gate/nc.nxmod"
32const MG_ELF_LIVE: *u8 = "./nx_mod_manifest.elf"
33const MG_ELF_STAGE: *u8 = "./nx_mod_manifest.sov.elf.new"
34const MG_ELF_BUILD: *u8 = "buildroot/_build/nx_mod_manifest.sov.elf"
35const MG_DIR_MODE: i64 = 493
36const MG_FILE_MODE: i64 = 420
37const MG_CAP: i64 = 65536
38const MG_A_LEN: i64 = 40
39const MG_B_LEN: i64 = 40
40const MG_C_LEN: i64 = 30
41const MG_VMD_MAGIC_LEN: i64 = 25
42const MG_NAME: *u8 = "house-cape"
43const MG_VER: *u8 = "1.2.0"
44const MG_VER2: *u8 = "1.2.1"
45const MG_GAMES: *u8 = "skyrimse,palworld"
46const MG_DEPS: *u8 = "nx_base@1.0"
47const MG_LIC: *u8 = "cc0-1.0"
48const MG_LIC_NC: *u8 = "cc-by-nc-4.0"
49const MG_LIC_NONE: *u8 = "no-such-licence-9f"
50const MG_SRC_URL: *u8 = "https://example.invalid/house-cape"
51const MG_EPOCH: i64 = 1788710000
52
53func mg_exists(path: *u8) -> i64 { let fd: i64 = sys_openat_rd(path); if fd < 0 { return 0 } sys_close(fd); return 1 }
54func mg_write_file(path: *u8, b: *u8, n: i64) -> i64 {
55 let fd: i64 = sys_openat_wr(path, MG_FILE_MODE)
56 if fd < 0 { return 0 - 1 }
57 var done: i64 = 0
58 while done < n { let k: i64 = sys_write(fd, b + done, n - done); if k <= 0 { break } done = done + k }
59 sys_close(fd)
60 return done
61}
62func mg_same_file(a: *u8, b: *u8) -> i64 {
63 let la: *i64 = sys_mmap(16) as *i64
64 let lb: *i64 = sys_mmap(16) as *i64
65 let ba: *u8 = sys_read_file(a, la)
66 let bb: *u8 = sys_read_file(b, lb)
67 if (ba as i64) == 0 { return 0 }
68 if (bb as i64) == 0 { return 0 }
69 if la[0] != lb[0] { return 0 }
70 var i: i64 = 0
71 while i < la[0] { if ba[i] != bb[i] { return 0 } i = i + 1 }
72 return 1
73}
74func mg_is_hex64(s: *u8) -> i64 {
75 var i: i64 = 0
76 while i < 64 {
77 let c: i64 = s[i] as i64
78 var ok: i64 = 0
79 if c >= 48 { if c <= 57 { ok = 1 } }
80 if c >= 97 { if c <= 102 { ok = 1 } }
81 if ok == 0 { return 0 }
82 i = i + 1
83 }
84 if s[64] != (0 as u8) { return 0 }
85 return 1
86}
87// the three fixture members; c.vmd is rewritten by mg_write_c so the MISSING tooth can restore it
88func mg_write_a() -> i64 { return mg_write_file(MG_A, "v 0 0 0\nv 1 0 0\nv 0 1 0\nf 1 2 3\n# cape\n" as *u8, MG_A_LEN) }
89func mg_write_b(flip: i64) -> i64 {
90 let png: *u8 = sys_mmap(64)
91 png[0] = 137 as u8; png[1] = 80 as u8; png[2] = 78 as u8; png[3] = 71 as u8; png[4] = 13 as u8; png[5] = 10 as u8; png[6] = 26 as u8; png[7] = 10 as u8
92 var k: i64 = 8
93 while k < MG_B_LEN { png[k] = (k * 11 % 251) as u8; k = k + 1 }
94 if flip == 1 { png[20] = (((png[20] & 0xff) as i64) ^ 255) as u8 }
95 return mg_write_file(MG_B, png, MG_B_LEN)
96}
97func mg_write_c() -> i64 {
98 let v: *u8 = sys_mmap(64)
99 let src: *u8 = "Vocaloid Motion Data 0002" as *u8
100 var i: i64 = 0
101 while i < MG_VMD_MAGIC_LEN { v[i] = src[i]; i = i + 1 }
102 return mg_write_file(MG_C, v, MG_C_LEN)
103}
104// emit the reference package to out; returns the manifest byte count; head65/info filled
105func mg_emit(out: *u8, version: *u8, lic: *u8, head65: *u8, info: *i64) -> i64 {
106 let paths: *i64 = sys_mmap(8 * 4) as *i64
107 paths[0] = MG_A_REL as i64; paths[1] = MG_B_REL as i64; paths[2] = MG_C_REL as i64
108 return mm_emit(out, MG_NAME, version, MG_GAMES, MG_DEPS, lic, MG_JRNL, MG_PKG, paths, 3, head65, info)
109}
110func mg_parse_file(path: *u8, m: *i64) -> i64 {
111 let lp: *i64 = sys_mmap(16) as *i64
112 let b: *u8 = sys_read_file(path, lp)
113 if (b as i64) == 0 { return MM_ERR_NOT_MANIFEST }
114 return mm_parse(b, lp[0], m)
115}
116func mg_verify_file(path: *u8, r: *i64, m: *i64) -> i64 {
117 let pr: i64 = mg_parse_file(path, m)
118 if pr < 0 { return 0 - 100 }
119 return mm_verify(m, MG_PKG, r)
120}
121
122func main(argc: i64, argv: *i64) -> i64 {
123 let ctr: *i64 = gv_ctr()
124 sys_mkdir(MG_DIR, MG_DIR_MODE)
125 sys_mkdir(MG_PKG, MG_DIR_MODE)
126 sys_mkdir(MG_TEX, MG_DIR_MODE)
127 sys_unlinkat(MG_JRNL)
128 gv_check_eq("fixture-a-written" as *u8, mg_write_a(), MG_A_LEN, ctr)
129 gv_check_eq("fixture-b-written" as *u8, mg_write_b(0), MG_B_LEN, ctr)
130 gv_check_eq("fixture-c-written" as *u8, mg_write_c(), MG_C_LEN, ctr)
131 // one provenance row on the scratch journal (MD9 composition): a.obj came from a cc0 source
132 let sha_a: *u8 = sys_mmap(PV_SHA_HEX + 1)
133 gv_check_eq("fixture-a-hashed" as *u8, pv_hash_file(MG_A, sha_a), MG_A_LEN, ctr)
134 gv_check("scratch-journal-row-written-for-a" as *u8, (pv_row_write(MG_JRNL, sha_a, MG_SRC_URL, MG_LIC, "nx_mod_manifest_gate" as *u8, MG_EPOCH) > 0) as i64, ctr)
135 // ---- 1. emit ----
136 let head1: *u8 = sys_mmap(MM_SHA_HEX + 1)
137 let info: *i64 = sys_mmap(8 * 8) as *i64
138 let n1: i64 = mg_emit(MG_OUT1, MG_VER, MG_LIC, head1, info)
139 gv_check("emit-returns-the-manifest-byte-count (>0)" as *u8, (n1 > 0) as i64, ctr)
140 gv_kv("manifest_bytes" as *u8, n1)
141 gv_check("emit-head-is-64-hex" as *u8, mg_is_hex64(head1), ctr)
142 gv_check_eq("emit-licence-cc0-reads-redist-YES (2)" as *u8, info[1], LG_YES, ctr)
143 gv_check_eq("emit-licence-cc0-reads-verified" as *u8, info[2], 1, ctr)
144 gv_check_eq("emit-games-2" as *u8, info[3], 2, ctr)
145 gv_check_eq("emit-deps-1" as *u8, info[4], 1, ctr)
146 gv_check_eq("emit-total-bytes-sums-the-members" as *u8, info[0], MG_A_LEN + MG_B_LEN + MG_C_LEN, ctr)
147 // ---- 2. parse back ----
148 let m: *i64 = sys_mmap(8 * MM_M_N_SLOTS) as *i64
149 gv_check_eq("manifest-parses" as *u8, mg_parse_file(MG_OUT1, m), MM_OK, ctr)
150 gv_check_eq("parse-content-rows-3" as *u8, m[MM_M_NCONTENT], 3, ctr)
151 gv_check_eq("parse-game-rows-2" as *u8, m[MM_M_NGAMES], 2, ctr)
152 gv_check_eq("parse-dep-rows-1" as *u8, m[MM_M_NDEPS], 1, ctr)
153 gv_check_eq("parse-prov-rows-3 (one per member)" as *u8, m[MM_M_NPROV], 3, ctr)
154 gv_check_eq("parse-licence-redist-2" as *u8, m[MM_M_LIC_REDIST], LG_YES, ctr)
155 gv_check("parse-head-equals-the-emit-head" as *u8, mm_streq(m[MM_M_HEAD] as *u8, head1), ctr)
156 gv_check("parse-games-rejoin-canonically" as *u8, mm_streq(m[MM_M_GAMES] as *u8, MG_GAMES), ctr)
157 gv_check("parse-deps-rejoin-canonically" as *u8, mm_streq(m[MM_M_DEPS] as *u8, MG_DEPS), ctr)
158 gv_check("parse-name-round-trips" as *u8, mm_streq(m[MM_M_NAME] as *u8, MG_NAME), ctr)
159 // the prov rows: a has the cc0 row (SHIP_OK), b and c have none (NO-ROW) -- read straight from the bytes
160 let lp1: *i64 = sys_mmap(16) as *i64
161 let mb1: *u8 = sys_read_file(MG_OUT1, lp1)
162 gv_check("prov-row-for-a-reads-SHIP_OK-OK" as *u8, gk_out_has(mb1, lp1[0], "|SHIP_OK|OK" as *u8), ctr)
163 gv_check("prov-rows-without-a-journal-row-read-REFUSE-NO-ROW (house members)" as *u8, gk_out_has(mb1, lp1[0], "|REFUSE|NO-ROW" as *u8), ctr)
164 // ---- 3. verify ACCEPT ----
165 let r: *i64 = sys_mmap(8 * MM_R_N) as *i64
166 gv_check_eq("verify-intact-package-ACCEPT" as *u8, mg_verify_file(MG_OUT1, r, m), MM_V_ACCEPT, ctr)
167 gv_check_eq("verify-ok-3" as *u8, r[MM_R_OK], 3, ctr)
168 gv_check("verify-recomputed-head-equals-declared" as *u8, mm_streq(r[MM_R_HEAD_RECOMPUTED] as *u8, r[MM_R_HEAD_DECLARED] as *u8), ctr)
169 gv_check("verify-head-of-files-equals-declared" as *u8, mm_streq(r[MM_R_HEAD_OF_FILES] as *u8, r[MM_R_HEAD_DECLARED] as *u8), ctr)
170 // ---- 4. determinism and header binding ----
171 let head2: *u8 = sys_mmap(MM_SHA_HEX + 1)
172 let n2: i64 = mg_emit(MG_OUT2, MG_VER, MG_LIC, head2, info)
173 gv_check_eq("second-emit-same-byte-count" as *u8, n2, n1, ctr)
174 gv_check("second-emit-byte-identical (no timestamps, deterministic chain)" as *u8, mg_same_file(MG_OUT1, MG_OUT2), ctr)
175 let head3: *u8 = sys_mmap(MM_SHA_HEX + 1)
176 let n3: i64 = mg_emit(MG_OUT3, MG_VER2, MG_LIC, head3, info)
177 gv_check("version-bump-moves-the-head (the header record is in the chain)" as *u8, (mm_streq(head3, head1) == 0) as i64, ctr)
178 gv_check("version-bump-manifest-not-byte-identical" as *u8, (mg_same_file(MG_OUT1, MG_OUT3) == 0) as i64, ctr)
179 // ---- 5. a tampered member ----
180 gv_check_eq("fixture-reached-the-condition: b.png rewritten with one byte flipped" as *u8, mg_write_b(1), MG_B_LEN, ctr)
181 let rt: *i64 = sys_mmap(8 * MM_R_N) as *i64
182 gv_check_eq("neg-control-tampered-member-REFUSE-TAMPERED" as *u8, mg_verify_file(MG_OUT1, rt, m), MM_V_TAMPERED, ctr)
183 gv_check_eq("tampered-count-1" as *u8, rt[MM_R_TAMPERED], 1, ctr)
184 let st: *i64 = rt[MM_R_STATES] as *i64
185 gv_check_eq("tampered-member-is-b (index 1)" as *u8, st[1], MM_S_TAMPERED, ctr)
186 gv_check("tamper-moves-the-head-of-files" as *u8, (mm_streq(rt[MM_R_HEAD_OF_FILES] as *u8, rt[MM_R_HEAD_DECLARED] as *u8) == 0) as i64, ctr)
187 gv_check("tamper-leaves-the-declared-chain-intact (the manifest itself was not edited)" as *u8, mm_streq(rt[MM_R_HEAD_RECOMPUTED] as *u8, rt[MM_R_HEAD_DECLARED] as *u8), ctr)
188 gv_check_eq("restore-b" as *u8, mg_write_b(0), MG_B_LEN, ctr)
189 gv_check_eq("verify-ACCEPT-again-after-restore (the refusal tracked the bytes, not the run)" as *u8, mg_verify_file(MG_OUT1, rt, m), MM_V_ACCEPT, ctr)
190 // ---- 6. a missing member ----
191 sys_unlinkat(MG_C)
192 gv_check_eq("fixture-reached-the-condition: c.vmd removed" as *u8, mg_exists(MG_C), 0, ctr)
193 gv_check_eq("neg-control-missing-member-REFUSE-MISSING" as *u8, mg_verify_file(MG_OUT1, rt, m), MM_V_MISSING, ctr)
194 gv_check_eq("missing-count-1" as *u8, rt[MM_R_MISSING], 1, ctr)
195 gv_check_eq("restore-c" as *u8, mg_write_c(), MG_C_LEN, ctr)
196 gv_check_eq("verify-ACCEPT-again-after-c-restored" as *u8, mg_verify_file(MG_OUT1, rt, m), MM_V_ACCEPT, ctr)
197 // ---- 7. a forged audit head and a forged content row (the manifest edited by hand) ----
198 let fb: *u8 = sys_mmap(lp1[0] + 16)
199 var i: i64 = 0
200 while i < lp1[0] { fb[i] = mb1[i]; i = i + 1 }
201 // the head is the last 64 hex before the final newline: flip its last char between '0' and '1'
202 let hp: i64 = lp1[0] - 2
203 if (fb[hp] as i64) == 48 { fb[hp] = 49 as u8 } else { fb[hp] = 48 as u8 }
204 mg_write_file(MG_OUT4, fb, lp1[0])
205 gv_check_eq("forged-head-manifest-still-parses" as *u8, mg_parse_file(MG_OUT4, m), MM_OK, ctr)
206 gv_check_eq("neg-control-forged-head-REFUSE-HEAD" as *u8, mg_verify_file(MG_OUT4, rt, m), MM_V_HEAD, ctr)
207 gv_check_eq("forged-head-members-all-ok (the files are honest, the manifest is not)" as *u8, rt[MM_R_OK], 3, ctr)
208 gv_check("forged-head-recomputed-differs-from-declared" as *u8, (mm_streq(rt[MM_R_HEAD_RECOMPUTED] as *u8, rt[MM_R_HEAD_DECLARED] as *u8) == 0) as i64, ctr)
209 // forge a content row: change the declared byte count of a.obj (40 -> 41) in a copy
210 i = 0
211 while i < lp1[0] { fb[i] = mb1[i]; i = i + 1 }
212 var pos: i64 = 0 - 1
213 i = 0
214 while i + 14 < lp1[0] { if gk_out_has(fb + i, 14, "content|a.obj|" as *u8) == 1 { if (fb[i] as i64) == 99 { pos = i; break } } i = i + 1 }
215 gv_check("fixture-reached-the-condition: content row for a.obj located" as *u8, (pos >= 0) as i64, ctr)
216 if pos >= 0 { fb[pos + 15] = 49 as u8 } // "content|a.obj|40|" -> "content|a.obj|41|"
217 mg_write_file(MG_OUT5, fb, lp1[0])
218 gv_check_eq("forged-row-manifest-still-parses" as *u8, mg_parse_file(MG_OUT5, m), MM_OK, ctr)
219 let vr: i64 = mg_verify_file(MG_OUT5, rt, m)
220 gv_check("neg-control-forged-content-row-is-REFUSED (never ACCEPT)" as *u8, (vr != MM_V_ACCEPT) as i64, ctr)
221 gv_check("forged-row-breaks-the-declared-chain" as *u8, (mm_streq(rt[MM_R_HEAD_RECOMPUTED] as *u8, rt[MM_R_HEAD_DECLARED] as *u8) == 0) as i64, ctr)
222 // ---- 8. licence and path refusals at emit ----
223 let hx: *u8 = sys_mmap(MM_SHA_HEX + 1)
224 gv_check_eq("neg-control-licence-not-in-rights-table-refuses-at-emit" as *u8, mg_emit(MG_OUT6, MG_VER, MG_LIC_NONE, hx, info), MM_ERR_LICENCE_UNKNOWN, ctr)
225 let n6: i64 = mg_emit(MG_OUT6, MG_VER, MG_LIC_NC, hx, info)
226 gv_check("non-redistributable-licence-still-emits (private use allowed; MD23 publish refuses)" as *u8, (n6 > 0) as i64, ctr)
227 gv_check_eq("non-redistributable-licence-reads-redist-NO (0)" as *u8, info[1], LG_NO, ctr)
228 let bad: *i64 = sys_mmap(8 * 2) as *i64
229 bad[0] = ("../escape.bin" as *u8) as i64
230 gv_check_eq("neg-control-climbing-path-refused" as *u8, mm_emit(MG_OUT6, MG_NAME, MG_VER, MG_GAMES, MG_DEPS, MG_LIC, MG_JRNL, MG_PKG, bad, 1, hx, info), MM_ERR_BAD_PATH, ctr)
231 bad[0] = ("/etc/hostname" as *u8) as i64
232 gv_check_eq("neg-control-absolute-path-refused" as *u8, mm_emit(MG_OUT6, MG_NAME, MG_VER, MG_GAMES, MG_DEPS, MG_LIC, MG_JRNL, MG_PKG, bad, 1, hx, info), MM_ERR_BAD_PATH, ctr)
233 bad[0] = ("a|b.obj" as *u8) as i64
234 gv_check_eq("neg-control-separator-in-path-refused" as *u8, mm_emit(MG_OUT6, MG_NAME, MG_VER, MG_GAMES, MG_DEPS, MG_LIC, MG_JRNL, MG_PKG, bad, 1, hx, info), MM_ERR_BAD_PATH, ctr)
235 gv_check_eq("neg-control-separator-in-name-refused" as *u8, mm_emit(MG_OUT6, "bad|name" as *u8, MG_VER, MG_GAMES, MG_DEPS, MG_LIC, MG_JRNL, MG_PKG, bad, 1, hx, info), MM_ERR_BAD_FIELD, ctr)
236 gv_check_eq("neg-control-zero-members-refused" as *u8, mm_emit(MG_OUT6, MG_NAME, MG_VER, MG_GAMES, MG_DEPS, MG_LIC, MG_JRNL, MG_PKG, bad, 0, hx, info), MM_ERR_NO_FILES, ctr)
237 let lpb: *i64 = sys_mmap(16) as *i64
238 let pngb: *u8 = sys_read_file(MG_B, lpb)
239 gv_check_eq("neg-control-png-bytes-are-not-a-manifest" as *u8, mm_parse(pngb, lpb[0], m), MM_ERR_NOT_MANIFEST, ctr)
240 // ---- 9. the command as a second witness ----
241 var elf: *u8 = 0 as *u8
242 if mg_exists(MG_ELF_LIVE) == 1 { elf = MG_ELF_LIVE }
243 else { if mg_exists(MG_ELF_STAGE) == 1 { elf = MG_ELF_STAGE } else { if mg_exists(MG_ELF_BUILD) == 1 { elf = MG_ELF_BUILD } } }
244 gv_need("cli-witness-present (live, staged or build fossil of nx_mod_manifest)" as *u8, ((elf as i64) != 0) as i64, ctr)
245 if (elf as i64) != 0 {
246 let out: *u8 = sys_mmap(MG_CAP)
247 let bl: *i64 = sys_mmap(16) as *i64
248 let rc1: i64 = gk_run_capture(elf, "verify" as *u8, MG_OUT1, "root=/tmp/nx_mod_manifest_gate/pkg" as *u8, 0 as *u8, out, MG_CAP, bl)
249 gv_check_eq("cli-verify-intact-exits-0" as *u8, rc1, 0, ctr)
250 gv_check("cli-verify-reads-ACCEPT" as *u8, gk_out_has(out, bl[0], "verdict=ACCEPT" as *u8), ctr)
251 gv_check("cli-verify-lists-every-member-OK" as *u8, gk_out_has(out, bl[0], "path=textures/b.png status=OK" as *u8), ctr)
252 let rc2: i64 = gk_run_capture(elf, "verify" as *u8, MG_OUT4, "root=/tmp/nx_mod_manifest_gate/pkg" as *u8, 0 as *u8, out, MG_CAP, bl)
253 gv_check_eq("cli-verify-forged-head-exits-4" as *u8, rc2, 4, ctr)
254 gv_check("cli-verify-forged-head-names-REFUSE-HEAD" as *u8, gk_out_has(out, bl[0], "verdict=REFUSE-HEAD" as *u8), ctr)
255 let rc3: i64 = gk_run_capture(elf, "emit" as *u8, MG_OUT6, "name=x" as *u8, 0 as *u8, out, MG_CAP, bl)
256 gv_check_eq("cli-emit-without-version-is-usage-exit-2" as *u8, rc3, 2, ctr)
257 gv_check("cli-emit-names-the-missing-field" as *u8, gk_out_has(out, bl[0], "version= is required" as *u8), ctr)
258 }
259 return gv_verdict("NX-MOD-MANIFEST" as *u8, ctr, "a three-member package emits a deterministic manifest bound to the ONE rights table and the ONE asset journal, verifies ACCEPT, and refuses by name a tampered member, a missing member, a forged head and a forged row; unsafe paths and unknown licences refuse at emit; the command agrees" as *u8)
260}