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

↩ module page · 481 lines · 20030 B
1// nx_entity_media.nx -- MULTI-IMAGE entity media gather.
2//
3// Supersedes the 1-image demo in nx_media_gather.nx, which fetched exactly ONE image and only if its URL
4// contained a hardcoded "upload.wikimedia.org". Here: fetch an entity page over sovereign validated HTTPS,
5// extract ALL image URLs, fetch each (polite pacing), sniff + sha256 + content-address into
6// knowledge/media/<entity>/, dedupe by digest within the run, and append a provenance row per stored asset.
7//
8// No host allowlist: any http(s) image URL is eligible. Bounds are PARAMETERS, not literals -- the intended
9// limits are hardware and politeness, nothing else. A hit cap is REPORTED (capped=1), never silent.
10//
11//   usage: nx_entity_media <page-url> <entity-slug> [max_imgs] [pace_ms]
12
13import "nx_str.nx"
14import "nx_syscalls.nx"
15import "nx_csprng.nx"
16import "nx_x509_trust_store.nx"
17import "nx_pem_loader.nx"
18import "nx_https_get.nx"
19import "nx_html_extract_imgs.nx"
20import "nx_media_sniff.nx"
21import "nx_sha256.nx"
22import "nx_inflate.nx"
23import "nx_http_dechunk.nx"
24const EM_MAGIC_2048: i64 = 2048
25
26const EM_PAGE_CAP: i64 = 4194304
27const EM_IMG_CAP: i64 = 8388608
28// Bounds sized so HARDWARE is the limit, not a literal. 4096 urls costs 32KB+32KB of offset/length
29// arrays, 128KB of dedupe digests and a 2MB url arena -- irrelevant against the 8MB image buffer.
30const EM_URLBUF: i64 = 2097152
31const EM_MAX_IMGS: i64 = 4096
32const EM_PATHBUF: i64 = 4096
33const EM_DEF_PACE_MS: i64 = 800
34
35func em_puts(s: *u8) -> i64 { sys_write(1, s, nx_str_len(s)); return 0 }
36func em_w(fd: i64, s: *u8) -> i64 { sys_write(fd, s, nx_str_len(s)); return 0 }
37
38func em_num(v: i64, o: *u8) -> i64 {
  let t: *u8 = sys_mmap(32)
  var m: i64 = v
  var k: i64 = 0
  if m < 0 { m = 0 - m }
  if m == 0 { t[0] = 48; k = 1 }
  while m > 0 { t[k] = 48 + (m % 10); m = m / 10; k = k + 1 }
  var i: i64 = 0
  while i < k { o[i] = t[k - 1 - i]; i = i + 1 }
  o[k] = 0 as u8
  return k
49}
50
51func em_pi(v: i64) -> i64 { let o: *u8 = sys_mmap(32); let n: i64 = em_num(v, o); sys_write(1, o, n); return 0 }
52func em_wn(fd: i64, v: i64) -> i64 { let o: *u8 = sys_mmap(32); let n: i64 = em_num(v, o); sys_write(fd, o, n); return 0 }
53
54func em_cat(dst: *u8, off: i64, s: *u8) -> i64 { var i: i64 = 0; while s[i] != (0 as u8) { dst[off+i] = s[i]; i = i + 1 } return off + i }
55
56func em_mkdir(path: *u8) -> i64 { return __syscall(258, -100, path, 0x1ed, 0, 0, 0) }
57
58func em_atoi(s: *u8) -> i64 {
  var i: i64 = 0
  var v: i64 = 0
  while s[i] != (0 as u8) {
      let c: i64 = s[i] as i64
      if c >= 48 { if c <= 57 { v = v * 10 + (c - 48) } }
      i = i + 1
  }
  return v
67}
68
69func em_hex(d: *u8, out: *u8) -> i64 {
  let hx: *u8 = "0123456789abcdef" as *u8
  var i: i64 = 0
  while i < 32 {
      let b: i64 = d[i] as i64
      out[i*2]   = hx[(b >> 4) & 15]
      out[i*2+1] = hx[b & 15]
      i = i + 1
  }
  out[64] = 0 as u8
  return 64
80}
81
82func em_body_off(resp: *u8, n: i64) -> i64 {
  var i: i64 = 0
  while i + 3 < n {
      if resp[i] == (13 as u8) { if resp[i+1] == (10 as u8) { if resp[i+2] == (13 as u8) { if resp[i+3] == (10 as u8) { return i + 4 } } } }
      i = i + 1
  }
  return 0
89}
90
91func em_write_file(path: *u8, buf: *u8, n: i64) -> i64 {
  let fd: i64 = sys_openat_wr(path, 0x1a4)
  if fd < 0 { return 0 - 1 }
  var off: i64 = 0
  while off < n {
      let w: i64 = sys_write(fd, ((buf as i64) + off) as *u8, n - off)
      if w <= 0 { sys_close(fd); return 0 - 1 }
      off = off + w
  }
  sys_close(fd)
  return n
102}
103
104// http(s) scheme only -- rejects data: URIs, protocol-relative and relative leftovers
105func em_is_http(u: *u8, n: i64) -> i64 {
  if n < 8 { return 0 }
  if u[0] != (104 as u8) { return 0 }
  if u[1] != (116 as u8) { return 0 }
  if u[2] != (116 as u8) { return 0 }
  if u[3] != (112 as u8) { return 0 }
  return 1
112}
113
114// has this exact content already been stored in THIS run?
115func em_seen(seen: *u8, nseen: i64, dg: *u8) -> i64 {
  var i: i64 = 0
  while i < nseen {
      var same: i64 = 1
      var b: i64 = 0
      while b < 32 { if seen[i*32+b] != dg[b] { same = 0 } b = b + 1 }
      if same == 1 { return 1 }
      i = i + 1
  }
  return 0
125}
126
127func em_ledger(lg: i64, entity: *u8, page: *u8, iurl: *u8, n: i64, hex: *u8, kind: *u8) -> i64 {
  if lg < 0 { return 0 }
  em_w(lg, entity); em_w(lg, "\t" as *u8)
  em_w(lg, page); em_w(lg, "\t" as *u8)
  em_w(lg, iurl); em_w(lg, "\t" as *u8)
  em_wn(lg, n); em_w(lg, "\t" as *u8)
  em_w(lg, hex); em_w(lg, "\t" as *u8)
  em_w(lg, kind); em_w(lg, "\tVERIFIED\n" as *u8)
  return 0
136}
137
138func em_doss(df: i64, entity: *u8, iurl: *u8, hex: *u8, kind: *u8, n: i64) -> i64 {
  if df < 0 { return 0 }
  em_w(df, "media asset entity=" as *u8); em_w(df, entity)
  em_w(df, " image=" as *u8); em_w(df, iurl)
  em_w(df, " sha256=" as *u8); em_w(df, hex)
  em_w(df, " kind=" as *u8); em_w(df, kind)
  em_w(df, " bytes=" as *u8); em_wn(df, n)
  em_w(df, " transport=sovereign-validated-tls13 status=verified\n" as *u8)
  return 0
147}
148
149// FULL-SIZE RESOLUTION. We gather <img src> AS RENDERED, and rendered means the THUMBNAIL the page chose
150// to display. Measured on a real corpus: 19 of 19 assets were under 400px, average longest side 79px --
151// the index was being built on postage stamps. Both major sources expose the original by a deterministic
152// URL transform:
153//   wikimedia  /commons/thumb/5/5d/X.jpg/250px-X.jpg  ->  /commons/5/5d/X.jpg
154//              (drop the "/thumb" segment, then drop the trailing rendered-size component)
155//   javdatabase  /idolimages/thumb/x.webp             ->  /idolimages/full/x.webp
156// Returns 1 and fills `out` when a transform applied, else 0. The caller TRIES THE ORIGINAL FIRST and
157// FALLS BACK to the thumbnail, so a source that does not honour the transform still yields an asset.
158// does url[0..n) end in a raster extension we actually decode?
159func em_ends(u: *u8, n: i64, s: *u8) -> i64 {
  let sl: i64 = nx_str_len(s)
  if sl > n { return 0 }
  var i: i64 = 0
  while i < sl { if u[n - sl + i] != s[i] { return 0 } i = i + 1 }
  return 1
165}
166
167func em_raster_ext(u: *u8, n: i64) -> i64 {
  if em_ends(u, n, ".jpg" as *u8) == 1 { return 1 }
  if em_ends(u, n, ".jpeg" as *u8) == 1 { return 1 }
  if em_ends(u, n, ".png" as *u8) == 1 { return 1 }
  if em_ends(u, n, ".webp" as *u8) == 1 { return 1 }
  if em_ends(u, n, ".gif" as *u8) == 1 { return 1 }
  if em_ends(u, n, ".JPG" as *u8) == 1 { return 1 }
  if em_ends(u, n, ".JPEG" as *u8) == 1 { return 1 }
  if em_ends(u, n, ".PNG" as *u8) == 1 { return 1 }
  return 0
177}
178
179func em_upsize(u: *u8, n: i64, out: *u8) -> i64 {
  // idolimages/thumb/ -> idolimages/full/
  let a: *u8 = "/idolimages/thumb/" as *u8
  let al: i64 = nx_str_len(a)
  var i: i64 = 0
  while i + al <= n {
      var hit: i64 = 1
      var j: i64 = 0
      while j < al { if u[i+j] != a[j] { hit = 0; j = al } else { j = j + 1 } }
      if hit == 1 {
          var o: i64 = 0
          while o < i { out[o] = u[o]; o = o + 1 }
          o = em_cat(out, o, "/idolimages/full/" as *u8)
          var k: i64 = i + al
          while k < n { out[o] = u[k]; o = o + 1; k = k + 1 }
          out[o] = 0 as u8
          return 1
      }
      i = i + 1
  }
199
  // /thumb/ -> drop the segment, then drop the trailing rendered-size component
  let b: *u8 = "/thumb/" as *u8
  let bl: i64 = nx_str_len(b)
  var t: i64 = 0 - 1
  var p: i64 = 0
  while p + bl <= n {
      if t < 0 {
          var hit2: i64 = 1
          var j2: i64 = 0
          while j2 < bl { if u[p+j2] != b[j2] { hit2 = 0; j2 = bl } else { j2 = j2 + 1 } }
          if hit2 == 1 { t = p }
      }
      p = p + 1
  }
  if t < 0 { return 0 }
215
  var o2: i64 = 0
  var c2: i64 = 0
  while c2 < t { out[o2] = u[c2]; o2 = o2 + 1; c2 = c2 + 1 }
  var k2: i64 = t + 6                      // skip "/thumb", keep the following "/"
  while k2 < n { out[o2] = u[k2]; o2 = o2 + 1; k2 = k2 + 1 }
  // truncate at the LAST '/' -- that removes the "250px-Name.jpg" rendered component
  var last: i64 = 0 - 1
  var q: i64 = 0
  while q < o2 { if out[q] == (47 as u8) { last = q } q = q + 1 }
  if last <= 0 { return 0 }
  out[last] = 0 as u8
  // ★A SUCCESSFUL FETCH OF THE WRONG THING DEFEATS A FALLBACK KEYED ON FETCH FAILURE.
  // A Commons thumbnail is often a PNG *rendering* of a non-raster original (.svg, .pdf, .ogv, .tif).
  // Upsizing those returns the SOURCE -- a 200 OK we cannot decode -- so the fetch-failure fallback never
  // fires and we silently lose the one usable form. Only upsize when the ORIGINAL is itself a raster we
  // decode; otherwise keep the rendered thumbnail, which is the decodable artifact.
  if em_raster_ext(out, last) == 0 { return 0 }
  return 1
234}
235
236// Content-Encoding: gzip. The sovereign HTTPS client requests gzip and returns the body still
237// COMPRESSED; handing those bytes to an HTML extractor yields a SILENT zero-images result rather
238// than an error. inf_gunzip has existed in nx_inflate.nx all along -- this is the missing compose.
239// Returns the inflated length written to dst, or 0 when src is not a gzip stream.
240func em_inflate_if_gzip(src: *u8, n: i64, dst: *u8, cap: i64) -> i64 {
  if n < 3 { return 0 }
  if src[0] != (31 as u8) { return 0 }
  if src[1] != (139 as u8) { return 0 }
  let dn: i64 = inf_gunzip(src, n, dst, cap)
  if dn <= 0 { return 0 }
  return dn
247}
248
249func main(argc: i64, argv: *i64) -> i64 {
  var url: *u8 = "https://en.wikipedia.org/wiki/Diora_Baird" as *u8
  var entity: *u8 = "diora_baird" as *u8
  var maxn: i64 = EM_MAX_IMGS
  var pace: i64 = EM_DEF_PACE_MS
  if argc >= 2 { url = argv[1] as *u8 }
  if argc >= 3 { entity = argv[2] as *u8 }
  if argc >= 4 { maxn = em_atoi(argv[3] as *u8) }
  if argc >= 5 { pace = em_atoi(argv[4] as *u8) }
  if maxn <= 0 { maxn = EM_MAX_IMGS }
  if maxn > EM_MAX_IMGS { maxn = EM_MAX_IMGS }
  if pace < 0 { pace = 0 }
261
  em_puts("=== ENTITY MEDIA GATHER (multi-image, sovereign TLS) ===\n entity=" as *u8)
  em_puts(entity); em_puts(" page=" as *u8); em_puts(url)
  em_puts(" max=" as *u8); em_pi(maxn); em_puts(" pace_ms=" as *u8); em_pi(pace); em_puts("\n" as *u8)
265
  let store: *TrustStore = trust_store_alloc(400)
  let nroots: i64 = nx_pem_trust_load_file("/etc/ssl/certs/ca-certificates.crt" as *u8, store)
  if nroots <= 0 { em_puts("ENTITY-MEDIA-FAIL no-roots\n" as *u8); sys_exit(1); return 1 }
269
  let cr: *u8 = sys_mmap(32)
  let pk: *u8 = sys_mmap(32)
  nx_csprng_fill(cr, 32)
  nx_csprng_fill(pk, 32)
  let page: *u8 = sys_mmap(EM_PAGE_CAP)
  let pr: i64 = nx_https_get(url, cr, pk, store, sys_now_realtime_sec(), page, EM_PAGE_CAP)
  em_puts(" page fetch bytes=" as *u8); em_pi(pr); em_puts("\n" as *u8)
  if pr <= 0 { em_puts("ENTITY-MEDIA-FAIL page-fetch\n" as *u8); sys_exit(1); return 1 }
278
  let bo: i64 = em_body_off(page, pr)
  let body: *u8 = ((page as i64) + bo) as *u8
  let blen: i64 = pr - bo
282
  // WIRE ORDER MATTERS: Transfer-Encoding framing is the OUTER layer, Content-Encoding the inner.
  // A chunked+gzip response begins with a hex chunk-size line, so the gzip magic is NOT at body[0]
  // and a naive gzip probe reports 'identity' and hands chunk-framed binary to the extractor.
  // nx_http_dechunk returns negative on non-chunked input, so attempt-then-fall-back is safe.
  var raw: *u8 = body
  var rawlen: i64 = blen
  let dechunk: *u8 = sys_mmap(EM_PAGE_CAP)
  let cn: i64 = nx_http_dechunk(body, blen, dechunk, EM_PAGE_CAP)
  if cn > 0 { raw = dechunk; rawlen = cn }
292
  var html: *u8 = raw
  var hlen: i64 = rawlen
  let infbuf: *u8 = sys_mmap(EM_PAGE_CAP)
  let pdn: i64 = em_inflate_if_gzip(raw, rawlen, infbuf, EM_PAGE_CAP)
  if pdn > 0 { html = infbuf; hlen = pdn }
298
  em_puts(" transfer=" as *u8)
  if cn > 0 { em_puts("chunked dechunked=" as *u8); em_pi(cn) } else { em_puts("identity" as *u8) }
  em_puts(" encoding=" as *u8)
  if pdn > 0 { em_puts("gzip inflated=" as *u8); em_pi(pdn) } else { em_puts("identity" as *u8) }
  em_puts(" html_bytes=" as *u8); em_pi(hlen); em_puts("\n" as *u8)
304
  let url_buf: *u8 = sys_mmap(EM_URLBUF)
  let offs: *i64 = sys_mmap(8 * EM_MAX_IMGS) as *i64
  let lens: *i64 = sys_mmap(8 * EM_MAX_IMGS) as *i64
  let nimgs: i64 = nx_html_extract_imgs(html, hlen, url, nx_str_len(url), url_buf, EM_URLBUF, offs, lens, EM_MAX_IMGS)
  em_puts(" image urls extracted=" as *u8); em_pi(nimgs); em_puts("\n" as *u8)
  if nimgs <= 0 { em_puts("ENTITY-MEDIA-FAIL no-images\n" as *u8); sys_exit(1); return 1 }
311
  em_mkdir("knowledge/media" as *u8)
  em_mkdir("knowledge/library" as *u8)
  let dir: *u8 = sys_mmap(EM_PATHBUF)
  var dof: i64 = em_cat(dir, 0, "knowledge/media/" as *u8)
  dof = em_cat(dir, dof, entity)
  dir[dof] = 0 as u8
  em_mkdir(dir)
319
  let dpath: *u8 = sys_mmap(EM_PATHBUF)
  var dpo: i64 = em_cat(dpath, 0, "knowledge/library/media-" as *u8)
  dpo = em_cat(dpath, dpo, entity)
  dpo = em_cat(dpath, dpo, ".txt" as *u8)
  dpath[dpo] = 0 as u8
325
  let lg: i64 = sys_openat_append("knowledge/media/media_ledger.tsv" as *u8, 0x1a4)
  let df: i64 = sys_openat_append(dpath, 0x1a4)
328
  let img: *u8 = sys_mmap(EM_IMG_CAP)
  let iurl: *u8 = sys_mmap(EM_PATHBUF)
  let fpath: *u8 = sys_mmap(EM_PATHBUF)
  let dg: *u8 = sys_mmap(32)
  let hex: *u8 = sys_mmap(72)
  let seen: *u8 = sys_mmap(32 * EM_MAX_IMGS)
  let imginf: *u8 = sys_mmap(EM_IMG_CAP)
  let imgdech: *u8 = sys_mmap(EM_IMG_CAP)
337
  var nseen: i64 = 0
  var stored: i64 = 0
  var dupes: i64 = 0
  var skipped: i64 = 0
  var failed: i64 = 0
  var nonimg: i64 = 0
  var capped: i64 = 0
  var bytes_total: i64 = 0
  // FORMAT CENSUS: 'non_image' previously conflated 'not an image' with 'an image format we do not
  // sniff'. Gather is now format-AGNOSTIC (store any real image); decode coverage is measured
  // separately by the indexer. That split is what makes the next build target decidable.
  var n_jpeg: i64 = 0
  var n_png: i64 = 0
  var n_webp: i64 = 0
  var n_gif: i64 = 0
  var n_bmp: i64 = 0
  var n_tiff: i64 = 0
  var n_svg: i64 = 0
  var n_upsized: i64 = 0
  var n_tinyskip: i64 = 0
358
  // FLAT loop: one guard flag, max nesting depth 2. A deep else-chain hides its own mis-nesting.
  var idx: i64 = 0
  while idx < nimgs {
      var st: i64 = 0
      let up: *u8 = ((url_buf as i64) + offs[idx]) as *u8
      let ul: i64 = lens[idx]
365
      if stored >= maxn { st = 9; capped = 1 }
      if st == 0 { if em_is_http(up, ul) == 0 { st = 1; skipped = skipped + 1 } }
      if st == 0 { if ul + 1 >= EM_PATHBUF { st = 1; skipped = skipped + 1 } }
369
      if st == 0 {
          var o: i64 = 0
          while o < ul { iurl[o] = up[o]; o = o + 1 }
          iurl[ul] = 0 as u8
          if pace > 0 { sys_sleep_ms(pace) }
          nx_csprng_fill(cr, 32)
          nx_csprng_fill(pk, 32)
      }
378
      // Try the FULL-SIZE original first; fall back to the rendered thumbnail if it does not resolve.
      var ir: i64 = 0
      if st == 0 {
          let full: *u8 = sys_mmap(EM_PATHBUF)
          if em_upsize(iurl, ul, full) == 1 {
              ir = nx_https_get(full, cr, pk, store, sys_now_realtime_sec(), img, EM_IMG_CAP)
              if ir > 0 { n_upsized = n_upsized + 1 }
              if ir <= 0 { if pace > 0 { sys_sleep_ms(pace) } }
          }
          if ir <= 0 {
              nx_csprng_fill(cr, 32)
              nx_csprng_fill(pk, 32)
              ir = nx_https_get(iurl, cr, pk, store, sys_now_realtime_sec(), img, EM_IMG_CAP)
          }
          if ir <= 0 { st = 1; failed = failed + 1 }
      }
395
      var iblen: i64 = 0
      var ibody: *u8 = img
      if st == 0 {
          let ibo: i64 = em_body_off(img, ir)
          ibody = ((img as i64) + ibo) as *u8
          iblen = ir - ibo
          if iblen <= 0 { st = 1; failed = failed + 1 }
          let icn: i64 = nx_http_dechunk(ibody, iblen, imgdech, EM_IMG_CAP)
          if icn > 0 { ibody = imgdech; iblen = icn }
          let idn: i64 = em_inflate_if_gzip(ibody, iblen, imginf, EM_IMG_CAP)
          if idn > 0 { ibody = imginf; iblen = idn }
      }
408
      var kind: *u8 = "unknown" as *u8
      var ext: *u8 = ".bin" as *u8
      if st == 0 {
          var isimg: i64 = 0
          if nx_sniff_is_jpeg(ibody, iblen) == 1 { kind = "jpeg" as *u8; ext = ".jpg" as *u8; isimg = 1; n_jpeg = n_jpeg + 1 }
          if nx_sniff_is_png(ibody, iblen) == 1 { kind = "png" as *u8; ext = ".png" as *u8; isimg = 1; n_png = n_png + 1 }
          if nx_sniff_is_webp(ibody, iblen) == 1 { kind = "webp" as *u8; ext = ".webp" as *u8; isimg = 1; n_webp = n_webp + 1 }
          if nx_sniff_is_gif(ibody, iblen) == 1 { kind = "gif" as *u8; ext = ".gif" as *u8; isimg = 1; n_gif = n_gif + 1 }
          if nx_sniff_is_bmp(ibody, iblen) == 1 { kind = "bmp" as *u8; ext = ".bmp" as *u8; isimg = 1; n_bmp = n_bmp + 1 }
          if nx_sniff_is_tiff(ibody, iblen) == 1 { kind = "tiff" as *u8; ext = ".tif" as *u8; isimg = 1; n_tiff = n_tiff + 1 }
          if isimg == 0 { st = 1; nonimg = nonimg + 1 }
          if isimg == 0 { if nx_sniff_is_svg_token(ibody, iblen) == 1 { n_svg = n_svg + 1 } }
      }
422
      // CHROME FLOOR: page furniture (flag icons, edit pencils, spacers) is tiny. A real photograph is
      // not 900 bytes. Rejecting by size here is crude but it is measured against the actual corpus, and
      // it is REPORTED so the number never hides.
      if st == 0 { if iblen < EM_MAGIC_2048 { st = 1; n_tinyskip = n_tinyskip + 1 } }
427
      if st == 0 {
          sha256_digest(ibody, iblen, dg)
          if em_seen(seen, nseen, dg) == 1 { st = 1; dupes = dupes + 1 }
      }
432
      if st == 0 {
          var b: i64 = 0
          while b < 32 { seen[nseen*32 + b] = dg[b]; b = b + 1 }
          nseen = nseen + 1
          em_hex(dg, hex)
          var fo: i64 = em_cat(fpath, 0, dir)
          fo = em_cat(fpath, fo, "/" as *u8)
          fo = em_cat(fpath, fo, hex)
          fo = em_cat(fpath, fo, ext)
          fpath[fo] = 0 as u8
          let wr: i64 = em_write_file(fpath, ibody, iblen)
          if wr != iblen { st = 1; failed = failed + 1 }
          if st == 0 { stored = stored + 1; bytes_total = bytes_total + iblen }
          if st == 0 { em_ledger(lg, entity, url, iurl, iblen, hex, kind) }
          if st == 0 { em_doss(df, entity, iurl, hex, kind, iblen) }
      }
449
      idx = idx + 1
  }
452
  if lg >= 0 { sys_close(lg) }
  if df >= 0 { sys_close(df) }
455
  em_puts("{\"tool\":\"nx_entity_media\",\"entity\":\"" as *u8); em_puts(entity)
  em_puts("\",\"page\":\"" as *u8); em_puts(url)
  em_puts("\",\"urls_extracted\":" as *u8); em_pi(nimgs)
  em_puts(",\"stored\":" as *u8); em_pi(stored)
  em_puts(",\"dupes\":" as *u8); em_pi(dupes)
  em_puts(",\"non_image\":" as *u8); em_pi(nonimg)
  em_puts(",\"skipped_non_http\":" as *u8); em_pi(skipped)
  em_puts(",\"failed\":" as *u8); em_pi(failed)
  em_puts(",\"bytes\":" as *u8); em_pi(bytes_total)
  em_puts(",\"fmt\":{\"jpeg\":" as *u8); em_pi(n_jpeg)
  em_puts(",\"png\":" as *u8); em_pi(n_png)
  em_puts(",\"webp\":" as *u8); em_pi(n_webp)
  em_puts(",\"gif\":" as *u8); em_pi(n_gif)
  em_puts(",\"bmp\":" as *u8); em_pi(n_bmp)
  em_puts(",\"tiff\":" as *u8); em_pi(n_tiff)
  em_puts(",\"svg_rejected\":" as *u8); em_pi(n_svg)
  em_puts(",\"upsized_to_original\":" as *u8); em_pi(n_upsized)
  em_puts(",\"chrome_under_2kb_skipped\":" as *u8); em_pi(n_tinyskip)
  em_puts("}" as *u8)
  em_puts(",\"capped_at_max\":" as *u8); em_pi(capped)
  em_puts(",\"dir\":\"" as *u8); em_puts(dir)
  em_puts("\"}\n" as *u8)
  em_puts("ENTITY-MEDIA-OK\n" as *u8)
  sys_exit(0)
  return 0
481}
nx_entity_media.nx source

`nx_entity_media.nx` source
