`nx_imgsearch.nx` source

↩ module page · 834 lines · 43119 B
1// nx_imgsearch.nx -- THE REVERSE-IMAGE SERVICE ORGAN: the MCP/API face of the multi-tier engine.
2//
3// Every verb emits STRICT JSON on stdout, because the callers are agents and workflows, not humans.
4// That drives three rules the whole file obeys:
5//   * HONEST ABSENT. "not found" is `{"present":false}` with a reason, never an empty list that a
6//     caller can mistake for "not searched" and never the nearest thing dressed up as a match.
7//   * SELF-DESCRIBING. `status` returns the live tier roster, every threshold, and the MEASURED
8//     per-class robustness with its gaps named, so an agent can decide whether this engine can answer
9//     its question before asking. A tool that cannot state its own limits cannot be trusted with one.
10//   * EVERY RESULT CARRIES ITS PROVENANCE -- which tier matched, at what distance, at which
11//     orientation, and whether that tier was CONFIDENT (inside its own threshold) or merely nearest.
12//
13// INDEX FORMAT (versioned, fixed-stride, mmap-first -- the scale decision):
14//   header 32B : magic "NXIMGIDX" | u32 version | u32 stride | i64 count | i64 cidblob_off
15//   record 96B : i64 dhash | u8 visdesc[80] | u32 cid_off | u32 cid_len
16//   then       : the cid string blob
17// Fixed stride means O(1) random access and no parsing, so the index is opened with sys_map_file --
18// the same read-only file-backed map that moved the text shard off the RAM ceiling onto the page
19// cache. The 80-dimension descriptor is QUANTISED TO u8 AT INGEST (its dimensions are already on a
20// 0..256 scale, so this costs at most one unit on a saturated bin): 96 bytes per image on disk
21// against 648 bytes unquantised, which is the difference between a 10M-image index fitting a NAS
22// volume and not. Same integer-quantisation-at-ingest discipline the text engine rides.
23//
24// HONEST CEILING, reported in the JSON rather than hidden: `query` currently EXPANDS the mmap'd
25// records into the engine's i64 descriptor arrays, so serving RAM is ~648 bytes/image even though
26// storage is 96. The named fix is a u8-native similarity tier that computes L1 straight off the
27// mapped bytes, making serving disk-bound like the text side. Until that lands the ceiling is real
28// and this tool prints it.
29// license_tier: ORIGINAL
30import "nx_imgsearch_engine.nx"
31import "nx_itoa_lib.nx"   // shared MSB-first emitter (zero-alloc)
32import "nx_imgcorpus.nx"
33import "nx_image_gray.nx"
34import "nx_dir.nx"
35const IS_MAGIC_1024: i64 = 1024
36const IS_MAGIC_4096: i64 = 4096
37const IS_MAGIC_99999: i64 = 99999
38
39const IS_MAGIC0: i64 = 78    // 'N'
40const IS_VERSION: i64 = 2    // v2 adds the LOCAL keypoint pack per record (occlusion-robust tier)
41// record: [0..8) dhash | [8..88) visdesc u8[80] | [88..92) cid_off u32 | [92..96) cid_len u32
42//         | [96..1256) local keypoint pack = 145 x i64 (FAST+BRIEF, the crop/letterbox tier)
43const IS_STRIDE:  i64 = 1256
44const IS_LOCAL_OFF: i64 = 96   // byte offset of the local pack within a record
45const IS_LOCAL_N:  i64 = 145   // i64 slots in the local pack (kp_pack_dim)
46const IS_HDR:     i64 = 32
47const IS_VDIM:    i64 = 80
48const IS_MAXTOPK: i64 = 32
49const IS_RAM_PER_IMG: i64 = 1816  // i64 descriptor footprint per image once expanded for serving
50// WORKING RESOLUTION CAP. Full-resolution photos (multi-megapixel) make the per-pixel tiers -- the
51// LOCAL FAST keypoint scan especially -- exceed the edge's 15s synchronous budget on the NAS CPU.
52// Every descriptor is computed at a bounded resolution instead: dHash/aHash already downscale to 9x8
53// internally, and running the edge-orientation + keypoint tiers at a canonical scale is standard
54// practice (it also bounds work independent of input size = the real scale lever for ingest). Applied
55// identically at index and query time so descriptors stay comparable. Below the cap = untouched, so
56// the synthetic bench (64x64) is unaffected.
57const IS_WORKDIM: i64 = 512
58
59func s_puts(p: *u8) -> i64 { var n: i64 = 0; while p[n] != (0 as u8) { n = n + 1 } sys_write(1, p, n); return 0 }
60func s_putb(p: *u8, n: i64) -> i64 { if n > 0 { sys_write(1, p, n) } return 0 }
61// MIGRATED to the shared emitter (debt 1785563586). The old body mmapped a scratch buffer
62// per call and never freed it. At page granularity that is 4096B leaked PER CALL -- the
63// defect that took 28.5GB of a 36GB host in nx_ts_lumadiff. A BENCH is the worst home for
64// it: its purpose is millions of iterations. nxi_* is MSB-first and allocates NOTHING.
65func s_num(v: i64) -> i64 { nxi_out(v); return 0 }
66func s_strlen(p: *u8) -> i64 { var n: i64 = 0; while p[n] != (0 as u8) { n = n + 1 } return n }
67func s_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 }
68func s_atoi(p: *u8) -> i64 { var v: i64 = 0; var i: i64 = 0; while p[i] != (0 as u8) { if p[i] >= (48 as u8) { if p[i] <= (57 as u8) { v = v * 10 + ((p[i] - (48 as u8)) as i64) } } i = i + 1 } return v }
69
70// JSON string body: escape backslash, quote, and control bytes. Callers are parsers, so a raw
71// quote inside a crawled URL must never be able to break the document.
72func s_jstr(p: *u8, n: i64) -> i64 {
  var i: i64 = 0
  while i < n {
      let c: i64 = p[i] as i64
      if c == 34 { s_puts("\\\"" as *u8) }
      else { if c == 92 { s_puts("\\\\" as *u8) }
      else { if c < 32 { s_puts(" " as *u8) }
      else { sys_write(1, ((p as i64) + i) as *u8, 1) } } }
      i = i + 1
  }
  return 0
83}
84func s_jkey(k: *u8) -> i64 { s_puts("\"" as *u8); s_puts(k); s_puts("\":" as *u8); return 0 }
85
86// ---- little-endian binary helpers ----
87func s_put_i64(b: *u8, off: i64, v: i64) -> i64 {
  var i: i64 = 0
  while i < 8 { b[off + i] = ((v >> (i * 8)) & 255) as u8; i = i + 1 }
  return 0
91}
92func s_get_i64(b: *u8, off: i64) -> i64 {
  var v: i64 = 0
  var i: i64 = 7
  while i >= 0 { v = (v << 8) | (b[off + i] as i64); i = i - 1 }
  return v
97}
98func s_put_u32(b: *u8, off: i64, v: i64) -> i64 {
  var i: i64 = 0
  while i < 4 { b[off + i] = ((v >> (i * 8)) & 255) as u8; i = i + 1 }
  return 0
102}
103func s_get_u32(b: *u8, off: i64) -> i64 {
  var v: i64 = 0
  var i: i64 = 3
  while i >= 0 { v = (v << 8) | (b[off + i] as i64); i = i - 1 }
  return v
108}
109
110// the engine configuration this service ships. ONE place, so status/query/index cannot drift apart.
111func s_build_engine(cap: i64) -> *nx_imgengine {
  let e: *nx_imgengine = nx_imgengine_new(cap)
  nx_imgengine_add_tier(e, nx_imgtier_new(NX_IT_KIND_COPY,    NX_IT_COPY_THRESH,     1000))
  nx_imgengine_add_tier(e, nx_imgtier_new(NX_IT_KIND_ORIENT,  NX_IT_COPY_THRESH,     1000))
  nx_imgengine_add_tier(e, nx_imgtier_new(NX_IT_KIND_LOCAL,   NX_IT_LOCAL_THRESH,     900))
  nx_imgengine_add_tier(e, nx_imgtier_new(NX_IT_KIND_SIMILAR, NX_IT_SIMILAR_THRESH,   800))
  return e
118}
119
120func s_klass_name(k: i64) -> *u8 {
  if k == NX_IT_CLASS_IDENTITY { return "identity" as *u8 }
  return "similarity" as *u8
123}
124
125func s_emit_tiers(e: *nx_imgengine) -> i64 {
  s_jkey("tiers" as *u8); s_puts("[" as *u8)
  var i: i64 = 0
  while i < nx_imgengine_ntiers(e) {
      let t: *nx_imgtier = nx_imgengine_tier(e, i)
      if i > 0 { s_puts("," as *u8) }
      s_puts("{" as *u8)
      s_jkey("name" as *u8); s_puts("\"" as *u8); s_puts(nx_imgtier_name(t)); s_puts("\"," as *u8)
      s_jkey("class" as *u8); s_puts("\"" as *u8); s_puts(s_klass_name(nx_imgtier_klass(t))); s_puts("\"," as *u8)
      s_jkey("threshold" as *u8); s_num(nx_imgtier_threshold(t)); s_puts("," as *u8)
      s_jkey("index_dim" as *u8); s_num(nx_imgtier_idx_dim(t)); s_puts("," as *u8)
      s_jkey("query_dim" as *u8); s_num(nx_imgtier_qry_dim(t)); s_puts("," as *u8)
      s_jkey("weight" as *u8); s_num(nx_imgtier_weight(t))
      s_puts("}" as *u8)
      i = i + 1
  }
  s_puts("]" as *u8)
  return 0
143}
144
145// ---- verb: status ------------------------------------------------------------------------------
146// Self-description INCLUDING the measured weaknesses. An agent must be able to learn that this
147// engine cannot yet answer a heavy-crop question without having to run the query and be misled.
148func s_verb_status() -> i64 {
  let e: *nx_imgengine = s_build_engine(1)
  s_puts("{" as *u8)
  s_jkey("tool" as *u8); s_puts("\"nx_imgsearch\"," as *u8)
  s_jkey("version" as *u8); s_num(IS_VERSION); s_puts("," as *u8)
  s_jkey("verb" as *u8); s_puts("\"status\"," as *u8)
  s_jkey("ok" as *u8); s_puts("true," as *u8)
  s_jkey("engine" as *u8); s_puts("{" as *u8)
  s_emit_tiers(e); s_puts("," as *u8)
  s_jkey("fusion" as *u8); s_puts("\"reciprocal-rank-fusion, abstention-gated\"," as *u8)
  s_jkey("rrf_k" as *u8); s_num(NX_IE_RRF_K); s_puts("," as *u8)
  s_jkey("ranking_complexity" as *u8); s_puts("\"hash tiers: BK-tree sublinear candidate generation (exact within-threshold, ~6x fewer comparisons on clustered corpora); similarity tier: O(N) heap scan pending ANN graph (seq717)\"" as *u8)
  s_puts("}," as *u8)
  s_jkey("index_format" as *u8); s_puts("{" as *u8)
  s_jkey("magic" as *u8); s_puts("\"NXIMGIDX\"," as *u8)
  s_jkey("stride_bytes" as *u8); s_num(IS_STRIDE); s_puts("," as *u8)
  s_jkey("open_mode" as *u8); s_puts("\"mmap (sys_map_file), page-cache resident\"," as *u8)
  s_jkey("serving_ram_bytes_per_image" as *u8); s_num(IS_RAM_PER_IMG)
  s_puts("}," as *u8)
  // MEASURED robustness -- these are nx_imgbench numbers, not aspirations.
  s_jkey("measured_robustness_permille" as *u8); s_puts("{" as *u8)
  s_jkey("note" as *u8); s_puts("\"recall@1 vs 256 distractors; UPPER BOUND on real-web\"," as *u8)
  s_jkey("identity" as *u8); s_puts("1000," as *u8)
  s_jkey("rescale" as *u8); s_puts("1000," as *u8)
  s_jkey("brightness_contrast" as *u8); s_puts("1000," as *u8)
  s_jkey("noise_recompress" as *u8); s_puts("1000," as *u8)
  s_jkey("watermark" as *u8); s_puts("1000," as *u8)
  s_jkey("mirror_rotate" as *u8); s_puts("1000," as *u8)
  s_jkey("crop_10" as *u8); s_puts("1000," as *u8)
  s_jkey("crop_20" as *u8); s_puts("1000," as *u8)
  s_jkey("crop_30" as *u8); s_puts("968," as *u8)
  s_jkey("letterbox" as *u8); s_puts("1000," as *u8)
  s_jkey("crop_rescale" as *u8); s_puts("906," as *u8)
  s_jkey("overall" as *u8); s_puts("992" as *u8)
  s_puts("}," as *u8)
  s_jkey("classes_survived" as *u8); s_puts("17," as *u8)
  s_jkey("classes_total" as *u8); s_puts("17," as *u8)
  s_jkey("known_gaps" as *u8); s_puts("[" as *u8)
  s_puts("{\"class\":\"crop+rescale\",\"permille\":906,\"needs\":\"CLOSED 2026-08-05 -- scale invariance ships on the QUERY side (index unchanged, no reindex): the query is described across a 5-step half-octave sweep and the tier takes the best, so a same-scale class cannot regress by construction. A SEARCHED scale must clear a higher inlier bar than the image own scale (multiple-comparisons correction) -- without it an out-of-corpus image claimed a false identity match.\"}," as *u8)
  s_puts("{\"class\":\"semantic-lookalike\",\"permille\":-1,\"status\":\"UNMEASURED\",\"note\":\"-1 means NEVER MEASURED, not zero. No semantic class exists in the 17-transform ruler, so the previous literal 0 was a CLAIM, not a result. Order: (1) build a semantic ruler from labelled same-concept pairs, (2) measure the EXISTING descriptors as the honest baseline, (3) only then a quantised learned image-embedding tier (NX_IT_KIND_SEMANTIC slot reserved). WARNING nx_embedding.nx is the LLM token-ID lookup, NOT an image encoder.\"}," as *u8)
  s_puts("{\"class\":\"avif-decode\",\"permille\":0,\"needs\":\"AVIF decoder (C5). WebP CLOSED 2026-08-05: VP8L lossless AND lossy VP8 keyframes both decode via the chokepoint (nx_vp8_kf, gate 8/8 oracle-anchored); julia corpus 120/120 indexed\"}" as *u8)
  s_puts("]" as *u8)
  s_puts("}\n" as *u8)
  return 0
192}
193
194// ---- shared ingest: decode one image FILE and write its 4-tier record ----
195// One record-writer, used by BOTH `index` (manifest-driven) and `walkdir` (directory-driven), so the
196// two ingest paths can never drift in what they store. Holds the tier objects + scratch buffers so a
197// caller allocates them once and reuses across an entire corpus. Returns the NEW cid-blob offset on
198// success, or -1 if the image was undecodable (caller counts it as skipped -- never fatal).
199struct SwIngest {
  tcopy:  i64,
  tsim:   i64,
  tlocal: i64,
  dh:     i64,
  vd:     i64,
  lp:     i64,
  wh:     i64,
207}
208const SWINGEST_BYTES: i64 = 56
209
210// Nearest-neighbour downscale a gray image so its larger side is at most `maxdim`, preserving aspect.
211// Returns the same buffer if already within bounds (no copy); otherwise a fresh bounded buffer.
212// outwh receives the working dimensions. This is the single choke point that bounds ALL tier work.
213func s_downscale_max(gray: *u8, w: i64, h: i64, maxdim: i64, outwh: *i64) -> *u8 {
  if w <= maxdim { if h <= maxdim { outwh[0] = w; outwh[1] = h; return gray } }
  var nw: i64 = w
  var nh: i64 = h
  if w >= h { nw = maxdim; nh = h * maxdim / w } else { nh = maxdim; nw = w * maxdim / h }
  if nw < 1 { nw = 1 }
  if nh < 1 { nh = 1 }
  let out: *u8 = sys_mmap(nw * nh)
  var oy: i64 = 0
  while oy < nh {
      let sy: i64 = (oy * h) / nh
      var ox: i64 = 0
      while ox < nw {
          let sx: i64 = (ox * w) / nw
          out[oy * nw + ox] = gray[sy * w + sx]
          ox = ox + 1
      }
      oy = oy + 1
  }
  outwh[0] = nw
  outwh[1] = nh
  return out
235}
236
237func s_ingest_new() -> *SwIngest {
  let g: *SwIngest = sys_mmap(SWINGEST_BYTES) as *SwIngest
  g.tcopy  = nx_imgtier_new(NX_IT_KIND_COPY,   NX_IT_COPY_THRESH,    1000) as i64
  g.tsim   = nx_imgtier_new(NX_IT_KIND_SIMILAR, NX_IT_SIMILAR_THRESH, 800) as i64
  g.tlocal = nx_imgtier_new(NX_IT_KIND_LOCAL,  NX_IT_LOCAL_THRESH,    900) as i64
  g.dh = sys_mmap(8) as i64
  g.vd = sys_mmap(8 * IS_VDIM) as i64
  g.lp = sys_mmap(8 * IS_LOCAL_N) as i64
  g.wh = sys_mmap(16) as i64
  return g
247}
248
249// write image at `path` into record slot nrec; cid string appended to cidb at cpos. Returns new cpos,
250// or -1 if undecodable. gray/rgb decoding + all four descriptors are computed exactly as at query time.
251func s_ingest_file(g: *SwIngest, recs: *u8, nrec: i64, cidb: *u8, cpos: i64, cid: *u8, path: *u8) -> i64 {
  let wh: *i64 = g.wh as *i64
  let graw: *u8 = nx_img_to_gray(path, wh)
  if graw == (0 as *u8) { return 0 - 1 }
  let gray: *u8 = s_downscale_max(graw, wh[0], wh[1], IS_WORKDIM, wh)
  let ro: i64 = nrec * IS_STRIDE
  let tcopy: *nx_imgtier = g.tcopy as *nx_imgtier
  let tsim: *nx_imgtier = g.tsim as *nx_imgtier
  let tlocal: *nx_imgtier = g.tlocal as *nx_imgtier
  let dh: *i64 = g.dh as *i64
  let vd: *i64 = g.vd as *i64
  let lp: *i64 = g.lp as *i64
  nx_imgtier_describe_index(tcopy, gray, 0 as *u8, wh[0], wh[1], dh)
  s_put_i64(recs, ro, dh[0])
  nx_imgtier_describe_index(tsim, gray, 0 as *u8, wh[0], wh[1], vd)
  var d: i64 = 0
  while d < IS_VDIM {
      var q: i64 = vd[d]
      if q < 0 { q = 0 }
      if q > 255 { q = 255 }
      recs[ro + 8 + d] = q as u8
      d = d + 1
  }
  nx_imgtier_describe_index(tlocal, gray, 0 as *u8, wh[0], wh[1], lp)
  var lq: i64 = 0
  while lq < IS_LOCAL_N { s_put_i64(recs, ro + IS_LOCAL_OFF + lq*8, lp[lq]); lq = lq + 1 }
  let cl: i64 = s_strlen(cid)
  s_put_u32(recs, ro + 88, cpos)
  s_put_u32(recs, ro + 92, cl)
  var c: i64 = 0
  while c < cl { cidb[cpos + c] = cid[c]; c = c + 1 }
  return cpos + cl
283}
284
285// write the NXIMGIDX header + records + cid blob to outpath. Returns total bytes, or -1 on open fail.
286func s_write_index(outpath: *u8, recs: *u8, nrec: i64, cidb: *u8, cpos: i64) -> i64 {
  let hdr: *u8 = sys_mmap(IS_HDR)
  hdr[0] = 78 as u8; hdr[1] = 88 as u8; hdr[2] = 73 as u8; hdr[3] = 77 as u8
  hdr[4] = 71 as u8; hdr[5] = 73 as u8; hdr[6] = 68 as u8; hdr[7] = 88 as u8
  s_put_u32(hdr, 8, IS_VERSION)
  s_put_u32(hdr, 12, IS_STRIDE)
  s_put_i64(hdr, 16, nrec)
  s_put_i64(hdr, 24, IS_HDR + nrec * IS_STRIDE)
  let fd: i64 = sys_openat_wr(outpath, 0x1a4)
  if fd < 0 { return 0 - 1 }
  sys_write(fd, hdr, IS_HDR)
  sys_write(fd, recs, nrec * IS_STRIDE)
  sys_write(fd, cidb, cpos)
  sys_close(fd)
  return IS_HDR + nrec * IS_STRIDE + cpos
301}
302
303// ---- verb: index -------------------------------------------------------------------------------
304// manifest rows: cid<TAB>image_path. Undecodable images are SKIPPED and COUNTED, never fatal -- one
305// bad file must not abort an ingest of millions.
306func s_verb_index(manifest: *u8, outpath: *u8) -> i64 {
  let mbox: *i64 = sys_mmap(16) as *i64
  let mbuf: *u8 = sys_read_file(manifest, mbox)
  if mbuf == (0 as *u8) {
      s_puts("{\"tool\":\"nx_imgsearch\",\"verb\":\"index\",\"ok\":false,\"error\":\"manifest unreadable\"}\n" as *u8)
      sys_exit(1); return 1
  }
  let mn: i64 = mbox[0]
  var nrows: i64 = 0
  var i: i64 = 0
  while i < mn { if mbuf[i] == (10 as u8) { nrows = nrows + 1 } i = i + 1 }
  nrows = nrows + 1
318
  let recs: *u8 = sys_mmap(IS_STRIDE * (nrows + 2))
  let cidb: *u8 = sys_mmap(IS_MAGIC_1024 * (nrows + 2))
  var nrec: i64 = 0
  var cpos: i64 = 0
  var skipped: i64 = 0
  let ing: *SwIngest = s_ingest_new()
325
  var ls: i64 = 0
  i = 0
  while i <= mn {
      var eol: i64 = 0
      if i == mn { eol = 1 } else { if mbuf[i] == (10 as u8) { eol = 1 } }
      if eol == 1 {
          if i > ls {
              var tab: i64 = 0 - 1
              var k: i64 = ls
              while k < i { if mbuf[k] == (9 as u8) { if tab < 0 { tab = k } } k = k + 1 }
              if tab > ls {
                  mbuf[tab] = 0 as u8
                  if i < mn { mbuf[i] = 0 as u8 }
                  let cid: *u8 = ((mbuf as i64) + ls) as *u8
                  let path: *u8 = ((mbuf as i64) + tab + 1) as *u8
                  let ncp: i64 = s_ingest_file(ing, recs, nrec, cidb, cpos, cid, path)
                  if ncp < 0 { skipped = skipped + 1 } else { cpos = ncp; nrec = nrec + 1 }
              }
          }
          ls = i + 1
      }
      i = i + 1
  }
349
  if s_write_index(outpath, recs, nrec, cidb, cpos) < 0 {
      s_puts("{\"tool\":\"nx_imgsearch\",\"verb\":\"index\",\"ok\":false,\"error\":\"cannot open output\"}\n" as *u8)
      sys_exit(1); return 1
  }
354
  s_puts("{" as *u8)
  s_jkey("tool" as *u8); s_puts("\"nx_imgsearch\"," as *u8)
  s_jkey("verb" as *u8); s_puts("\"index\"," as *u8)
  s_jkey("ok" as *u8); s_puts("true," as *u8)
  s_jkey("indexed" as *u8); s_num(nrec); s_puts("," as *u8)
  s_jkey("skipped_undecodable" as *u8); s_num(skipped); s_puts("," as *u8)
  s_jkey("bytes" as *u8); s_num(IS_HDR + nrec * IS_STRIDE + cpos); s_puts("," as *u8)
  s_jkey("bytes_per_image" as *u8); s_num(IS_STRIDE); s_puts("," as *u8)
  s_jkey("path" as *u8); s_puts("\"" as *u8); s_jstr(outpath, s_strlen(outpath)); s_puts("\"" as *u8)
  s_puts("}\n" as *u8)
  return 0
366}
367
368// ---- verb: walkdir (ASYNC) + walkdirsync + walkstatus ------------------------------------------
369// Point the engine at a REAL directory of images and build the index -- the bridge from a synthetic
370// bench to a production corpus. Walks one directory (nx_dir bounded getdents), indexes every .png /
371// .jpg / .jpeg, filename = cid. Undecodable images (incl. WebP/AVIF, a filed gap) are SKIPPED and
372// COUNTED, never fatal. BOUNDED by `max`, reported when capped.
373//
374// WHY ASYNC: a full-resolution PNG decode is expensive, and the sovereign edge drops any synchronous
375// backend response that takes over ~15s -- so a foreground walkdir over more than a couple of real
376// photos times out and the daemon reaps it. `walkdir` therefore SELF-DETACHES: it forks a child that
377// setsid()s into its own session (surviving the parent's return + the closed request pipe, the same
378// primitive nx_daemon/nx_hostctl use for NAS daemons), redirects its fds to a log, indexes in the
379// background with no time limit, and writes the result to `<index>.status` when done. The parent
380// returns STARTED immediately, well inside the edge budget. `walkstatus <index>` polls that marker.
381// `walkdirsync` runs it foreground (for small dirs / local tests). HONEST BOUND: the detached child
382// still inherits the executor's address-space RLIMIT, so a single run is bounded by memory, not time;
383// an unbounded 100k+ corpus is the hostctl-sub rung (filed) -- but async lifts the reachable count
384// from ~1 (foreground, time-bound) to as many as fit RLIMIT.
385const SW_WALK_DEFAULT: i64 = 400
386const SW_WALK_HARDCAP: i64 = 50000
387
388func s_path_join(root: *u8, name: *u8, out: *u8) -> i64 {
  var o: i64 = 0
  var i: i64 = 0
  while root[i] != (0 as u8) { out[o] = root[i]; o = o + 1; i = i + 1 }
  if o > 0 { if out[o-1] != (47 as u8) { out[o] = 47 as u8; o = o + 1 } }
  i = 0
  while name[i] != (0 as u8) { out[o] = name[i]; o = o + 1; i = i + 1 }
  out[o] = 0 as u8
  return o
397}
398
399func s_is_image_name(name: *u8, nl: i64) -> i64 {
  if nx_dir_name_ends_with(name, nl, ".png" as *u8, 4) == 1 { return 1 }
  if nx_dir_name_ends_with(name, nl, ".jpg" as *u8, 4) == 1 { return 1 }
  if nx_dir_name_ends_with(name, nl, ".jpeg" as *u8, 5) == 1 { return 1 }
  if nx_dir_name_ends_with(name, nl, ".PNG" as *u8, 4) == 1 { return 1 }
  if nx_dir_name_ends_with(name, nl, ".JPG" as *u8, 4) == 1 { return 1 }
  // .gif ADMITTED 2026-08-04: nx_gif_decode is now wired into nx_img_to_gray, so a GIF is decodable.
  // .webp ADMITTED DELIBERATELY THOUGH LOSSY VP8 STILL FAILS: excluding it here made the file invisible
  // BEFORE any decode, so walkdir reported skipped_undecodable=0 while silently ignoring 26 real images.
  // Admitting it converts an invisible omission into an honest skipped_undecodable count. A zero from a
  // counter that was never incremented is not evidence of success.
  if nx_dir_name_ends_with(name, nl, ".gif" as *u8, 4) == 1 { return 1 }
  if nx_dir_name_ends_with(name, nl, ".GIF" as *u8, 4) == 1 { return 1 }
  if nx_dir_name_ends_with(name, nl, ".webp" as *u8, 5) == 1 { return 1 }
  // .bmp/.tif ADMITTED 2026-08-05: nx_bmp_decode + nx_tiff_decode wired through the
  // chokepoint, which nx_img_to_gray now projects -- both are decodable end-to-end.
  if nx_dir_name_ends_with(name, nl, ".bmp" as *u8, 4) == 1 { return 1 }
  if nx_dir_name_ends_with(name, nl, ".BMP" as *u8, 4) == 1 { return 1 }
  if nx_dir_name_ends_with(name, nl, ".tif" as *u8, 4) == 1 { return 1 }
  if nx_dir_name_ends_with(name, nl, ".tiff" as *u8, 5) == 1 { return 1 }
  // 1990s roster ADMITTED 2026-08-05 (nx_legacy_codec_gate 12/12): nx_tga_decode,
  // nx_pcx_decode, nx_ico_decode and nx_pnm_decode are wired at the chokepoint, so
  // each is decodable end-to-end.  .ico is the one with live-web demand -- every
  // favicon.ico a crawler meets is this format.
  if nx_dir_name_ends_with(name, nl, ".tga" as *u8, 4) == 1 { return 1 }
  if nx_dir_name_ends_with(name, nl, ".TGA" as *u8, 4) == 1 { return 1 }
  if nx_dir_name_ends_with(name, nl, ".pcx" as *u8, 4) == 1 { return 1 }
  if nx_dir_name_ends_with(name, nl, ".ico" as *u8, 4) == 1 { return 1 }
  if nx_dir_name_ends_with(name, nl, ".ICO" as *u8, 4) == 1 { return 1 }
  if nx_dir_name_ends_with(name, nl, ".cur" as *u8, 4) == 1 { return 1 }
  if nx_dir_name_ends_with(name, nl, ".ppm" as *u8, 4) == 1 { return 1 }
  if nx_dir_name_ends_with(name, nl, ".pgm" as *u8, 4) == 1 { return 1 }
  if nx_dir_name_ends_with(name, nl, ".pbm" as *u8, 4) == 1 { return 1 }
  if nx_dir_name_ends_with(name, nl, ".pnm" as *u8, 4) == 1 { return 1 }
  return 0
434}
435
436// append ".status" (or any suffix) to a path into out; returns out (NUL-terminated).
437func s_suffix_path(path: *u8, suf: *u8, out: *u8) -> *u8 {
  var o: i64 = 0
  while path[o] != (0 as u8) { out[o] = path[o]; o = o + 1 }
  var j: i64 = 0
  while suf[j] != (0 as u8) { out[o] = suf[j]; o = o + 1; j = j + 1 }
  out[o] = 0 as u8
  return out
444}
445
446// fd-aware JSON emit helpers (the async child writes to a status file, not stdout)
447func s_fw(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 }
448// MIGRATED to the shared emitter (debt 1785563586). The old body mmapped a scratch buffer
449// per call and never freed it. At page granularity that is 4096B leaked PER CALL -- the
450// defect that took 28.5GB of a 36GB host in nx_ts_lumadiff. A BENCH is the worst home for
451// it: its purpose is millions of iterations. nxi_* is MSB-first and allocates NOTHING.
452func s_fwn(fd: i64, v: i64) -> i64 { nxi_fd(fd, v); return 0 }
453func s_fwstr(fd: i64, p: *u8) -> i64 {
  var i: i64 = 0
  while p[i] != (0 as u8) {
      let c: i64 = p[i] as i64
      if c == 34 { s_fw(fd, "\\\"" as *u8) } else { if c == 92 { s_fw(fd, "\\\\" as *u8) } else { if c < 32 { s_fw(fd, " " as *u8) } else { sys_write(fd, ((p as i64) + i) as *u8, 1) } } }
      i = i + 1
  }
  return 0
461}
462
463// THE CORE: enumerate + index + write index. Emits the result JSON to `fd`. Returns 0 ok / 1 error.
464func s_walkdir_run(root: *u8, outpath: *u8, maxn: i64, fd: i64) -> i64 {
  let rowcap: i64 = maxn * 4 + 16
  let rows: *NxDirRow = sys_mmap(NX_DIR_ROW_BYTES * rowcap) as *NxDirRow
  let arena: *u8 = sys_mmap(256 * rowcap)
  let res: *NxDirResult = sys_mmap(NX_DIR_RESULT_BYTES) as *NxDirResult
  let dv: i64 = nx_dir_list(root, rows, rowcap, arena, 256 * rowcap, 0, res)
  if dv == NX_DIR_OPEN_FAILED {
      s_fw(fd, "{\"tool\":\"nx_imgsearch\",\"verb\":\"walkdir\",\"ok\":false,\"error\":\"directory unreadable\",\"root\":\"" as *u8)
      s_fwstr(fd, root); s_fw(fd, "\"}\n" as *u8)
      return 1
  }
  let nfilled: i64 = res.n_filled
  var dir_truncated: i64 = 0
  if dv == NX_DIR_TRUNCATED { dir_truncated = 1 }
478
  let recs: *u8 = sys_mmap(IS_STRIDE * (maxn + 2))
  let cidb: *u8 = sys_mmap(IS_MAGIC_1024 * (maxn + 2))
  let pbuf: *u8 = sys_mmap(IS_MAGIC_4096)
  let ing: *SwIngest = s_ingest_new()
  var nrec: i64 = 0
  var cpos: i64 = 0
  var skipped: i64 = 0
  var seen_imgs: i64 = 0
  var capped: i64 = 0
488
  var r: i64 = 0
  while r < nfilled {
      if nrec >= maxn { capped = 1; r = nfilled } else {
          let row: *NxDirRow = nx_dir_row_at(rows, r)
          if nx_dir_row_is_regular_file(row) == 1 {
              if s_is_image_name(row.name_ptr, row.name_len) == 1 {
                  seen_imgs = seen_imgs + 1
                  s_path_join(root, row.name_ptr, pbuf)
                  let ncp: i64 = s_ingest_file(ing, recs, nrec, cidb, cpos, row.name_ptr, pbuf)
                  if ncp < 0 { skipped = skipped + 1 } else { cpos = ncp; nrec = nrec + 1 }
              }
          }
          r = r + 1
      }
  }
504
  if s_write_index(outpath, recs, nrec, cidb, cpos) < 0 {
      s_fw(fd, "{\"tool\":\"nx_imgsearch\",\"verb\":\"walkdir\",\"ok\":false,\"error\":\"cannot open output\"}\n" as *u8)
      return 1
  }
509
  s_fw(fd, "{\"tool\":\"nx_imgsearch\",\"verb\":\"walkdir\",\"ok\":true,\"done\":true," as *u8)
  s_fw(fd, "\"root\":\"" as *u8); s_fwstr(fd, root); s_fw(fd, "\"," as *u8)
  s_fw(fd, "\"dir_entries\":" as *u8); s_fwn(fd, nfilled)
  s_fw(fd, ",\"image_files_seen\":" as *u8); s_fwn(fd, seen_imgs)
  s_fw(fd, ",\"indexed\":" as *u8); s_fwn(fd, nrec)
  s_fw(fd, ",\"skipped_undecodable\":" as *u8); s_fwn(fd, skipped)
  s_fw(fd, ",\"capped_at_max\":" as *u8)
  if capped == 1 { s_fw(fd, "true" as *u8) } else { s_fw(fd, "false" as *u8) }
  s_fw(fd, ",\"dir_listing_truncated\":" as *u8)
  if dir_truncated == 1 { s_fw(fd, "true" as *u8) } else { s_fw(fd, "false" as *u8) }
  s_fw(fd, ",\"max\":" as *u8); s_fwn(fd, maxn)
  s_fw(fd, ",\"bytes\":" as *u8); s_fwn(fd, IS_HDR + nrec * IS_STRIDE + cpos)
  s_fw(fd, ",\"path\":\"" as *u8); s_fwstr(fd, outpath); s_fw(fd, "\"}\n" as *u8)
  return 0
524}
525
526func s_clamp_max(max_in: i64) -> i64 {
  var maxn: i64 = max_in
  if maxn < 1 { maxn = SW_WALK_DEFAULT }
  if maxn > SW_WALK_HARDCAP { maxn = SW_WALK_HARDCAP }
  return maxn
531}
532
533// foreground (small dirs / local tests): run + emit to stdout.
534func s_verb_walkdirsync(root: *u8, outpath: *u8, max_in: i64) -> i64 {
  return s_walkdir_run(root, outpath, s_clamp_max(max_in), 1)
536}
537
538// ASYNC: fork a detached child that indexes in the background and writes <index>.status; return now.
539func s_verb_walkdir(root: *u8, outpath: *u8, max_in: i64) -> i64 {
  let maxn: i64 = s_clamp_max(max_in)
  let statp: *u8 = s_suffix_path(outpath, ".status" as *u8, sys_mmap(IS_MAGIC_4096))
  // a fresh run must not read a previous run's DONE marker -- clear it first (best-effort truncate).
  let cfd: i64 = sys_openat_wr(statp, 0x1a4)
  if cfd >= 0 { sys_close(cfd) }
545
  let pid: i64 = sys_fork()
  if pid == 0 {
      // CHILD: detach into its own session so the daemon's request-pipe close / pgroup signal can't
      // reap it, then redirect fds so its output can never corrupt the parent's JSON response.
      nx_setsid()
      let din: i64 = sys_openat_rd("/dev/null" as *u8)
      let dlog: i64 = sys_openat_wr("/tmp/nx_imgsearch_walk.log" as *u8, 0x1a4)
      if din >= 0 { sys_dup3(din, 0, 0) }
      if dlog >= 0 { sys_dup3(dlog, 1, 0); sys_dup3(dlog, 2, 0) }
      let sfd: i64 = sys_openat_wr(statp, 0x1a4)
      s_walkdir_run(root, outpath, maxn, sfd)
      if sfd >= 0 { sys_close(sfd) }
      sys_exit(0)
      return 0
  }
561
  // PARENT: return immediately (well under the edge's synchronous budget).
  s_puts("{" as *u8)
  s_jkey("tool" as *u8); s_puts("\"nx_imgsearch\"," as *u8)
  s_jkey("verb" as *u8); s_puts("\"walkdir\"," as *u8)
  s_jkey("ok" as *u8); s_puts("true," as *u8)
  s_jkey("action" as *u8); s_puts("\"STARTED\"," as *u8)
  s_jkey("mode" as *u8); s_puts("\"detached\"," as *u8)
  s_jkey("pid" as *u8); s_num(pid); s_puts("," as *u8)
  s_jkey("root" as *u8); s_puts("\"" as *u8); s_jstr(root, s_strlen(root)); s_puts("\"," as *u8)
  s_jkey("max" as *u8); s_num(maxn); s_puts("," as *u8)
  s_jkey("index" as *u8); s_puts("\"" as *u8); s_jstr(outpath, s_strlen(outpath)); s_puts("\"," as *u8)
  s_jkey("status_marker" as *u8); s_puts("\"" as *u8); s_jstr(statp, s_strlen(statp)); s_puts("\"," as *u8)
  s_jkey("poll_with" as *u8); s_puts("\"walkstatus <index>\"" as *u8)
  s_puts("}\n" as *u8)
  return 0
577}
578
579// poll an async walkdir: cat <index>.status if the child finished, else report running/absent.
580func s_verb_walkstatus(idxpath: *u8) -> i64 {
  let statp: *u8 = s_suffix_path(idxpath, ".status" as *u8, sys_mmap(IS_MAGIC_4096))
  let sbox: *i64 = sys_mmap(16) as *i64
  let sbuf: *u8 = sys_read_file(statp, sbox)
  if sbuf != (0 as *u8) { if sbox[0] > 0 {
      // the child wrote its result JSON -- emit it verbatim (already a complete object)
      sys_write(1, sbuf, sbox[0])
      return 0
  } }
  // no completed marker yet: is the index (partial) present at all?
  let ibox: *i64 = sys_mmap(16) as *i64
  let ibuf: *u8 = sys_read_file(idxpath, ibox)
  var have_idx: i64 = 0
  if ibuf != (0 as *u8) { if ibox[0] >= IS_HDR { have_idx = 1 } }
  s_puts("{\"tool\":\"nx_imgsearch\",\"verb\":\"walkstatus\",\"ok\":true,\"done\":false,\"status\":\"running-or-absent\",\"index_present\":" as *u8)
  if have_idx == 1 { s_puts("true" as *u8) } else { s_puts("false" as *u8) }
  s_puts(",\"index\":\"" as *u8); s_jstr(idxpath, s_strlen(idxpath)); s_puts("\"}\n" as *u8)
  return 0
598}
599
600// ---- verb: query -------------------------------------------------------------------------------
601func s_verb_query(idxpath: *u8, imgpath: *u8, topk_in: i64) -> i64 {
  let ibox: *i64 = sys_mmap(16) as *i64
  let ib: *u8 = sys_map_file(idxpath, ibox)
  if ib == (0 as *u8) {
      s_puts("{\"tool\":\"nx_imgsearch\",\"verb\":\"query\",\"ok\":false,\"error\":\"index unreadable\"}\n" as *u8)
      sys_exit(1); return 1
  }
  if ibox[0] < IS_HDR {
      s_puts("{\"tool\":\"nx_imgsearch\",\"verb\":\"query\",\"ok\":false,\"error\":\"index truncated\"}\n" as *u8)
      sys_exit(1); return 1
  }
  if ib[0] != (78 as u8) {
      s_puts("{\"tool\":\"nx_imgsearch\",\"verb\":\"query\",\"ok\":false,\"error\":\"bad index magic\"}\n" as *u8)
      sys_exit(1); return 1
  }
  // stride/version guard: a stale index built at a different record stride would be silently
  // mis-sliced (every field read at the wrong offset). Reject it with a clear message instead.
  let idx_stride: i64 = s_get_u32(ib, 12)
  if idx_stride != IS_STRIDE {
      s_puts("{\"tool\":\"nx_imgsearch\",\"verb\":\"query\",\"ok\":false,\"error\":\"index stride mismatch (stale index -- re-run index with this build)\",\"index_stride\":" as *u8)
      s_num(idx_stride); s_puts(",\"expected_stride\":" as *u8); s_num(IS_STRIDE); s_puts("}\n" as *u8)
      sys_exit(1); return 1
  }
  let count: i64 = s_get_i64(ib, 16)
  let cbo: i64 = s_get_i64(ib, 24)
  if count <= 0 {
      s_puts("{\"tool\":\"nx_imgsearch\",\"verb\":\"query\",\"ok\":true,\"index\":{\"count\":0},\"identity_match\":{\"present\":false,\"reason\":\"empty index\"},\"results\":[]}\n" as *u8)
      return 0
  }
630
  let wh: *i64 = sys_mmap(16) as *i64
  let graw: *u8 = nx_img_to_gray(imgpath, wh)
  if graw == (0 as *u8) {
      s_puts("{\"tool\":\"nx_imgsearch\",\"verb\":\"query\",\"ok\":false,\"error\":\"query image undecodable (PNG/JPEG supported; WebP/AVIF are a known gap)\"}\n" as *u8)
      sys_exit(1); return 1
  }
  // same working-resolution cap as ingest, so query and index descriptors are computed identically
  let gray: *u8 = s_downscale_max(graw, wh[0], wh[1], IS_WORKDIM, wh)
639
  // expand the mapped records into the engine's tier descriptor arrays. Tier order matches
  // s_build_engine exactly: 0=copy, 1=orient, 2=local, 3=similar. (Serving RAM ceiling documented
  // in status; on-disk stays 1256 B/record, filed for a u8-native serve path as seq717.)
  let e: *nx_imgengine = s_build_engine(count)
  var i: i64 = 0
  while i < count {
      let ro: i64 = IS_HDR + i * IS_STRIDE
      let dcopy: *i64 = ie_desc_at(e, 0, i)
      dcopy[0] = s_get_i64(ib, ro)
      let dor: *i64 = ie_desc_at(e, 1, i)
      dor[0] = dcopy[0]
      let dloc: *i64 = ie_desc_at(e, 2, i)
      var lq: i64 = 0
      while lq < IS_LOCAL_N { dloc[lq] = s_get_i64(ib, ro + IS_LOCAL_OFF + lq*8); lq = lq + 1 }
      let dsim: *i64 = ie_desc_at(e, 3, i)
      var d: i64 = 0
      while d < IS_VDIM { dsim[d] = ib[ro + 8 + d] as i64; d = d + 1 }
      let parr: *i64 = e.pays as *i64
      parr[i] = i
      i = i + 1
  }
  e.count = count
662
  var topk: i64 = topk_in
  if topk < 1 { topk = 5 }
  if topk > IS_MAXTOPK { topk = IS_MAXTOPK }
  let op: *i64 = sys_mmap(8 * topk) as *i64
  let os: *i64 = sys_mmap(8 * topk) as *i64
  let ot: *i64 = sys_mmap(8 * topk) as *i64
  let od: *i64 = sys_mmap(8 * topk) as *i64
  let n: i64 = nx_imgengine_query(e, gray, 0 as *u8, wh[0], wh[1], topk, op, os, ot, od)
671
  let bt: *i64 = sys_mmap(8) as *i64
  let bd: *i64 = sys_mmap(8) as *i64
  let br: *i64 = sys_mmap(8) as *i64
  let bm: i64 = nx_imgengine_best_match_r(e, gray, 0 as *u8, wh[0], wh[1], bt, bd, br)
676
  s_puts("{" as *u8)
  s_jkey("tool" as *u8); s_puts("\"nx_imgsearch\"," as *u8)
  s_jkey("version" as *u8); s_num(IS_VERSION); s_puts("," as *u8)
  s_jkey("verb" as *u8); s_puts("\"query\"," as *u8)
  s_jkey("ok" as *u8); s_puts("true," as *u8)
  s_jkey("index" as *u8); s_puts("{" as *u8)
  s_jkey("count" as *u8); s_num(count); s_puts("," as *u8)
  s_jkey("bytes" as *u8); s_num(ibox[0]); s_puts("," as *u8)
  s_jkey("serving_ram_bytes" as *u8); s_num(count * IS_RAM_PER_IMG)
  s_puts("}," as *u8)
  s_jkey("query" as *u8); s_puts("{" as *u8)
  s_jkey("width" as *u8); s_num(wh[0]); s_puts("," as *u8)
  s_jkey("height" as *u8); s_num(wh[1])
  s_puts("}," as *u8)
691
  // the IDENTITY answer, kept separate from the similarity list on purpose
  s_jkey("identity_match" as *u8); s_puts("{" as *u8)
  if bm < 0 {
      s_jkey("present" as *u8); s_puts("false," as *u8)
      s_jkey("reason" as *u8)
      if br[0] == 2 {
          s_puts("\"query image carries too little visual structure for identity matching (flat or smooth-gradient); its fingerprint would collide with every other structureless image\"," as *u8)
          s_jkey("reason_code" as *u8); s_puts("\"uninformative_query\"," as *u8)
      } else {
          s_puts("\"no identity-class tier within its threshold\"," as *u8)
          s_jkey("reason_code" as *u8); s_puts("\"no_match\"," as *u8)
      }
      s_jkey("nearest_distance" as *u8); s_num(bd[0])
  } else {
      let ro: i64 = IS_HDR + bm * IS_STRIDE
      let co: i64 = cbo + s_get_u32(ib, ro + 88)
      let cl: i64 = s_get_u32(ib, ro + 92)
      let mt: *nx_imgtier = nx_imgengine_tier(e, bt[0])
      s_jkey("present" as *u8); s_puts("true," as *u8)
      s_jkey("cid" as *u8); s_puts("\"" as *u8); s_jstr(((ib as i64) + co) as *u8, cl); s_puts("\"," as *u8)
      s_jkey("tier" as *u8); s_puts("\"" as *u8); s_puts(nx_imgtier_name(mt)); s_puts("\"," as *u8)
      s_jkey("distance" as *u8); s_num(bd[0])
  }
  s_puts("}," as *u8)
716
  s_jkey("results" as *u8); s_puts("[" as *u8)
  i = 0
  while i < n {
      if i > 0 { s_puts("," as *u8) }
      let ro: i64 = IS_HDR + op[i] * IS_STRIDE
      let co: i64 = cbo + s_get_u32(ib, ro + 88)
      let cl: i64 = s_get_u32(ib, ro + 92)
      let rt: *nx_imgtier = nx_imgengine_tier(e, ot[i])
      s_puts("{" as *u8)
      s_jkey("rank" as *u8); s_num(i + 1); s_puts("," as *u8)
      s_jkey("cid" as *u8); s_puts("\"" as *u8); s_jstr(((ib as i64) + co) as *u8, cl); s_puts("\"," as *u8)
      s_jkey("score" as *u8); s_num(os[i]); s_puts("," as *u8)
      s_jkey("tier" as *u8); s_puts("\"" as *u8); s_puts(nx_imgtier_name(rt)); s_puts("\"," as *u8)
      s_jkey("tier_class" as *u8); s_puts("\"" as *u8); s_puts(s_klass_name(nx_imgtier_klass(rt))); s_puts("\"," as *u8)
      s_jkey("distance" as *u8); s_num(od[i]); s_puts("," as *u8)
      s_jkey("similarity_permille" as *u8); s_num(nx_imgtier_score(rt, od[i])); s_puts("," as *u8)
      // Confidence comes from the ENGINE's confident-score, not from re-deriving the threshold
      // test here. Recomputing it locally is how the two disagreed: identity_match refused a
      // structureless query while this list still labelled its collisions confident.
      s_jkey("confident" as *u8)
      if os[i] > 0 { s_puts("true" as *u8) } else { s_puts("false" as *u8) }
      s_puts("}" as *u8)
      i = i + 1
  }
  s_puts("]}\n" as *u8)
  return 0
743}
744
745// ---- verb: selftest ----------------------------------------------------------------------------
746// A round trip an agent can run to confirm the service is functional without any corpus on disk:
747// build a synthetic index in memory, mirror one of its images, and require the engine to find it.
748func s_verb_selftest() -> i64 {
  let N: i64 = 64
  let W: i64 = 64
  let e: *nx_imgengine = s_build_engine(N)
  var i: i64 = 0
  while i < N { nx_imgengine_add_image(e, nx_imgcorpus_new(i, W, W), 0 as *u8, W, W, i); i = i + 1 }
  let src: *u8 = nx_imgcorpus_new(7, W, W)
  let mir: *u8 = sys_mmap(W * W)
  var y: i64 = 0
  while y < W {
      var x: i64 = 0
      while x < W { mir[y * W + x] = src[y * W + (W - 1 - x)]; x = x + 1 }
      y = y + 1
  }
  let bt: *i64 = sys_mmap(8) as *i64
  let bd: *i64 = sys_mmap(8) as *i64
  let hit: i64 = nx_imgengine_best_match(e, mir, 0 as *u8, W, W, bt, bd)
  let stranger: i64 = nx_imgengine_best_match(e, nx_imgcorpus_new(IS_MAGIC_99999, W, W), 0 as *u8, W, W, bt, bd)
  var ok: i64 = 0
  if hit == 7 { if stranger < 0 { ok = 1 } }
  s_puts("{" as *u8)
  s_jkey("tool" as *u8); s_puts("\"nx_imgsearch\"," as *u8)
  s_jkey("verb" as *u8); s_puts("\"selftest\"," as *u8)
  s_jkey("ok" as *u8)
  if ok == 1 { s_puts("true," as *u8) } else { s_puts("false," as *u8) }
  s_jkey("mirrored_image_found" as *u8); s_num(hit); s_puts("," as *u8)
  s_jkey("expected" as *u8); s_puts("7," as *u8)
  s_jkey("stranger_correctly_absent" as *u8)
  if stranger < 0 { s_puts("true," as *u8) } else { s_puts("false," as *u8) }
  s_jkey("verdict" as *u8)
  if ok == 1 { s_puts("\"GREEN\"" as *u8) } else { s_puts("\"RED\"" as *u8) }
  s_puts("}\n" as *u8)
  if ok == 1 { return 0 }
  sys_exit(1)
  return 1
783}
784
785func main(argc: i64, argv: *i64) -> i64 {
  if argc < 2 { s_verb_status(); return 0 }
  let verb: *u8 = argv[1] as *u8
  if s_streq(verb, "status" as *u8) == 1 { s_verb_status(); return 0 }
  if s_streq(verb, "selftest" as *u8) == 1 { return s_verb_selftest() }
  if s_streq(verb, "index" as *u8) == 1 {
      if argc < 4 {
          s_puts("{\"tool\":\"nx_imgsearch\",\"verb\":\"index\",\"ok\":false,\"error\":\"usage: index <manifest.tsv> <out.nximgidx>\"}\n" as *u8)
          sys_exit(2); return 2
      }
      return s_verb_index(argv[2] as *u8, argv[3] as *u8)
  }
  if s_streq(verb, "query" as *u8) == 1 {
      if argc < 4 {
          s_puts("{\"tool\":\"nx_imgsearch\",\"verb\":\"query\",\"ok\":false,\"error\":\"usage: query <index.nximgidx> <image> [topk]\"}\n" as *u8)
          sys_exit(2); return 2
      }
      var k: i64 = 5
      if argc >= 5 { k = s_atoi(argv[4] as *u8) }
      return s_verb_query(argv[2] as *u8, argv[3] as *u8, k)
  }
  if s_streq(verb, "walkdir" as *u8) == 1 {
      if argc < 4 {
          s_puts("{\"tool\":\"nx_imgsearch\",\"verb\":\"walkdir\",\"ok\":false,\"error\":\"usage: walkdir <image-dir> <out.nximgidx> [max]  (async -- poll with walkstatus)\"}\n" as *u8)
          sys_exit(2); return 2
      }
      var mx: i64 = 0
      if argc >= 5 { mx = s_atoi(argv[4] as *u8) }
      return s_verb_walkdir(argv[2] as *u8, argv[3] as *u8, mx)
  }
  if s_streq(verb, "walkdirsync" as *u8) == 1 {
      if argc < 4 {
          s_puts("{\"tool\":\"nx_imgsearch\",\"verb\":\"walkdirsync\",\"ok\":false,\"error\":\"usage: walkdirsync <image-dir> <out.nximgidx> [max]\"}\n" as *u8)
          sys_exit(2); return 2
      }
      var mx: i64 = 0
      if argc >= 5 { mx = s_atoi(argv[4] as *u8) }
      return s_verb_walkdirsync(argv[2] as *u8, argv[3] as *u8, mx)
  }
  if s_streq(verb, "walkstatus" as *u8) == 1 {
      if argc < 3 {
          s_puts("{\"tool\":\"nx_imgsearch\",\"verb\":\"walkstatus\",\"ok\":false,\"error\":\"usage: walkstatus <index.nximgidx>\"}\n" as *u8)
          sys_exit(2); return 2
      }
      return s_verb_walkstatus(argv[2] as *u8)
  }
  s_puts("{\"tool\":\"nx_imgsearch\",\"ok\":false,\"error\":\"unknown verb\",\"verbs\":[\"status\",\"selftest\",\"index\",\"query\",\"walkdir\",\"walkdirsync\",\"walkstatus\"]}\n" as *u8)
  sys_exit(2)
  return 2
834}
nx_imgsearch.nx source

`nx_imgsearch.nx` source
