code wiki / (root) / nx_bundle_ingest_cli_candidate_t144.nx
`nx_bundle_ingest_cli_candidate_t144.nx` source

↩ module page · 495 lines · 24052 B
1// nx_bundle_ingest.nx -- COMMUNITY BUNDLE TO A TYPED MANIFEST (/compare/modding MD1 bundle_ingest, 2026-09-06). Walks a ZIP or
2// a 7z by content type through nx_bundle_ingest_lib (the zip reader, the inflater and the ONE identify ruler are all
3// incumbents) or nx_sevenz_lib (the 7z container reader over nx_lzma_lib, MD29, same day -- filling the SAME record table, so
4// the texture binder and the partition run unchanged over both containers) and prints one MEMBER row per entry plus one
5// BUNDLE row whose partition sums to the entry count. Unknown members are rows, not omissions; a method or coder the walker
6// cannot open is a row that says so.
7// PROVENANCE (MD9, same day): the archive's own sha256 is the asset identity. With source=<url> the walk appends a row to the
8// provenance journal (licence=<id> names a rights-table row; absent, the licence is recorded as unknown, which is NOT a table
9// row and therefore REFUSES every export and publish door by construction); with or without it the verdict for that sha is
10// printed from nx_asset_prov_lib -- private use always allowed, the walk's own exit code unchanged.
11// usage: nx_bundle_ingest <bundle.zip|bundle.7z> [manifest.out] [source=<url>] [licence=<id>] [jrnl=<path>]
12// exits: 0 walked | 2 usage | 3 REFUSED (unreadable, not a zip or 7z, truncated, a record or the header refused, partition
13//        does not sum)
14// license_tier: ORIGINAL   No hw writes (Rule 26).   expect_exit: 0
15import "nx_syscalls.nx"
16import "nx_bundle_ingest_selected_candidate_t144.nx"
17import "nx_asset_prov_lib.nx"
18import "nx_sevenz_selected_candidate_t144.nx"
19import "nx_fsops_lib.nx"
20import "nx_atomic_rewrite.nx"
21import "json_emit.nx"
22
23const BIC_NAMES_HEADROOM: i64 = 4096
24const BIC_MODE_0644: i64 = 420
25const BIC_EXIT_USAGE: i64 = 2
26const BIC_EXIT_REFUSE: i64 = 3
27const BIC_OUTFD: i64 = 1
28const BIC_SRC_KEY: *u8 = "source="
29const BIC_SRC_KEY_LEN: i64 = 7
30const BIC_LIC_KEY: *u8 = "licence="
31const BIC_LIC_KEY_LEN: i64 = 8
32const BIC_JRNL_KEY: *u8 = "jrnl="
33const BIC_JRNL_KEY_LEN: i64 = 5
34const BIC_LIC_DEFAULT: *u8 = "unknown"        // deliberately NOT a rights-table row: the absence is the refusal
35const BIC_ORIGIN: *u8 = "nx_bundle_ingest"
36const BIC_ST_N: i64 = 8
37const BIC_CONTAINER_ZIP: i64 = 0
38const BIC_CONTAINER_7Z: i64 = 1
39
40func bic_len(s: *u8) -> i64 { var n: i64 = 0; while s[n] != (0 as u8) { n = n + 1 } return n }
41func bic_w(fd: i64, s: *u8) -> i64 { sys_write(fd, s, bic_len(s)); return 0 }
42func bic_wn(fd: i64, v: i64) -> i64 {
  let t: *u8 = sys_mmap(32)
  var m: i64 = v
  var w: i64 = 0
  if m < 0 { t[0] = 45 as u8; sys_write(fd, t, 1); m = 0 - m }
  if m == 0 { t[0] = 48 as u8; sys_write(fd, t, 1); return 0 }
  let d: *u8 = sys_mmap(32)
  var k: i64 = 0
  while m > 0 { d[k] = (48 + (m % 10)) as u8; m = m / 10; k = k + 1 }
  var j: i64 = 0
  while j < k { t[w] = d[k - 1 - j]; w = w + 1; j = j + 1 }
  sys_write(fd, t, w)
  return 0
55}
56func bic_prefix(s: *u8, p: *u8, n: i64) -> i64 { var i: i64 = 0; while i < n { if s[i] != p[i] { return 0 } i = i + 1 } return 1 }
57func bic_is_kv(s: *u8) -> i64 {
  if bic_prefix(s, BIC_SRC_KEY, BIC_SRC_KEY_LEN) == 1 { return 1 }
  if bic_prefix(s, BIC_LIC_KEY, BIC_LIC_KEY_LEN) == 1 { return 1 }
  if bic_prefix(s, BIC_JRNL_KEY, BIC_JRNL_KEY_LEN) == 1 { return 1 }
  return 0
62}
63// trailing key=value args are a SCAN, so the positional contract (archive, manifest) is untouched
64func bic_arg(argc: i64, argv: *i64, key: *u8, klen: i64) -> *u8 {
  var i: i64 = 2
  while i < argc {
      let a: *u8 = argv[i] as *u8
      if bic_prefix(a, key, klen) == 1 { return a + klen }
      i = i + 1
  }
  return 0 as *u8
72}
73func bic_container_name(c: i64) -> *u8 { if c == BIC_CONTAINER_7Z { return "7z" as *u8 } return "zip" as *u8 }
74// the method column: a zip row carries the zip method number, a 7z row the coder code -- named so the reader need not know
75func bic_method(fd: i64, container: i64, code: i64) -> i64 {
  if container == BIC_CONTAINER_7Z { bic_w(fd, sz_coder_name(code)); return 0 }
  bic_wn(fd, code)
  return 0
79}
80
81func bic_row(fd: i64, tbl: *i64, names: *u8, i: i64, container: i64) -> i64 {
  let r: *i64 = bi_rec(tbl, i)
  bic_w(fd, "MEMBER idx=" as *u8); bic_wn(fd, i)
  bic_w(fd, " name=" as *u8); sys_write(fd, names + r[BI_F_NAMEOFF], r[BI_F_NAMELEN])
  bic_w(fd, " method=" as *u8); bic_method(fd, container, r[BI_F_METHOD])
  bic_w(fd, " csize=" as *u8); bic_wn(fd, r[BI_F_CSIZE])
  bic_w(fd, " usize=" as *u8); bic_wn(fd, r[BI_F_USIZE])
  bic_w(fd, " magic=" as *u8); bic_w(fd, ap_name(r[BI_F_MAGIC]))
  bic_w(fd, " category=" as *u8); bic_w(fd, ap_catname(r[BI_F_CAT]))
  bic_w(fd, " claim=" as *u8); bic_w(fd, ap_name(r[BI_F_CLAIM]))
  bic_w(fd, " verdict=" as *u8); bic_w(fd, bi_verdict_name(r[BI_F_VERDICT]))
  bic_w(fd, " inflate=" as *u8); bic_w(fd, bi_inflate_name(r[BI_F_INFLATE]))
  bic_w(fd, " bind=" as *u8); bic_w(fd, bi_bind_name(r[BI_F_BIND]))
  bic_w(fd, " bound_to=" as *u8); bic_wn(fd, r[BI_F_BOUND_TO])
  bic_w(fd, "\n" as *u8)
  return 0
97}
98
99func bic_summary(fd: i64, m: i64, p: *i64, sum: i64, verdict: *u8, container: i64, st: *i64) -> i64 {
  // the incumbent's prefix is a CONTRACT its gate and every reader anchor on: members first, the container after it
  bic_w(fd, "BUNDLE members=" as *u8); bic_wn(fd, m)
  bic_w(fd, " container=" as *u8); bic_w(fd, bic_container_name(container))
  bic_w(fd, " model=" as *u8); bic_wn(fd, p[BI_P_MODEL])
  bic_w(fd, " material=" as *u8); bic_wn(fd, p[BI_P_MATERIAL])
  bic_w(fd, " texture=" as *u8); bic_wn(fd, p[BI_P_TEXTURE])
  bic_w(fd, " motion=" as *u8); bic_wn(fd, p[BI_P_MOTION])
  bic_w(fd, " audio=" as *u8); bic_wn(fd, p[BI_P_AUDIO])
  bic_w(fd, " video=" as *u8); bic_wn(fd, p[BI_P_VIDEO])
  bic_w(fd, " bundle=" as *u8); bic_wn(fd, p[BI_P_BUNDLE])
  bic_w(fd, " unknown=" as *u8); bic_wn(fd, p[BI_P_UNKNOWN])
  bic_w(fd, " sum=" as *u8); bic_wn(fd, sum)
  bic_w(fd, " stored=" as *u8); bic_wn(fd, p[BI_P_STORED])
  bic_w(fd, " inflated=" as *u8); bic_wn(fd, p[BI_P_INFLATED])
  bic_w(fd, " failed=" as *u8); bic_wn(fd, p[BI_P_FAILED])
  bic_w(fd, " unsupported=" as *u8); bic_wn(fd, p[BI_P_UNSUPPORTED])
  bic_w(fd, " textures_bound=" as *u8); bic_wn(fd, p[BI_P_BOUND])
  bic_w(fd, " textures_unbound=" as *u8); bic_wn(fd, p[BI_P_UNBOUND])
  if container == BIC_CONTAINER_7Z {
      bic_w(fd, " dirs=" as *u8); bic_wn(fd, st[0])
      bic_w(fd, " folders=" as *u8); bic_wn(fd, st[2])
      bic_w(fd, " encoded_header=" as *u8); bic_wn(fd, st[3])
  }
  bic_w(fd, " verdict=" as *u8); bic_w(fd, verdict); bic_w(fd, "\n" as *u8)
  return 0
125}
126
127// the provenance leg: identity is the archive's own sha; a row is appended only when the caller names where it came from
128func bic_provenance(argc: i64, argv: *i64, b: *u8, n: i64) -> i64 {
  let sha: *u8 = sys_mmap(PV_SHA_HEX + 1)
  pv_hash_bytes(b, n, sha)
  let src: *u8 = bic_arg(argc, argv, BIC_SRC_KEY, BIC_SRC_KEY_LEN)
  var lic: *u8 = bic_arg(argc, argv, BIC_LIC_KEY, BIC_LIC_KEY_LEN)
  var jrnl: *u8 = bic_arg(argc, argv, BIC_JRNL_KEY, BIC_JRNL_KEY_LEN)
  if (jrnl as i64) == 0 { jrnl = PV_JRNL_DEFAULT }
  if (src as i64) != 0 {
      if (lic as i64) == 0 { lic = BIC_LIC_DEFAULT }
      let w: i64 = pv_row_write(jrnl, sha, src, lic, BIC_ORIGIN, pv_now())
      bic_w(BIC_OUTFD, "PROVENANCE-ROW sha=" as *u8); bic_w(BIC_OUTFD, sha)
      bic_w(BIC_OUTFD, " source=" as *u8); bic_w(BIC_OUTFD, src)
      bic_w(BIC_OUTFD, " lic=" as *u8); bic_w(BIC_OUTFD, lic)
      bic_w(BIC_OUTFD, " row_bytes=" as *u8); bic_wn(BIC_OUTFD, w)
      bic_w(BIC_OUTFD, " jrnl=" as *u8); bic_w(BIC_OUTFD, jrnl); bic_w(BIC_OUTFD, "\n" as *u8)
  } else {
      bic_w(BIC_OUTFD, "PROVENANCE-ROW sha=" as *u8); bic_w(BIC_OUTFD, sha)
      bic_w(BIC_OUTFD, " NOT-WRITTEN (pass source=<url> [licence=<id>] to record where this bundle came from)\n" as *u8)
  }
  let res: *i64 = sys_mmap(8 * PV_RES_N) as *i64
  let rc: i64 = pv_verdict(jrnl, sha, res)
  pv_print(sha, rc, res)
  return rc
151}
152
153
154// Additive ZIP selection API. Ordinary bundle.zip/7z CLI remains below unchanged.
155// Limits are explicit caller arguments; member names never become filesystem paths.
156const BIX_LOCK_SUFFIX: *u8 = ".nx-ingest-lock"
157const BIX_JSON_ROW_ROOM: i64 = 512
158const BIX_JSON_BASE_ROOM: i64 = 2048
159func bix_uint(s: *u8) -> i64 {
  var i: i64 = 0; var v: i64 = 0
  while s[i] != (0 as u8) {
      let d: i64 = s[i] as i64 - 48
      if d < 0 { return 0-1 }; if d > 9 { return 0-1 }
      if v > (NX_ZIP_U32-1-d)/10 { return 0-1 }
      v=v*10+d; i=i+1
  }
  if i == 0 { return 0-1 }; return v
168}
169func bix_lock(path: *u8) -> i64 {
  if fsx_write_denied(path) == 1 { return 0-1 }
  let n: i64 = bic_len(path)
  let sn: i64 = bic_len(BIX_LOCK_SUFFIX)
  if n+sn+FSX_TMP_ROOM >= FSX_PATH_CAP { return 0-1 }
  let p: *u8 = sys_mmap(n+sn+1)
  if (p as i64) <= 0 { return 0-1 }
  var i: i64 = 0
  while i < n { p[i]=path[i]; i=i+1 }
  i=0; while i < sn { p[n+i]=BIX_LOCK_SUFFIX[i]; i=i+1 }; p[n+sn]=0 as u8
  let fd: i64 = sys_openat_lock(p)
  sys_munmap(p,n+sn+1)
  if fd < 0 { return fd }
  if sys_flock(fd,SYS_LOCK_EX | SYS_LOCK_NB) != 0 { sys_close(fd); return 0-1 }
  return fd
184}
185func bix_same(path: *u8, data: *u8, n: i64) -> i64 {
  let fd: i64 = sys_openat_rd(path)
  if fd < 0 { return 0 }
  let size: i64 = sys_lseek(fd,0,2)
  sys_close(fd)
  if size != n { return 0 }
  if n == 0 { return 1 }
  return ar_same_file(path,data,n)
193}
194func bix_store(path: *u8, data: *u8, n: i64) -> i64 {
  let lockfd: i64 = bix_lock(path)
  if lockfd < 0 { return 0-4 }
  var rc: i64 = 0
  let present: i64 = sys_openat_rd(path)
  if present >= 0 {
      sys_close(present)
      if bix_same(path,data,n) != 1 { rc = 0-5 }
  } else {
      if present != (0-2) { sys_flock(lockfd,SYS_LOCK_UN); sys_close(lockfd); return 0-8 }
      let linkbuf: *u8=sys_mmap(1)
      if (linkbuf as i64) <= 0 { sys_flock(lockfd,SYS_LOCK_UN); sys_close(lockfd); return 0-8 }
      let link_rc: i64=sys_readlinkat(path,linkbuf,1)
      sys_munmap(linkbuf,1)
      if link_rc >= 0 { sys_flock(lockfd,SYS_LOCK_UN); sys_close(lockfd); return 0-9 }
      if link_rc != (0-2) { sys_flock(lockfd,SYS_LOCK_UN); sys_close(lockfd); return 0-8 }
      if fsx_write(path,data,n) != n { rc = 0-6 }
      else {
          let fd: i64 = sys_openat_rd(path)
          if fd < 0 { rc=0-7 } else {
              if sys_fsync(fd) != 0 { rc=0-7 }
              if sys_close(fd) != 0 { rc=0-7 }
          }
          if ar_syncdir_checked(path) != 0 { rc=0-7 }
          if bix_same(path,data,n) != 1 { rc=0-7 }
      }
  }
  sys_flock(lockfd,SYS_LOCK_UN); sys_close(lockfd)
  return rc
223}
224func bix_key(w: *JsonWriter, key: *u8, value: *u8) -> i64 {
  if json_emit_key(w,key,bic_len(key)) < 0 { return 0-1 }
  return json_emit_string(w,value,bic_len(value))
227}
228func bix_num(w: *JsonWriter, key: *u8, value: i64) -> i64 {
  if json_emit_key(w,key,bic_len(key)) < 0 { return 0-1 }
  if w.cap-w.pos < NXI_BUF+1 { return 0-1 }
  if je_sep(w) < 0 { return 0-1 }
  w.pos=nxi_buf(w.buf,w.pos,value)
  return 0
234}
235func bix_row(w: *JsonWriter, r: *i64, names: *u8, idx: i64) -> i64 {
  var rc: i64 = json_begin_object(w)
  rc=rc | bix_num(w,"index",idx)
  // Hex retains arbitrary archive-name bytes without pretending a charset or emitting invalid UTF-8.
  let nl: i64 = r[BI_F_NAMELEN]
  let hex: *u8 = sys_mmap(nl*2+1)
  if (hex as i64) <= 0 { return 0-1 }
  let digits: *u8 = "0123456789abcdef"
  var i: i64 = 0
  while i < nl { let b: i64 = names[r[BI_F_NAMEOFF]+i] as i64; hex[i*2]=digits[(b>>4)&15]; hex[i*2+1]=digits[b&15]; i=i+1 }
  hex[nl*2]=0 as u8
  rc=rc | bix_key(w,"name_bytes_hex",hex)
  sys_munmap(hex,nl*2+1)
  rc=rc | bix_num(w,"compressed_bytes",r[BI_F_CSIZE])
  rc=rc | bix_num(w,"declared_bytes",r[BI_F_USIZE])
  rc=rc | bix_num(w,"decoded_bytes",r[BI_F_DLEN])
  rc=rc | bix_num(w,"method",r[BI_F_METHOD])
  rc=rc | bix_num(w,"crc_expected",r[BI_F_CRC])
  rc=rc | bix_num(w,"crc_actual",r[BI_F_CRC_ACTUAL])
  rc=rc | bix_key(w,"integrity",bi_inflate_name(r[BI_F_INFLATE]))
  rc=rc | json_end_object(w)
  return rc
257}
258func bix_receipt(path: *u8, w: *JsonWriter) -> i64 {
  if w.pos >= w.cap { return 0-1 }
  w.buf[w.pos]=10 as u8
  let n: i64=w.pos+1
  if fsx_append(path,w.buf,n) < n { return 0-1 }
  let fd: i64=sys_openat_rd(path)
  if fd < 0 { return 0-1 }
  let rc: i64=sys_fsync(fd)
  let close_rc: i64=sys_close(fd)
  if rc != 0 { return 0-1 }; if close_rc != 0 { return 0-1 }
  if ar_syncdir_checked(path) != 0 { return 0-1 }
  if sys_write(1,w.buf,n) != n { return 0-1 }
  return 0
271}
272func bix_intent(receipt: *u8, archive: *u8, sha: *u8, output: *u8, member_sha: *u8) -> i64 {
  let cap: i64=BIX_JSON_BASE_ROOM+6*(bic_len(archive)+bic_len(output))
  let buf: *u8=sys_mmap(cap)
  let w: *JsonWriter=sys_mmap(40) as *JsonWriter
  let prior: *u8=sys_mmap(JE_MAX_DEPTH+16)
  if (buf as i64) <= 0 { return 0-1 }; if (w as i64) <= 0 { return 0-1 }; if (prior as i64) <= 0 { return 0-1 }
  w.buf=buf; w.pos=0; w.cap=cap; w.depth=0; w.prior=prior
  var rc: i64=json_begin_object(w)
  rc=rc | bix_key(w,"schema","nishi.bundle.selection.v1")
  rc=rc | bix_key(w,"state","validated-output-pending")
  rc=rc | bix_key(w,"archive",archive)
  rc=rc | bix_key(w,"archive_sha256",sha)
  rc=rc | bix_key(w,"output",output)
  rc=rc | bix_key(w,"selected_sha256",member_sha)
  rc=rc | json_end_object(w)
  if rc >= 0 { rc=bix_receipt(receipt,w) }
  sys_munmap(prior,JE_MAX_DEPTH+16); sys_munmap(w as *u8,40); sys_munmap(buf,cap)
  return rc
290}
291// Paths are caller-owned private intake paths. Detect existing inode aliases before any receipt append.
292const BIX_STAT_BYTES: i64 = 256
293const BIX_STAT_DEVICE_WORD: i64 = 0
294const BIX_STAT_INODE_WORD: i64 = 1
295func bix_alias(a: *u8, b: *u8) -> i64 {
  if fsx_seq(a,b) == 1 { return 1 }
  let sa: *i64=sys_mmap(BIX_STAT_BYTES) as *i64
  let sb: *i64=sys_mmap(BIX_STAT_BYTES) as *i64
  if (sa as i64) <= 0 { return 0-1 }
  if (sb as i64) <= 0 { sys_munmap(sa as *u8,BIX_STAT_BYTES); return 0-1 }
  let ra: i64=sys_fstatat(a,sa as *u8)
  let rb: i64=sys_fstatat(b,sb as *u8)
  var same: i64=0
  if ra == 0 { if rb == 0 {
      if sa[BIX_STAT_DEVICE_WORD] == sb[BIX_STAT_DEVICE_WORD] { if sa[BIX_STAT_INODE_WORD] == sb[BIX_STAT_INODE_WORD] { same=1 } }
  } }
  if ra != 0 { if ra != (0-2) { same=0-1 } }
  if rb != 0 { if rb != (0-2) { same=0-1 } }
  sys_munmap(sa as *u8,BIX_STAT_BYTES); sys_munmap(sb as *u8,BIX_STAT_BYTES)
  return same
311}
312func bix_store_state(rc: i64) -> *u8 {
  if rc == (0-4) { return "output-lock-refused" }
  if rc == (0-5) { return "output-conflict" }
  if rc == (0-6) { return "output-write-failed" }
  if rc == (0-7) { return "output-durability-or-readback-uncertain" }
  if rc == (0-8) { return "output-path-unreadable-or-uncertain" }
  if rc == (0-9) { return "output-existing-symlink" }
  return "extracted-verified"
320}
321func bix_main(argc: i64, argv: *i64) -> i64 {
  let extracting: i64=fsx_seq(argv[1] as *u8,"extract")
  if extracting == 1 { if argc != 9 { return 2 } } else { if argc != 5 { return 2 } }
  let archive: *u8=argv[2] as *u8
  var receipt: *u8=argv[3] as *u8
  var max_archive: i64=bix_uint(argv[4] as *u8)
  var max_member: i64=0
  var output: *u8=0 as *u8
  var selected_name: *u8=0 as *u8
  if extracting == 1 {
      selected_name=argv[3] as *u8; output=argv[4] as *u8; receipt=argv[5] as *u8
      max_archive=bix_uint(argv[6] as *u8); max_member=bix_uint(argv[7] as *u8)
      // Explicit expected archive identity binds selection to the caller's inspected input.
      if bic_len(argv[8] as *u8) != PV_SHA_HEX { return 2 }
  }
  if max_archive <= 0 { return 2 }; if max_member < 0 { return 2 }
  if fsx_denied(archive) == 1 { return 5 }
  if fsx_write_denied(receipt) == 1 { return 5 }
  if bix_alias(archive,receipt) != 0 { return 5 }
  if extracting == 1 { if bix_alias(archive,output) != 0 { return 5 }; if bix_alias(receipt,output) != 0 { return 5 } }
  let fd: i64=sys_openat_rd(archive)
  if fd < 0 { return 3 }
  let n: i64=sys_lseek(fd,0,2)
  sys_close(fd)
  if n <= 0 { return 3 }; if n > max_archive { return 3 }
  let lp: *i64=sys_mmap(8) as *i64
  if (lp as i64) <= 0 { return 4 }
  let b: *u8=sys_read_file(archive,lp)
  if (b as i64) <= 0 { return 3 }; if lp[0] != n { return 3 }
  let sha: *u8=sys_mmap(PV_SHA_HEX+1)
  if (sha as i64) <= 0 { return 4 }
  pv_hash_bytes(b,n,sha)
  if extracting == 1 { if fsx_seq(sha,argv[8] as *u8) != 1 { return 3 } }
  let count: i64=bi_count(b,n)
  if count < 0 { return 3 }
  let eo: i64=nxzip_find_eocd(b,n)
  let ncap: i64=nxzip_r32(b,eo+12)+count+1
  let names: *u8=sys_mmap(ncap)
  let tbl: *i64=sys_mmap((count+1)*BI_F_N*8) as *i64
  let opts: *i64=sys_mmap(24) as *i64
  if (names as i64) <= 0 { return 4 }; if (tbl as i64) <= 0 { return 4 }; if (opts as i64) <= 0 { return 4 }
  opts[0]=count; opts[1]=0-2; opts[2]=max_member
  let rows: i64=bi_walk_selected(b,n,tbl,names,ncap,opts)
  if rows != count { return 3 }
  var selected: i64=0-2
  var state: *u8="inventory-complete"
  var exit_code: i64=0
  var selected_sha: *u8=""
  if extracting == 1 {
      var matches: i64=0; var i: i64=0
      while i < count { let r: *i64=bi_rec(tbl,i); if r[BI_F_NAMELEN] == bic_len(selected_name) { if fsx_seq(names+r[BI_F_NAMEOFF],selected_name) == 1 { matches=matches+1; selected=i } }; i=i+1 }
      if matches != 1 { state="selection-not-unique-or-absent"; exit_code=3 }
      else {
          opts[1]=selected
          if bi_walk_selected(b,n,tbl,names,ncap,opts) != count { state="directory-refused"; exit_code=3 }
          else {
              let r: *i64=bi_rec(tbl,selected)
              if r[BI_F_INFLATE] > BI_INF_OK { state=bi_inflate_name(r[BI_F_INFLATE]); exit_code=3 }
              else {
                  selected_sha=sys_mmap(PV_SHA_HEX+1)
                  if (selected_sha as i64) <= 0 { return 4 }
                  pv_hash_bytes(r[BI_F_DATA] as *u8,r[BI_F_DLEN],selected_sha)
                  if bix_intent(receipt,archive,sha,output,selected_sha) != 0 { return 4 }
                  let stored: i64=bix_store(output,r[BI_F_DATA] as *u8,r[BI_F_DLEN])
                  state=bix_store_state(stored)
                  if stored != 0 { exit_code=4 }
              }
          }
      }
  }
  let cap: i64=ncap*2+(count+1)*BIX_JSON_ROW_ROOM+BIX_JSON_BASE_ROOM+(bic_len(archive)+bic_len(receipt))*6
  let buf: *u8=sys_mmap(cap)
  let w: *JsonWriter=sys_mmap(40) as *JsonWriter
  if (buf as i64) <= 0 { return 4 }; if (w as i64) <= 0 { return 4 }
  let prior: *u8=sys_mmap(JE_MAX_DEPTH+16)
  if (prior as i64) <= 0 { return 4 }
  w.buf=buf; w.pos=0; w.cap=cap; w.depth=0; w.prior=prior
  var rc: i64=json_begin_object(w)
  rc=rc | bix_key(w,"schema","nishi.bundle.selection.v1")
  rc=rc | bix_key(w,"state",state)
  rc=rc | bix_key(w,"archive",archive)
  rc=rc | bix_key(w,"archive_sha256",sha)
  rc=rc | bix_num(w,"archive_bytes",n)
  rc=rc | bix_num(w,"members",count)
  rc=rc | bix_num(w,"selected_index",selected)
  rc=rc | bix_key(w,"selected_sha256",selected_sha)
  if extracting == 1 { rc=rc | bix_key(w,"output",output) }
  rc=rc | bix_num(w,"exit_code",exit_code)
  rc=rc | json_emit_key(w,"entries",7)
  rc=rc | json_begin_array(w)
  var i: i64=0
  while i < count { rc=rc | bix_row(w,bi_rec(tbl,i),names,i); i=i+1 }
  rc=rc | json_end_array(w)
  rc=rc | json_end_object(w)
  if rc < 0 { return 4 }
  if bix_receipt(receipt,w) != 0 { return 4 }
  return exit_code
418}
419
420func bix_run(argc: i64, argv: *i64) -> i64 {
  let rc: i64=bix_main(argc,argv)
  if rc != 0 {
      let buf: *u8=sys_mmap(256)
      if (buf as i64) > 0 {
          let w: *JsonWriter=sys_mmap(40) as *JsonWriter
          let prior: *u8=sys_mmap(JE_MAX_DEPTH+16)
          if (w as i64) > 0 { if (prior as i64) > 0 {
              w.buf=buf; w.pos=0; w.cap=256; w.depth=0; w.prior=prior
              json_begin_object(w); bix_key(w,"schema","nishi.bundle.selection.v1"); bix_key(w,"state","refused-or-incomplete"); bix_num(w,"exit_code",rc); json_end_object(w)
              buf[w.pos]=10 as u8; sys_write(1,buf,w.pos+1)
          } }
      }
  }
  return rc
435}
436
437func main(argc: i64, argv: *i64) -> i64 {
  if argc > 1 {
      if fsx_seq(argv[1] as *u8,"inventory") == 1 { return bix_run(argc,argv) }
      if fsx_seq(argv[1] as *u8,"extract") == 1 { return bix_run(argc,argv) }
  }
  if argc < 2 { bic_w(BIC_OUTFD, "usage: nx_bundle_ingest <bundle.zip|bundle.7z> [manifest.out] [source=<url>] [licence=<id>] [jrnl=<path>]\n" as *u8); return BIC_EXIT_USAGE }
  let path: *u8 = argv[1] as *u8
  let lp: *i64 = sys_mmap(16) as *i64
  let b: *u8 = sys_read_file(path, lp)
  if (b as i64) == 0 { bic_w(BIC_OUTFD, "BUNDLE-REFUSE unreadable: " as *u8); bic_w(BIC_OUTFD, path); bic_w(BIC_OUTFD, "\n" as *u8); return BIC_EXIT_REFUSE }
  let n: i64 = lp[0]
  // the container is decided by its MAGIC, never by the filename
  var container: i64 = BIC_CONTAINER_ZIP
  if sz_is_7z(b, n) == 1 { container = BIC_CONTAINER_7Z }
  var total: i64 = 0
  if container == BIC_CONTAINER_7Z { total = sz_count(b, n) } else { total = bi_count(b, n) }
  if total < 0 {
      if container == BIC_CONTAINER_7Z { bic_w(BIC_OUTFD, "BUNDLE-REFUSE 7z " as *u8); bic_w(BIC_OUTFD, sz_err_name(total)) }
      else { bic_w(BIC_OUTFD, "BUNDLE-REFUSE no-EOCD not-a-zip-or-truncated" as *u8) }
      bic_w(BIC_OUTFD, " bytes=" as *u8); bic_wn(BIC_OUTFD, n); bic_w(BIC_OUTFD, "\n" as *u8)
      return BIC_EXIT_REFUSE
  }
  // the table and the name arena are sized from the container, never from a constant (UTF-16 names widen at most 2x)
  let tbl: *i64 = sys_mmap(8 * BI_F_N * (total + 1)) as *i64
  let ncap: i64 = n * 2 + BIC_NAMES_HEADROOM
  let names: *u8 = sys_mmap(ncap)
  let st: *i64 = sys_mmap(8 * BIC_ST_N) as *i64
  var m: i64 = 0
  if container == BIC_CONTAINER_7Z { m = sz_walk(b, n, tbl, total, names, ncap, st) } else { m = bi_walk(b, n, tbl, total, names, ncap) }
  if m < 0 {
      if container == BIC_CONTAINER_7Z { bic_w(BIC_OUTFD, "BUNDLE-REFUSE 7z walk " as *u8); bic_w(BIC_OUTFD, sz_err_name(m)); bic_w(BIC_OUTFD, "\n" as *u8) }
      else { bic_w(BIC_OUTFD, "BUNDLE-REFUSE central-directory walk rc=" as *u8); bic_wn(BIC_OUTFD, m); bic_w(BIC_OUTFD, " (-1 no EOCD, -2 a record refused, -3 count exceeded the declared count)\n" as *u8) }
      return BIC_EXIT_REFUSE
  }
  bi_bind_textures(tbl, m, names)
  let p: *i64 = sys_mmap(8 * BI_P_N) as *i64
  let sum: i64 = bi_partition(tbl, m, p)
  var verdict: *u8 = "WALKED" as *u8
  if sum != m { verdict = "REFUSED-partition-does-not-sum" as *u8 }
  var i: i64 = 0
  while i < m { bic_row(BIC_OUTFD, tbl, names, i, container); i = i + 1 }
  bic_summary(BIC_OUTFD, m, p, sum, verdict, container, st)
  var manifest: *u8 = 0 as *u8
  if argc >= 3 { if bic_is_kv(argv[2] as *u8) == 0 { manifest = argv[2] as *u8 } }
  if (manifest as i64) != 0 {
      let fd: i64 = sys_openat_wr(manifest, BIC_MODE_0644)
      if fd < 0 { bic_w(BIC_OUTFD, "BUNDLE-MANIFEST-UNWRITABLE " as *u8); bic_w(BIC_OUTFD, manifest); bic_w(BIC_OUTFD, "\n" as *u8) }
      else {
          i = 0
          while i < m { bic_row(fd, tbl, names, i, container); i = i + 1 }
          bic_summary(fd, m, p, sum, verdict, container, st)
          sys_close(fd)
          bic_w(BIC_OUTFD, "BUNDLE-MANIFEST wrote=" as *u8); bic_w(BIC_OUTFD, manifest); bic_w(BIC_OUTFD, "\n" as *u8)
      }
  }
  bic_provenance(argc, argv, b, n)
  if sum != m { return BIC_EXIT_REFUSE }
  return 0
495}
nx_bundle_ingest_cli_candidate_t144.nx source

`nx_bundle_ingest_cli_candidate_t144.nx` source
