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

↩ module page · 1382 lines · 69093 B
1// nx_nofloat_serve_core.nx -- the PURE CORE of the no-float LLM serve organ (2026-07-10): model session +
2// greedy generation + HTTP request handler, NO sockets (the daemon shell owns those; the gate exercises this
3// core in-process with synthetic requests -- the proven pure-core+gate+daemon idiom).
4//   nsv_init(path)      one-time: load GGUF, tokenizer meta, dequant-once i32 (lossless hero) + i8 (fast) caches.
5//   nsv_generate(gp)    ctx-bundle: sequential CACHED prefill (decode_step per prompt token -- mathematically
6//                       identical to batch prefill under causal masking) then greedy decode; text out through
7//                       the byte-level-BPE inverse (nx_nofloat_tokdec) so ' Paris' renders as real text.
8//   nsv_handle(...)     routes: GET / (app page)  GET /health  GET /api  POST /gen {prompt,max_new,mode}.
9// license_tier: ORIGINAL   No hw writes (Rule 26).
10import "nx_syscalls.nx"
11import "nx_tier.nx"
12import "nx_le.nx"
13import "nx_tensor.nx"
14import "nx_gguf.nx"
15import "nx_gguf_load.nx"
16import "nx_gguf_meta.nx"
17import "nx_nofloat_llm.nx"
18import "nx_nofloat_tok.nx"
19import "nx_nofloat_tokdec.nx"
20import "nx_nofloat_arch.nx"
21import "nx_nofloat_q4k.nx"     // LM4 resident-Q4_K decode (2026-09-02): the 7B fits because the weights stay in the file map
22
23const NSV_MAXT: i64 = 2048     // final prompt+gen TOKEN cap (KV cache rows). L2 raise 384->2048 (FORGE 2026-07-12)
                             // so a mini-pack (~1300 tok) + task + whole-organ generation fits. Decode buffers +
                             // KV cache scale with this: ~+200MB at 2048 for the 0.5B coder (24L, kvd=128, ne=896)
                             // -- well within WSL 16GB alongside the ~700MB model + i32/i8 caches. Gated L2.
27const NSV_MAXIN: i64 = 16384   // max prompt BYTES for the tokenizer's byte-level pretokenize scratch (tok_ptr/tok_len).
                             // L2 raise 8192->16384 for the full mini-pack (3911B) + task headroom.
                             // ⚠ tk_bpe_encode seeds 1 slot per INPUT BYTE -> those buffers MUST be sized by bytes,
                             // NOT NSV_MAXT (the old NSV_MAXT*8 page-rounded to 512 entries -> SIGSEGV on >512-byte prompts).
31const NSV_MAXNEW: i64 = 512    // per-request generation cap (L2 raise 96->512 for whole small organs)
32const NSV_CHATML_IDS: i64 = 8  // ids the ChatML wrapper adds around the content (two markers plus the user, newline and assistant pieces)
33const NSV_ERR_TOO_LONG: i64 = 3 // meta[5] for a prompt past the byte cap or the token cap: refused at the door, never half-encoded
34const NSV_PREFILL_BATCHED_DEFAULT: i64 = 1   // R0r: the i8 route prefills in blocks through nf_prefill_batched (nx_nofloat_prefill_gate proves it bit-identical); declared here because its first reader is the scratch allocator
35const NSV_EOS1: i64 = 151643
36const NSV_EOS2: i64 = 151645
37
38static g_nsv_buf: *u8
39static g_nsv_hdr: *NxGgufHeader
40static g_nsv_wc32: *i64
41static g_nsv_wc8: *i64
42static g_nsv_wq4: *i64         // LM4: per-layer resident-Q4_K slot tables (nx_nofloat_q4k), built instead of wc8 when g_nsv_q4k
43static g_nsv_q4k: i64          // 1 = resident-Q4_K serve: model file-mapped, no i32/i16 layer caches, decode mode 3
44static g_nsv_q4st: *i64        // NQ_ST_WORDS census of the q4k build (in-place vs fallback tensors and bytes)
45static g_nsv_hcp: *i64
46static g_nsv_sb: *i64
47static g_nsv_kvc: *i64
48static g_nsv_freqs: *i64
49static g_nsv_cfgA: *i64
50static g_nsv_cfgF: *i64
51static g_nsv_tmp: *i64
52static g_nsv_x1: *i64
53static g_nsv_h1: *i64
54static g_nsv_xt: *i64              // R0r: the prompt's dequantised embedding rows (NSV_MAXT x ne)
55static g_nsv_prefill_batched: i64   // R0r: 1 = blocks through nf_prefill_batched on the i8 route, 0 = the sequential control
56static g_nsv_normed: *i64
57static g_nsv_gout: *i64
58static g_nsv_idout: *i64
59static g_nsv_lgout: *i64
60static g_nsv_nmbuf: *u8
61static g_nsv_ids: *i64
62static g_nsv_tokp: *i64
63static g_nsv_tokl: *i64
64static g_nsv_lgv: *i64     // full vocab logits (sampling path)
65static g_nsv_mt: *i64          // [0]=mfirst [1]=nm_c [2]=vfirst [3]=vocab [4]=te_base [5]=te_ty [6]=ready [7]=init_ms
66static g_nsv_mpath: *u8        // the ACTUAL loaded model path (health must not lie about which model serves)
67static g_nsv_dims: *i64        // arch-config (nac_read_config 2026-07-15): [0]=D [1]=n_layers [2]=n_heads [3]=n_kv [4]=head_dim [5]=q_dim [6]=kv_dim [7]=ffn [8]=scale_q16 [9]=rope_base [10]=ok
68static g_nsv_kvsnap: *i64      // PREFIX-KV-CACHE (2026-07-15): snapshot of KV rows 0..P-1 (the fixed prompt prefix) for reuse across requests
69static g_nsv_snap_p: i64       // number of prefix tokens currently snapshotted (0 = none)
70static g_nsv_crib_ids: *i64    // the snapshotted prefix's token ids (for common-prefix safety vs BPE re-tokenization)
71
72func nsv_slen(s: *u8) -> i64 { var n: i64=0; while s[n]!=(0 as u8){n=n+1} return n }
73func nsv_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 }
74func nsv_catb(dst: *u8, off: i64, s: *u8, n: i64) -> i64 { var i: i64=0; while i<n {dst[off+i]=s[i];i=i+1} return off+n }
75func nsv_catn(dst: *u8, off: i64, v: i64) -> i64 {
  var o: i64=off
  var m: i64=v
  if m<0 { dst[o]=45 as u8; o=o+1; m=0-m }
  let t: *u8=sys_mmap(28)
  var k: i64=0
  if m==0 { t[0]=48 as u8; k=1 }
  while m>0 { t[k]=(48+(m%10)) as u8; m=m/10; k=k+1 }
  var i: i64=0
  while i<k { dst[o+i]=t[k-1-i]; i=i+1 }
  return o+k
86}
87
88func nsv_log(s: *u8) -> i64 { var n: i64=0; while s[n]!=(0 as u8){n=n+1} sys_write(1,s,n); return 0 }
89
90// g_nsv_mt layout: [0]=mfirst [1]=nm_c [2]=vfirst [3]=vocab [4]=te_base [5]=te_ty [6]=ready [7]=init_ms
91//                  [8]=oh_base [9]=oh_ty  (head tensor -- passed to nsv_build_caches via statics)
92
93// STAGE 1: read model, parse, resolve tokenizer meta + the 3 tensors, load output-norm. NO pooled calls.
94// Split from nsv_init (single responsibility + lean frame: the fused 150-line init hit an nx_cc large-frame
95// codegen edge -- a GP fault at the first pooled call -- that vanishes when each stage is its own function).
96func nsv_load_meta(path: *u8) -> i64 {
  let len_out: *i64 = sys_mmap(8) as *i64
  len_out[0]=0
  if g_nsv_q4k == 1 {
      // LM4: the weights are READ IN PLACE, so the model must be a file-backed map (evictable page cache),
      // never a 4.7 GB anonymous copy. sys_map_file is read-only by construction (Rule 26).
      nsv_log("  [init] mapping model (file-backed, resident-Q4_K)...\n" as *u8)
      g_nsv_buf = sys_map_file(path, len_out)
  } else {
      nsv_log("  [init] reading model...\n" as *u8)
      g_nsv_buf = sys_read_file(path, len_out)
  }
  if (g_nsv_buf as i64) == 0 { return 1 }
  g_nsv_hdr = sys_mmap(NX_GGUF_HDR_BYTES) as *NxGgufHeader
  nsv_log("  [init] parsing gguf...\n" as *u8)
  if nx_gguf_parse(g_nsv_buf, len_out[0], g_nsv_hdr) != NX_GGUF_OK { return 2 }
  // ARCH-CONFIG (2026-07-15): dims from the model's own metadata (nac_read_config, gate-proven 07-10) --
  // ANY Qwen2/Llama-schema gguf serves; for the 0.5B these are the SAME numbers, now read instead of assumed.
  g_nsv_dims = sys_mmap(16*8) as *i64
  let arch_out: *u8 = sys_mmap(48)
  if nac_read_config(g_nsv_buf, len_out[0], g_nsv_hdr, g_nsv_dims, arch_out) != 0 { return 8 }
  if g_nsv_dims[10] != 1 { return 8 }
  // FAIL-FAST TYPE SCAN (2026-07-15 debt-eaten): every tensor's quant type must be supported BEFORE we
  // serve. Unknown types used to zero/wrong-decode SILENTLY mid-token; now init refuses (error 10) and
  // the daemon never comes up on a model we cannot faithfully decode. (⚠hsc is a FRESH local -- the
  // first cut used `hloc` which is declared LATER in this fn; nx_cc accepts use-before-declare of a
  // local and reads stack garbage -> SEGV. The LOCAL sibling of the fwd-static-ref gotcha.)
  let hsc: *NxGgufHeader = g_nsv_hdr
  let vbts: *i64 = sys_mmap(16) as *i64
  var tscan: i64 = 0
  while tscan < hsc.tensor_count {
      let tsi: *NxGgufTensorInfo = nx_gguf_tensor_at(hsc, tscan)
      if nf_type_stride(tsi.ggml_type, vbts) != 0 { return 10 }
      tscan = tscan + 1
  }
  let ne: i64 = g_nsv_dims[0]
  // hloc: local copy of the static header pointer. This organ FOUND the static-base member-access
  // miscompile (g_nsv_hdr.data_off returned the pointer, not the field) -- ROOT-FIXED + BLESSED
  // 2026-07-10 (nx_parse VK_GLOBAL unwrap, nx_static_field_probe pins it). The local copy stays as
  // style: one load, then cheap field reads.
  let hloc: *NxGgufHeader = g_nsv_hdr
  g_nsv_mt = sys_mmap(16*8) as *i64
  let voff: *i64=sys_mmap(8) as *i64
  let vty: *i64=sys_mmap(8) as *i64
  let km: *u8="tokenizer.ggml.merges" as *u8
  let kt: *u8="tokenizer.ggml.tokens" as *u8
  if nx_gguf_meta_find(g_nsv_buf, len_out[0], g_nsv_hdr, km, nsv_slen(km), voff, vty)==NX_GMETA_OK {
      g_nsv_mt[1]=nx_gguf_meta_array_count(g_nsv_buf, voff[0])
      g_nsv_mt[0]=nx_gguf_meta_array_first_elt_off(g_nsv_buf, voff[0])
  } else { return 3 }
  if nx_gguf_meta_find(g_nsv_buf, len_out[0], g_nsv_hdr, kt, nsv_slen(kt), voff, vty)==NX_GMETA_OK {
      g_nsv_mt[3]=nx_gguf_meta_array_count(g_nsv_buf, voff[0])
      g_nsv_mt[2]=nx_gguf_meta_array_first_elt_off(g_nsv_buf, voff[0])
  } else { return 4 }
  let nt: *u8="token_embd.weight" as *u8
  let no: *u8="output.weight" as *u8
  let nn: *u8="output_norm.weight" as *u8
  let ie: nx_int=nx_gguf_find_tensor(g_nsv_hdr, nt, 17)
  var io: nx_int=nx_gguf_find_tensor(g_nsv_hdr, no, 13)
  let inn: nx_int=nx_gguf_find_tensor(g_nsv_hdr, nn, 18)
  if ie<0 { return 5 }
  if io<0 { io = ie }  // tied-embeddings fallback: qwen2-0.5b ties lm_head to token_embd; embedding-model GGUFs (jina) omit output.weight entirely
  if inn<0 { return 5 }
  let te: *NxGgufTensorInfo=nx_gguf_tensor_at(hloc, ie)
  g_nsv_mt[4]=hloc.data_off+te.offset
  g_nsv_mt[5]=te.ggml_type
  let oh: *NxGgufTensorInfo=nx_gguf_tensor_at(hloc, io)
  g_nsv_mt[8]=hloc.data_off+oh.offset
  g_nsv_mt[9]=oh.ggml_type
  nsv_log("  [init] tensors located; loading output norm...\n" as *u8)
  g_nsv_gout=sys_mmap(ne*8) as *i64
  load_named_q16(g_nsv_buf, g_nsv_hdr, nn, 18, g_nsv_gout, ne)
  return 0
169}
170
171// STAGE 2: allocate all per-request scratch + KV caches (sized to the serve MAXT). NO pooled calls.
172func nsv_alloc_scratch() -> i64 {
  let ne: i64 = g_nsv_dims[0]
  let qd: i64 = g_nsv_dims[5]
  let kvd: i64 = g_nsv_dims[6]
  let fd: i64 = g_nsv_dims[7]
  let nl: i64 = g_nsv_dims[1]
  let hd: i64 = g_nsv_dims[4]
  nsv_log("  [init] allocating scratch + kv...\n" as *u8)
  g_nsv_sb=sys_mmap(14*8) as *i64
  g_nsv_sb[0]=sys_mmap(NSV_MAXT*ne*8) as i64
  g_nsv_sb[1]=sys_mmap(NSV_MAXT*qd*8) as i64
  g_nsv_sb[2]=sys_mmap(NSV_MAXT*kvd*8) as i64
  g_nsv_sb[3]=sys_mmap(NSV_MAXT*kvd*8) as i64
  g_nsv_sb[4]=sys_mmap(NSV_MAXT*qd*8) as i64
  g_nsv_sb[5]=sys_mmap(NSV_MAXT*8) as i64
  g_nsv_sb[6]=sys_mmap(NSV_MAXT*8) as i64
  g_nsv_sb[7]=sys_mmap(NSV_MAXT*ne*8) as i64
  g_nsv_sb[8]=sys_mmap(NSV_MAXT*fd*8) as i64
  g_nsv_sb[9]=sys_mmap(NSV_MAXT*fd*8) as i64
  g_nsv_sb[10]=sys_mmap(NSV_MAXT*fd*8) as i64
  g_nsv_sb[11]=sys_mmap(NSV_MAXT*ne*8) as i64
  g_nsv_sb[12]=sys_mmap(NSV_MAXT*ne*8) as i64
  g_nsv_sb[13]=sys_mmap(NSV_MAXT*ne*8) as i64
  g_nsv_kvc=sys_mmap(2*nl*8) as *i64
  var kl: i64=0
  while kl<nl { g_nsv_kvc[2*kl]=sys_mmap(NSV_MAXT*kvd*8) as i64; g_nsv_kvc[2*kl+1]=sys_mmap(NSV_MAXT*kvd*8) as i64; kl=kl+1 }
  g_nsv_nmbuf=sys_mmap(64)
  g_nsv_freqs=sys_mmap(hd*8) as *i64
  rope_freqs(g_nsv_freqs, hd)
  g_nsv_tmp=sys_mmap(64*256*8) as *i64
  g_nsv_x1=sys_mmap(ne*8) as *i64
  g_nsv_h1=sys_mmap(ne*8) as *i64
  g_nsv_xt=sys_mmap(NSV_MAXT*ne*8) as *i64
  g_nsv_prefill_batched=NSV_PREFILL_BATCHED_DEFAULT
  g_nsv_normed=sys_mmap(ne*8) as *i64
  g_nsv_idout=sys_mmap(8) as *i64
  g_nsv_lgout=sys_mmap(8) as *i64
  g_nsv_ids=sys_mmap((NSV_MAXIN + NSV_CHATML_IDS)*8) as *i64   // sized by BYTES like tokp/tokl (a token covers >= 1 byte, so ntok <= bytes): the token-cap check below is then always reached instead of an overrun (2026-09-17: a 19222-byte BRIGHT query overran the 2048-entry buffer and the serving engine died in tk_rank_fast)
  g_nsv_tokp=sys_mmap(NSV_MAXIN*8) as *i64      // 1 slot per INPUT BYTE (byte-level pretokenize) -> size by BYTES
  g_nsv_tokl=sys_mmap(NSV_MAXIN*8) as *i64
  let vcl: i64 = g_nsv_mt[3]
  g_nsv_lgv=sys_mmap(vcl*8) as *i64
  g_nsv_cfgA=sys_mmap(8*8) as *i64
  g_nsv_cfgA[1]=ne
  g_nsv_cfgA[2]=g_nsv_dims[2]
  g_nsv_cfgA[3]=g_nsv_dims[3]
  g_nsv_cfgA[4]=hd
  g_nsv_cfgA[5]=qd
  g_nsv_cfgA[6]=kvd
  g_nsv_cfgA[7]=g_nsv_dims[8]
  g_nsv_cfgF=sys_mmap(4*8) as *i64
  g_nsv_cfgF[1]=ne
  g_nsv_cfgF[2]=fd
  return 0
226}
227
228// ---- one-time session init (fail-fast: any error -> nonzero, organ must not serve). Thin orchestrator
229// over three lean stages -- each its own frame so the pooled STAGE 3 never shares a frame with the big
230// STAGE 1/2 setup (the large-frame codegen edge that GP-faulted the fused version). ----
231// LIGHT INIT (2026-07-16, memory-proportionate loading): i8-only serve skips the i32 weight cache (~4 bytes/param
232// -- the single biggest allocation; ~6GB at 1.5B) so a mode-1-pinned organ fits comfortably inside the WSL VM
233// (host-pressure kills root-caused: 32GB host, dual-cache 1.5B init ~11GB -> intermittent SIGKILL of the tree).
234// Head cache stays (sampling needs full logits). CONTRACT: after nsv_init_i8, callers MUST pin mode=1 (gp[3]=1);
235// mode 0 would read the absent i32 cache.
236static g_nsv_i8only: i64
237static g_nsv_noi8: i64          // 1 = lossless-only init: the i32 cache and NO i8 cache (the quantisation-gap probe on a 16 GB VM)
238func nsv_init_i8(path: *u8) -> i64 {
  g_nsv_i8only = 1
  return nsv_init(path)
241}
242// LOSSLESS-ONLY INIT (2026-09-17, the quantisation-gap probe): the i32 cache and NO i8 cache, so a probe that decodes
243// mode 0 only fits beside the running i8 engine on a 16 GB VM. CONTRACT: callers pin mode=0 (gp[3]=0); mode 1 would
244// read the absent i8 cache.
245func nsv_init_i32only(path: *u8) -> i64 {
  g_nsv_noi8 = 1
  return nsv_init(path)
248}
249// LM4 RESIDENT-Q4_K INIT (2026-09-02): no i32 layer cache, no i16 layer cache -- every Q4_K projection is dotted
250// in place from the file map (nx_nofloat_q4k); non-Q4_K tensors fall back per tensor to i16 and are counted.
251// Head cache stays i32 (sampling needs full logits). CONTRACT: callers use decode mode 3 (the request parser
252// defaults to it and refuses i32/i8, whose caches were never built).
253func nsv_init_q4k(path: *u8) -> i64 {
  g_nsv_q4k = 1
  g_nsv_i8only = 1
  return nsv_init(path)
257}
258func nsv_init(path: *u8) -> i64 {
  let t0: i64 = sys_now_ms()
  g_nsv_mpath = path
  // Spawn the worker pool at startup (fail-fast: workers ready before the first request, not on first
  // token). nf_pool is idempotent -> the cache build + every decode reuse this instance.
  nsv_log("  [init] pre-warming worker pool...\n" as *u8)
  nf_pool()
  let rc1: i64 = nsv_load_meta(path)
  if rc1 != 0 { return rc1 }
  nsv_alloc_scratch()
  let brc: i64 = nsv_build_caches()
  if brc != 0 { return brc }
  g_nsv_mt[7]=sys_now_ms()-t0
  g_nsv_mt[6]=1
  return 0
273}
274
275// STAGE 3: build the dequant-once caches (i32 head + i32 layers + i8 layers). The ONLY pooled stage;
276// reads oh_base/oh_ty from g_nsv_mt[8]/[9]. Lean frame = no GP fault at nf_pool() first-touch.
277func nsv_build_caches() -> i64 {
  let ne: i64 = g_nsv_dims[0]
  let qd: i64 = g_nsv_dims[5]
  let kvd: i64 = g_nsv_dims[6]
  let fd: i64 = g_nsv_dims[7]
  let nl: i64 = g_nsv_dims[1]
  let oh_base: i64 = g_nsv_mt[8]
  let oh_ty: i64 = g_nsv_mt[9]
  let vcb: i64 = g_nsv_mt[3]
  nsv_log("  [init] building i32 head cache...\n" as *u8)
  let hcache: *i32 = nf_dequant_head_all_i32(g_nsv_buf, oh_base, oh_ty, vcb, ne)
  if (hcache as i64) <= 0 { return 7 }
  if g_nsv_i8only == 0 {
      nsv_log("  [init] building i32 weight cache (dequant-once)...\n" as *u8)
      g_nsv_wc32=sys_mmap(nl*8) as *i64
      let ovf: i64=nf_dequant_all_layers_i32(g_nsv_buf, g_nsv_hdr, g_nsv_wc32, nl, ne, qd, kvd, fd)
      if ovf != 0 { return 6 }
  } else {
      nsv_log("  [init] i8-only: skipping i32 weight cache (memory-proportionate)\n" as *u8)
  }
  if g_nsv_q4k == 1 {
      nsv_log("  [init] building resident-Q4_K slot tables (weights stay in the file map)...\n" as *u8)
      g_nsv_wq4=sys_mmap(nl*8) as *i64
      g_nsv_q4st=sys_mmap(NQ_ST_WORDS*8) as *i64
      if nq_build_layers(g_nsv_buf, g_nsv_hdr, g_nsv_wq4, nl, ne, qd, kvd, fd, g_nsv_nmbuf, g_nsv_q4st) != 0 { return 11 }
      nsv_log("  [init] q4k layers=" as *u8); nsv_logn(g_nsv_q4st[3])
      nsv_log(" inplace_tensors=" as *u8); nsv_logn(g_nsv_q4st[0])
      nsv_log(" inplace_file_bytes=" as *u8); nsv_logn(g_nsv_q4st[4])
      nsv_log(" fallback_i16_tensors=" as *u8); nsv_logn(g_nsv_q4st[1])
      nsv_log(" fallback_anon_bytes=" as *u8); nsv_logn(g_nsv_q4st[2])
      nsv_log(" q8_tensors=" as *u8); nsv_logn(g_nsv_q4st[5]); nsv_log(" q8_file_bytes=" as *u8); nsv_logn(g_nsv_q4st[6])
      nsv_log("\n" as *u8)
  } else { if g_nsv_noi8 == 1 {
      nsv_log("  [init] lossless-only: skipping i8 weight cache (this process decodes mode 0 only)\n" as *u8)
  } else {
      nsv_log("  [init] building i8 weight cache...\n" as *u8)
      g_nsv_wc8=sys_mmap(nl*8) as *i64
      nf_dequant_all_layers_i8(g_nsv_buf, g_nsv_hdr, g_nsv_wc8, nl, ne, qd, kvd, fd)
  } }
  nsv_log("  [init] caches ready\n" as *u8)
  g_nsv_hcp=sys_mmap(6*8) as *i64
  g_nsv_hcp[0]=hcache as i64
  g_nsv_hcp[1]=g_nsv_normed as i64
  g_nsv_hcp[2]=g_nsv_mt[3]
  g_nsv_hcp[3]=ne
  g_nsv_hcp[4]=g_nsv_idout as i64
  g_nsv_hcp[5]=g_nsv_lgout as i64
  return 0
325}
326
327func nsv_logn(v: i64) -> i64 { let t: *u8 = sys_mmap(32); let n: i64 = nsv_catn(t, 0, v); sys_write(1, t, n); return 0 }
328
329// one cached decode step at pos in the requested mode (0=i32 lossless, 1=i8 SIMD fast, 3=resident-Q4_K in place).
330const NSV_MODE_I32: i64 = 0
331const NSV_MODE_I8: i64 = 1
332const NSV_MODE_Q4K: i64 = 3    // 2 is the GPU embed grading mode (nsv_embed) -- never reuse it for a decode route
333func nsv_step(pos: i64, mode: i64) -> i64 {
  if mode == NSV_MODE_Q4K {
      decode_step_kv_q4k(g_nsv_x1, g_nsv_h1, g_nsv_wq4, g_nsv_sb, g_nsv_freqs, g_nsv_kvc, pos, g_nsv_cfgA, g_nsv_cfgF, g_nsv_dims[1])
      return 0
  }
  if mode == 1 {
      decode_step_kv_cached_i8(g_nsv_buf, g_nsv_hdr, g_nsv_x1, g_nsv_h1, g_nsv_wc8, g_nsv_sb, g_nsv_nmbuf, g_nsv_freqs, g_nsv_kvc, pos, g_nsv_cfgA, g_nsv_cfgF, g_nsv_dims[1])
  } else {
      decode_step_kv_cached_i32(g_nsv_buf, g_nsv_hdr, g_nsv_x1, g_nsv_h1, g_nsv_wc32, g_nsv_sb, g_nsv_nmbuf, g_nsv_freqs, g_nsv_kvc, pos, g_nsv_cfgA, g_nsv_cfgF, g_nsv_dims[1])
  }
  return 0
344}
345
346// R0r: the sequential prefill (one cached step per prompt token) -- the control nx_nofloat_prefill_gate measures against.
347func nsv_prefill_seq(nprompt: i64, mode: i64) -> i64 {
  let ne: i64 = g_nsv_cfgA[1]
  var i: i64 = 0
  while i < nprompt {
      dequant_row(g_nsv_buf, g_nsv_mt[4], g_nsv_mt[5], g_nsv_ids[i], ne, g_nsv_x1, g_nsv_tmp)
      nsv_step(i, mode)
      i = i + 1
  }
  return 0
356}
357// R0r: the prompt's rows through nf_prefill_batched in blocks of NF_PREFILL_M positions (one weight pass per block; the
358// block keeps the activation rows L2-resident). Leaves g_nsv_h1 exactly as the sequential path leaves it. The i8 route
359// only: the i32 and Q4_K routes keep nsv_prefill_seq, and nsv_generate_pfx (the forge's prefix-cache path) stays sequential.
360func nsv_prefill_i8_batched(nprompt: i64) -> i64 {
  let ne: i64 = g_nsv_cfgA[1]
  var i: i64 = 0
  while i < nprompt {
      dequant_row(g_nsv_buf, g_nsv_mt[4], g_nsv_mt[5], g_nsv_ids[i], ne, ((g_nsv_xt as i64)+i*ne*8) as *i64, g_nsv_tmp)
      i = i + 1
  }
  var b: i64 = 0
  while b < nprompt {
      var T: i64 = NF_PREFILL_M
      if b + T > nprompt { T = nprompt - b }
      nf_prefill_batched(g_nsv_buf, g_nsv_hdr, ((g_nsv_xt as i64)+b*ne*8) as *i64, g_nsv_h1, g_nsv_wc8, g_nsv_sb, g_nsv_nmbuf, g_nsv_freqs, g_nsv_kvc, b, T, g_nsv_cfgA, g_nsv_cfgF, g_nsv_dims[1])
      b = b + T
  }
  return 0
375}
376
377// xorshift64* PRNG step; state at sp[0] (never 0). Deterministic per seed -- "same in -> same bytes" holds
378// with the seed as part of the in.
379func nsv_rand(sp: *i64) -> i64 {
  var s: i64 = sp[0]
  s = s ^ (s >> 12)
  s = s ^ (s << 25)
  s = s ^ (s >> 27)
  sp[0] = s
  var r: i64 = s * 2685821657736338717
  if r < 0 { r = 0 - r }
  if r < 0 { r = 0 }
  return r
389}
390// temperature/top-k/top-p sampling over the full logit vector -- 100 percent integer (logits are Q16 head
391// convention; fx_exp is the same Q16 exp the attention softmax rides). sp = [lgv, vocab, temp_pm, top_p_pm,
392// top_k, seed_state_ptr]. Returns the sampled token id.
393func nsv_sample(sp: *i64) -> i64 {
  let lgv: *i64 = sp[0] as *i64
  let vocab: i64 = sp[1]
  var temp_pm: i64 = sp[2]
  var top_p_pm: i64 = sp[3]
  var k: i64 = sp[4]
  let sd: *i64 = sp[5] as *i64
  if temp_pm < 1 { temp_pm = 1 }
  if temp_pm > 5000 { temp_pm = 5000 }
  if top_p_pm < 1 { top_p_pm = 1 }
  if top_p_pm > 1000 { top_p_pm = 1000 }
  if k < 1 { k = 1 }
  if k > 256 { k = 256 }
  // top-k select (insertion into a small descending array; common case = 1 compare reject)
  let kid: *i64 = sys_mmap(256*8) as *i64
  let klg: *i64 = sys_mmap(256*8) as *i64
  var n: i64 = 0
  var v: i64 = 0
  while v < vocab {
      let l: i64 = lgv[v]
      var take: i64 = 0
      if n < k { take = 1 } else { if l > klg[n-1] { take = 1 } }
      if take == 1 {
          var pos: i64 = n
          if pos >= k { pos = k - 1 }
          var j: i64 = pos
          while j > 0 { if l > klg[j-1] { klg[j]=klg[j-1]; kid[j]=kid[j-1]; j=j-1 } else { j = 0 - j } }
          if j < 0 { j = 0 - j }
          klg[j]=l
          kid[j]=v
          if n < k { n = n + 1 }
      }
      v = v + 1
  }
  // temperature -> Q16 exp weights (max-subtracted so fx_exp sees <= 0)
  let ev: *i64 = sys_mmap(256*8) as *i64
  let base: i64 = klg[0]
  var total: i64 = 0
  var i: i64 = 0
  while i < n {
      let x: i64 = ((klg[i] - base) * 1000) / temp_pm
      let e: i64 = fx_exp(x)
      ev[i] = e
      total = total + e
      i = i + 1
  }
  if total <= 0 { return kid[0] }
  // top-p nucleus: keep the smallest prefix (descending) whose mass >= top_p_pm/1000 of total
  let cutoff: i64 = (top_p_pm * total) / 1000
  var m: i64 = 0
  var cum: i64 = 0
  var going: i64 = 1
  while going == 1 {
      if m >= n { going = 0 } else {
          cum = cum + ev[m]
          m = m + 1
          if cum >= cutoff { going = 0 }
      }
  }
  if m < 1 { m = 1 }
  var mtotal: i64 = 0
  i = 0
  while i < m { mtotal = mtotal + ev[i]; i = i + 1 }
  if mtotal <= 0 { return kid[0] }
  // draw
  let r: i64 = nsv_rand(sd) % mtotal
  var c2: i64 = 0
  i = 0
  while i < m { c2 = c2 + ev[i]; if c2 > r { return kid[i] } i = i + 1 }
  return kid[m-1]
463}
464// pick the next token from the current normed hidden state. np = [temp_pm, top_p_pm, top_k, seed_state_ptr].
465// temp_pm==0 -> greedy argmax (the bit-exact hero path, unchanged); else full-logits head + seeded sampling.
466func nsv_next_token(np: *i64) -> i64 {
  if np[0] == 0 { return head_argmax_cached_i32(g_nsv_hcp) }
  let hlp: *i64 = sys_mmap(6*8) as *i64
  hlp[0]=g_nsv_hcp[0]
  hlp[1]=g_nsv_normed as i64
  hlp[2]=g_nsv_mt[3]
  hlp[3]=g_nsv_cfgA[1]
  hlp[4]=g_nsv_lgv as i64
  head_logits_cached_i32(hlp)
  let sp: *i64 = sys_mmap(6*8) as *i64
  sp[0]=g_nsv_lgv as i64
  sp[1]=g_nsv_mt[3]
  sp[2]=np[0]
  sp[3]=np[1]
  sp[4]=np[2]
  sp[5]=np[3]
  return nsv_sample(sp)
483}
484// decode token `tok` to text: append to the out buffer AND (if ep[3]=fd >= 0) emit one SSE frame
485// `data: {"piece":"..."}` to the stream. ep = [out, olen, ocap, fd]. Returns the new olen.
486func nsv_emit_piece(tok: i64, ep: *i64) -> i64 {
  let out: *u8 = ep[0] as *u8
  var olen: i64 = ep[1]
  let ocap: i64 = ep[2]
  let fd: i64 = ep[3]
  let off: i64 = tk_decode_off(g_nsv_buf, g_nsv_mt[2], tok)
  let pl: i64 = nx_gguf_meta_read_string_len(g_nsv_buf, off)
  if pl < 1 { return olen }
  let tmp: *u8 = sys_mmap(1024)
  let tn: i64 = td_piece_decode(nx_gguf_meta_read_string_ptr(g_nsv_buf, off), pl, tmp, 0, 1000)
  var i: i64 = 0
  while i < tn { if olen < ocap { out[olen]=tmp[i]; olen=olen+1 } i = i + 1 }
  if fd >= 0 {
      let fr: *u8 = sys_mmap(4096)
      var fo: i64 = nsv_cat(fr, 0, "data: {\"piece\":\"" as *u8)
      fo = nsv_jesc(fr, fo, tmp, tn)
      fo = nsv_cat(fr, fo, "\"}\n\n" as *u8)
      var w: i64 = 0
      while w < fo { let kw: i64 = sys_write(fd, ((fr as i64)+w) as *u8, fo-w); if kw <= 0 { w = fo } else { w = w + kw } }
  }
  return olen
507}
508
509// build a ChatML prompt id sequence into g_nsv_ids:
510//   <|im_start|>user\n{content}<|im_end|>\n<|im_start|>assistant\n
511// special ids 151644 (im_start) / 151645 (im_end == NSV_EOS2) are SPLICED directly (tk_bpe_encode
512// is pure byte-BPE and would byte-encode the marker text). Everything INLINE -- no multi-data-arg
513// helper (the documented 3+-arg miscompile class). Returns nprompt (total ids). Lets the INSTRUCT
514// model see turn structure. tmpids: tk_bpe_encode writes from index 0, so encode into it then copy.
515func nsv_chatml_ids(content: *u8, clen: i64) -> i64 {
  let base: i64 = g_nsv_ids as i64
  var off: i64 = 0
  // <|im_start|>
  g_nsv_ids[off] = 151644
  off = off + 1
  // user\n  (encode IN-PLACE into g_nsv_ids[off..] -- the proven single-call buffer)
  let po1: i64 = base + off*8
  let ip1: *i64 = po1 as *i64
  let nu: i64 = tk_bpe_encode(g_nsv_buf, g_nsv_mt[0], g_nsv_mt[1], g_nsv_mt[2], g_nsv_mt[3], "user\n" as *u8, 5, g_nsv_tokp, g_nsv_tokl, ip1)
  off = off + nu
  // content
  let po2: i64 = base + off*8
  let ip2: *i64 = po2 as *i64
  let nc: i64 = tk_bpe_encode_b(g_nsv_buf, g_nsv_mt[0], g_nsv_mt[1], g_nsv_mt[2], g_nsv_mt[3], content, clen, g_nsv_tokp, g_nsv_tokl, NSV_MAXIN, ip2, NSV_MAXIN + NSV_CHATML_IDS - off)
  if nc == TK_REFUSED_TOO_LONG { return TK_REFUSED_TOO_LONG }
  off = off + nc
  // <|im_end|>
  g_nsv_ids[off] = 151645
  off = off + 1
  // \n
  let po3: i64 = base + off*8
  let ip3: *i64 = po3 as *i64
  let nn: i64 = tk_bpe_encode(g_nsv_buf, g_nsv_mt[0], g_nsv_mt[1], g_nsv_mt[2], g_nsv_mt[3], "\n" as *u8, 1, g_nsv_tokp, g_nsv_tokl, ip3)
  off = off + nn
  // <|im_start|>
  g_nsv_ids[off] = 151644
  off = off + 1
  // assistant\n
  let po4: i64 = base + off*8
  let ip4: *i64 = po4 as *i64
  let na: i64 = tk_bpe_encode(g_nsv_buf, g_nsv_mt[0], g_nsv_mt[1], g_nsv_mt[2], g_nsv_mt[3], "assistant\n" as *u8, 10, g_nsv_tokp, g_nsv_tokl, ip4)
  off = off + na
  return off
549}
550
551// THE DOOR (2026-09-17): a prompt is admitted by its BYTE length before a byte of it is tokenised. tk_bpe_encode seeds
552// one scratch slot per input byte into g_nsv_tokp and g_nsv_tokl (NSV_MAXIN entries) and writes ids unbounded, so the
553// old order (encode, then check the token count) let a 19222-byte query overrun the scratch and kill the serving
554// engine inside tk_rank_fast (reproduced on a debug build, resolved by nx_addr2line). 0 admitted, NSV_ERR_TOO_LONG refused.
555func nsv_prompt_admit(plen: i64) -> i64 {
  if plen > NSV_MAXIN { return NSV_ERR_TOO_LONG }
  return 0
558}
559
560// generation. gp = [prompt, plen, max_new, mode, out_text, otcap, meta, stream_fd(-1=none),
561//                   temp_pm(0=greedy), top_p_pm, top_k, seed, chatml(1=wrap prompt in ChatML)].
562// meta out: [0]=n_prompt [1]=n_gen [2]=ms_total [3]=ms_per_tok [4]=eos [5]=err. returns text length (-1 on err).
563func nsv_generate(gp: *i64) -> i64 {
  let prompt: *u8 = gp[0] as *u8
  let plen: i64 = gp[1]
  var max_new: i64 = gp[2]
  let mode: i64 = gp[3]
  let out: *u8 = gp[4] as *u8
  let ocap: i64 = gp[5]
  let meta: *i64 = gp[6] as *i64
  meta[0]=0
  meta[1]=0
  meta[2]=0
  meta[3]=0
  meta[4]=0
  meta[5]=0
  if g_nsv_mt[6] != 1 { meta[5]=9; return 0-1 }
  if plen < 1 { meta[5]=1; return 0-1 }
  if nsv_prompt_admit(plen) != 0 { meta[5]=NSV_ERR_TOO_LONG; return 0-1 }
  if max_new < 1 { max_new = 24 }
  if max_new > NSV_MAXNEW { max_new = NSV_MAXNEW }
  var nprompt: i64 = 0
  if gp[12] == 1 { nprompt = nsv_chatml_ids(prompt, plen) }
  else { nprompt = tk_bpe_encode_b(g_nsv_buf, g_nsv_mt[0], g_nsv_mt[1], g_nsv_mt[2], g_nsv_mt[3], prompt, plen, g_nsv_tokp, g_nsv_tokl, NSV_MAXIN, g_nsv_ids, NSV_MAXIN + NSV_CHATML_IDS) }
  if nprompt == TK_REFUSED_TOO_LONG { meta[5]=NSV_ERR_TOO_LONG; return 0-1 }
  if nprompt < 1 { meta[5]=2; return 0-1 }
  if nprompt >= NSV_MAXT - 2 { meta[5]=3; return 0-1 }
  if nprompt + max_new >= NSV_MAXT { max_new = NSV_MAXT - 1 - nprompt }
  meta[0]=nprompt
  let ne: i64 = g_nsv_cfgA[1]
  // sampling params (gp[8]=temp_pm 0=greedy, gp[9]=top_p_pm, gp[10]=top_k, gp[11]=seed) + stream fd (gp[7])
  let np: *i64 = sys_mmap(4*8) as *i64
  let sd: *i64 = sys_mmap(8) as *i64
  var seed: i64 = gp[11]
  if seed == 0 { seed = 88172645463325252 }
  sd[0]=seed
  np[0]=gp[8]
  np[1]=gp[9]
  np[2]=gp[10]
  np[3]=sd as i64
  let ep: *i64 = sys_mmap(4*8) as *i64
  ep[0]=out as i64
  ep[1]=0
  ep[2]=ocap
  ep[3]=gp[7]
  let t0: i64 = sys_now_ms()
  // CACHED prefill. R0r (2026-09-17): the i8 route runs the prompt in blocks through nf_prefill_batched (one weight
  // pass per NF_PREFILL_M positions) unless g_nsv_prefill_batched is 0; every other route runs the sequential
  // per-token step. Both are bit-identical under causal masking (row t only ever attends 0..t) and both ride the
  // dequant-once caches, so there is NO per-request re-dequant of the model. meta[6] carries the prefill ms.
  var seqpre: i64 = 1
  if mode == NSV_MODE_I8 { if g_nsv_prefill_batched == 1 { seqpre = 0 } }
  if seqpre == 1 { nsv_prefill_seq(nprompt, mode) } else { nsv_prefill_i8_batched(nprompt) }
  meta[6] = sys_now_ms() - t0
  rmsnorm_gamma_row_q24(g_nsv_h1, g_nsv_gout, 0, ne, g_nsv_normed, 0)
  var next: i64 = nsv_next_token(np)
  var T: i64 = nprompt
  g_nsv_ids[T]=next
  T=T+1
  var ngen: i64 = 1
  var stop: i64 = 0
  if next==NSV_EOS1 { stop=1; meta[4]=1 }
  if next==NSV_EOS2 { stop=1; meta[4]=1 }
  if stop == 0 { ep[1] = nsv_emit_piece(next, ep) }
  while stop == 0 {
      if ngen >= max_new { stop = 1 } else { if T >= NSV_MAXT { stop = 1 } else {
          let pos: i64 = T - 1
          dequant_row(g_nsv_buf, g_nsv_mt[4], g_nsv_mt[5], g_nsv_ids[pos], ne, g_nsv_x1, g_nsv_tmp)
          nsv_step(pos, mode)
          rmsnorm_gamma_row_q24(g_nsv_h1, g_nsv_gout, 0, ne, g_nsv_normed, 0)
          next = nsv_next_token(np)
          g_nsv_ids[T]=next
          T=T+1
          ngen=ngen+1
          if next==NSV_EOS1 { stop=1; meta[4]=1 }
          if next==NSV_EOS2 { stop=1; meta[4]=1 }
          if meta[4] == 0 { ep[1] = nsv_emit_piece(next, ep) }
      } }
  }
  let t1: i64 = sys_now_ms()
  meta[1]=ngen
  meta[2]=t1-t0
  if ngen > 0 { meta[3]=(t1-t0)/(nprompt+ngen) }
  return ep[1]
645}
646
647// ---- PREFIX-KV-CACHE (2026-07-15): the forge re-prefills a FIXED crib (~130 tok) on every task. Snapshot the
648// crib's KV rows 0..P-1 ONCE, restore them per task -> skip re-prefilling the crib (~P fewer prefill steps/task).
649// BIT-EXACT by causal masking: row t only attends 0..t, so the crib K/V are identical with or without the suffix
650// (the code already relies on this for sequential==batch prefill). Additive: the live nsv_generate is untouched.
651func nsv_kv_snapshot(P: i64) -> i64 {
  let kvd: i64 = g_nsv_dims[6]
  let nl: i64 = g_nsv_dims[1]
  let per: i64 = P * kvd
  g_nsv_kvsnap = sys_mmap(2 * nl * per * 8) as *i64
  g_nsv_snap_p = P
  g_nsv_crib_ids = sys_mmap(P * 8) as *i64
  var s: i64 = 0
  while s < P { g_nsv_crib_ids[s] = g_nsv_ids[s]; s = s + 1 }
  var L: i64 = 0
  while L < nl {
      let K: *i64 = g_nsv_kvc[2*L] as *i64
      let V: *i64 = g_nsv_kvc[2*L+1] as *i64
      let base: i64 = (2*L) * per
      var e: i64 = 0
      while e < per {
          g_nsv_kvsnap[base + e] = K[e]
          g_nsv_kvsnap[base + per + e] = V[e]
          e = e + 1
      }
      L = L + 1
  }
  return 0
674}
675func nsv_kv_restore() -> i64 {
  if (g_nsv_kvsnap as i64) == 0 { return 0 - 1 }
  let kvd: i64 = g_nsv_dims[6]
  let nl: i64 = g_nsv_dims[1]
  let P: i64 = g_nsv_snap_p
  let per: i64 = P * kvd
  var L: i64 = 0
  while L < nl {
      let K: *i64 = g_nsv_kvc[2*L] as *i64
      let V: *i64 = g_nsv_kvc[2*L+1] as *i64
      let base: i64 = (2*L) * per
      var e: i64 = 0
      while e < per {
          K[e] = g_nsv_kvsnap[base + e]
          V[e] = g_nsv_kvsnap[base + per + e]
          e = e + 1
      }
      L = L + 1
  }
  return 0
695}
696// DISK-PERSISTED snapshot (2026-07-15): the crib KV survives process restarts -- a fresh process loads the
697// snapshot instead of re-prefilling (the WSL/daemon-restart pattern). Format: [P][nl][kvd] then crib ids
698// (P i64) then per-layer K rows then V rows (P*kvd i64 each). Load fail-safe: any dim mismatch -> -1, caller
699// falls back to full prefill (never a wrong cache).
700func nsv_kv_snapshot_save(path: *u8) -> i64 {
  if (g_nsv_kvsnap as i64) == 0 { return 0 - 1 }
  let kvd: i64 = g_nsv_dims[6]
  let nl: i64 = g_nsv_dims[1]
  let P: i64 = g_nsv_snap_p
  let per: i64 = P * kvd
  let fd: i64 = sys_openat_wr(path, 0x1a4)
  if fd < 0 { return 0 - 2 }
  let hdrb: *i64 = sys_mmap(3*8) as *i64
  hdrb[0] = P
  hdrb[1] = nl
  hdrb[2] = kvd
  sys_write(fd, hdrb as *u8, 24)
  sys_write(fd, g_nsv_crib_ids as *u8, P*8)
  sys_write(fd, g_nsv_kvsnap as *u8, 2*nl*per*8)
  sys_close(fd)
  return 0
717}
718func nsv_kv_snapshot_load(path: *u8) -> i64 {
  let kvd: i64 = g_nsv_dims[6]
  let nl: i64 = g_nsv_dims[1]
  let fd: i64 = sys_openat_rd(path)
  if fd < 0 { return 0 - 1 }
  let hdrb: *i64 = sys_mmap(3*8) as *i64
  if sys_read(fd, hdrb as *u8, 24) != 24 { sys_close(fd); return 0 - 2 }
  let P: i64 = hdrb[0]
  if P < 1 { sys_close(fd); return 0 - 3 }
  if P >= NSV_MAXT { sys_close(fd); return 0 - 3 }
  if hdrb[1] != nl { sys_close(fd); return 0 - 4 }
  if hdrb[2] != kvd { sys_close(fd); return 0 - 4 }
  let per: i64 = P * kvd
  g_nsv_crib_ids = sys_mmap(P*8) as *i64
  g_nsv_kvsnap = sys_mmap(2*nl*per*8) as *i64
  var need: i64 = P*8
  var got: i64 = 0
  var q: *u8 = g_nsv_crib_ids as *u8
  while got < need { let r: i64 = sys_read(fd, (q as i64 + got) as *u8, need - got); if r <= 0 { sys_close(fd); return 0 - 5 } got = got + r }
  need = 2*nl*per*8
  got = 0
  q = g_nsv_kvsnap as *u8
  while got < need { let r2: i64 = sys_read(fd, (q as i64 + got) as *u8, need - got); if r2 <= 0 { sys_close(fd); return 0 - 5 } got = got + r2 }
  sys_close(fd)
  g_nsv_snap_p = P
  return P
744}
745
746// nsv_generate with prefix-KV-cache. prefix_len = # prompt tokens shared with the snapshot; use_snap: 0 = prefill
747// all + snapshot rows 0..prefix_len-1; 1 = restore the snapshot + prefill only [prefix_len..nprompt). Requires
748// prefix_len < nprompt when use_snap==1 (a suffix must exist). Everything after prefill is byte-identical to
749// nsv_generate (same decode, sampling, emit) -> the OUTPUT must match nsv_generate exactly (the gate proves it).
750func nsv_generate_pfx(gp: *i64, prefix_len: i64, use_snap: i64) -> i64 {
  let prompt: *u8 = gp[0] as *u8
  let plen: i64 = gp[1]
  var max_new: i64 = gp[2]
  let mode: i64 = gp[3]
  let out: *u8 = gp[4] as *u8
  let ocap: i64 = gp[5]
  let meta: *i64 = gp[6] as *i64
  meta[0]=0
  meta[1]=0
  meta[2]=0
  meta[3]=0
  meta[4]=0
  meta[5]=0
  if g_nsv_mt[6] != 1 { meta[5]=9; return 0-1 }
  if plen < 1 { meta[5]=1; return 0-1 }
  if nsv_prompt_admit(plen) != 0 { meta[5]=NSV_ERR_TOO_LONG; return 0-1 }
  if max_new < 1 { max_new = 24 }
  if max_new > NSV_MAXNEW { max_new = NSV_MAXNEW }
  var nprompt: i64 = 0
  if gp[12] == 1 { nprompt = nsv_chatml_ids(prompt, plen) }
  else { nprompt = tk_bpe_encode_b(g_nsv_buf, g_nsv_mt[0], g_nsv_mt[1], g_nsv_mt[2], g_nsv_mt[3], prompt, plen, g_nsv_tokp, g_nsv_tokl, NSV_MAXIN, g_nsv_ids, NSV_MAXIN + NSV_CHATML_IDS) }
  if nprompt == TK_REFUSED_TOO_LONG { meta[5]=NSV_ERR_TOO_LONG; return 0-1 }
  if nprompt < 1 { meta[5]=2; return 0-1 }
  if nprompt >= NSV_MAXT - 2 { meta[5]=3; return 0-1 }
  if nprompt + max_new >= NSV_MAXT { max_new = NSV_MAXT - 1 - nprompt }
  meta[0]=nprompt
  let ne: i64 = g_nsv_cfgA[1]
  let np: *i64 = sys_mmap(4*8) as *i64
  let sd: *i64 = sys_mmap(8) as *i64
  var seed: i64 = gp[11]
  if seed == 0 { seed = 88172645463325252 }
  sd[0]=seed
  np[0]=gp[8]
  np[1]=gp[9]
  np[2]=gp[10]
  np[3]=sd as i64
  let ep: *i64 = sys_mmap(4*8) as *i64
  ep[0]=out as i64
  ep[1]=0
  ep[2]=ocap
  ep[3]=gp[7]
  let t0: i64 = sys_now_ms()
  // no-snapshot fallback: use_snap=1 with no prior snapshot degrades to a full prefill (never crashes)
  var us: i64 = use_snap
  if us == 1 { if (g_nsv_kvsnap as i64) == 0 { us = 0 } }
  var i: i64 = 0
  if us == 1 {
      nsv_kv_restore()
      // BOUNDARY-SAFE: only the token rows that ACTUALLY match the snapshotted crib are trusted; the first
      // divergent token (BPE may re-tokenize the crib/task seam) and everything after is re-prefilled fresh.
      var cp: i64 = 0
      var go: i64 = 1
      while go == 1 {
          if cp >= g_nsv_snap_p { go = 0 }
          else { if cp >= nprompt { go = 0 }
          else { if g_nsv_ids[cp] == g_nsv_crib_ids[cp] { cp = cp + 1 } else { go = 0 } } }
      }
      // stale-h1 guard: if the snapshot covers the WHOLE prompt (identical prompt, e.g. best-of-N resample),
      // still re-run the LAST prompt token so g_nsv_h1 is the state after token nprompt-1, not a stale gen state.
      // Rewriting KV row nprompt-1 with the same values is harmless; skipping it leaves h1 wrong.
      if cp >= nprompt { cp = nprompt - 1 }
      i = cp
  }
  while i < nprompt {
      dequant_row(g_nsv_buf, g_nsv_mt[4], g_nsv_mt[5], g_nsv_ids[i], ne, g_nsv_x1, g_nsv_tmp)
      nsv_step(i, mode)
      i = i + 1
  }
  if us == 0 {
      var snl: i64 = prefix_len
      if snl > nprompt { snl = nprompt }
      if snl > 0 { nsv_kv_snapshot(snl) }
  }
  rmsnorm_gamma_row_q24(g_nsv_h1, g_nsv_gout, 0, ne, g_nsv_normed, 0)
  var next: i64 = nsv_next_token(np)
  var T: i64 = nprompt
  g_nsv_ids[T]=next
  T=T+1
  var ngen: i64 = 1
  var stop: i64 = 0
  if next==NSV_EOS1 { stop=1; meta[4]=1 }
  if next==NSV_EOS2 { stop=1; meta[4]=1 }
  if stop == 0 { ep[1] = nsv_emit_piece(next, ep) }
  while stop == 0 {
      if ngen >= max_new { stop = 1 } else { if T >= NSV_MAXT { stop = 1 } else {
          let pos: i64 = T - 1
          dequant_row(g_nsv_buf, g_nsv_mt[4], g_nsv_mt[5], g_nsv_ids[pos], ne, g_nsv_x1, g_nsv_tmp)
          nsv_step(pos, mode)
          rmsnorm_gamma_row_q24(g_nsv_h1, g_nsv_gout, 0, ne, g_nsv_normed, 0)
          next = nsv_next_token(np)
          g_nsv_ids[T]=next
          T=T+1
          ngen=ngen+1
          if next==NSV_EOS1 { stop=1; meta[4]=1 }
          if next==NSV_EOS2 { stop=1; meta[4]=1 }
          if meta[4] == 0 { ep[1] = nsv_emit_piece(next, ep) }
      } }
  }
  let t1: i64 = sys_now_ms()
  meta[1]=ngen
  meta[2]=t1-t0
  if ngen > 0 { meta[3]=(t1-t0)/(nprompt+ngen) }
  return ep[1]
854}
855
856// ---- GPU ORACLE socket client (e4) -- ⚠BENCH LANE ONLY, NEVER THE RUN LANE (operator law
857// 2026-07-15: "sovereign from the hardware first byte up"; C/libcuda = benchmark oracle like
858// WARP/fxc/gcc). mode 2 is invoked ONLY by in-process gates (nx_gpu_embed_gate) to grade the
859// sovereign CPU path against the resident-weight GPU oracle; the daemon HTTP surface cannot
860// select it. The production /embed and /gen paths are 100%-sovereign CPU until the NishiLang
861// GPU driver (#22) exists. Protocol per token: send [pos=-(i+1):i64][x1: ne i64] ->
862// recv [normed: ne i64]. NO silent fallback: absent oracle = a loud error.
863func nsv_gwall(fd: i64, buf: *u8, count: i64) -> i64 {
  var off: i64 = 0
  while off < count {
      let q: *u8 = buf + off
      let w: i64 = sys_write(fd, q, count - off)
      if w <= 0 { return 0 - 1 }
      off = off + w
  }
  return 0
872}
873
874func nsv_grall(fd: i64, buf: *u8, count: i64) -> i64 {
  var off: i64 = 0
  while off < count {
      let q: *u8 = buf + off
      let r: i64 = sys_read(fd, q, count - off)
      if r <= 0 { return 0 - 1 }
      off = off + r
  }
  return 0
883}
884
885func nsv_gpu_connect() -> i64 {
  let fd: i64 = sys_socket(1, 1, 0)
  if fd < 0 { return 0 - 1 }
  let sa: *u8 = sys_mmap(128) as *u8
  sa[0] = 1 as u8
  sa[1] = 0 as u8
  let path: *u8 = "/home/elderwesto/nx_stage/nx_gpu.sock" as *u8
  var i: i64 = 0
  while path[i] != (0 as u8) { sa[2 + i] = path[i]; i = i + 1 }
  let cr: i64 = sys_connect(fd, sa, 110)
  if cr < 0 { sys_close(fd); return 0 - 2 }
  return fd
897}
898
899// EMBEDDING (jina-code-embeddings recipe, arXiv:2508.21290): a code/text embedding is the LAST-TOKEN
900// pooled FINAL-NORM hidden state == exactly g_nsv_normed after the sequential prefill. No ChatML, no
901// generation -- the caller prepends the task instruction prefix (nl2code/qa/code2code/...) to the text.
902// Fresh sequence by construction: prefill restarts at pos=0 (KV rows 0..n-1 overwritten; causal attention
903// never reads beyond pos -> no state leak between embeds; same semantics as the GPU serve pos==0).
904// outvec receives ne i64s (Q24 scale). Returns n_prompt_tokens (>0) or negative error.
905func nsv_embed(text: *u8, tlen: i64, mode: i64, outvec: *i64) -> i64 {
  if g_nsv_mt[6] != 1 { return 0-9 }
  if tlen < 1 { return 0-1 }
  if nsv_prompt_admit(tlen) != 0 { return 0-3 }
  let nprompt: i64 = tk_bpe_encode_b(g_nsv_buf, g_nsv_mt[0], g_nsv_mt[1], g_nsv_mt[2], g_nsv_mt[3], text, tlen, g_nsv_tokp, g_nsv_tokl, NSV_MAXIN, g_nsv_ids, NSV_MAXIN + NSV_CHATML_IDS)
  if nprompt == TK_REFUSED_TOO_LONG { return 0-3 }
  if nprompt < 1 { return 0-2 }
  if nprompt >= NSV_MAXT - 2 { return 0-3 }
  let ne: i64 = g_nsv_cfgA[1]
  if mode == 2 {
      // GPU backend: forward+norm run on the resident-weight server, bit-exact vs the CPU i8 path
      // (gate nx_gpu_embed_gate). Reply lands directly in outvec; the last token's reply stays.
      let gs: i64 = nsv_gpu_connect()
      if gs < 0 { return 0 - 10 }
      let posb: *i64 = sys_mmap(8) as *i64
      var k: i64 = 0
      while k < nprompt {
          dequant_row(g_nsv_buf, g_nsv_mt[4], g_nsv_mt[5], g_nsv_ids[k], ne, g_nsv_x1, g_nsv_tmp)
          posb[0] = 0 - (k + 1)
          if nsv_gwall(gs, posb as *u8, 8) != 0 { sys_close(gs); return 0 - 11 }
          if nsv_gwall(gs, g_nsv_x1 as *u8, ne * 8) != 0 { sys_close(gs); return 0 - 11 }
          if nsv_grall(gs, outvec as *u8, ne * 8) != 0 { sys_close(gs); return 0 - 12 }
          k = k + 1
      }
      sys_close(gs)
      return nprompt
  }
  var i: i64 = 0
  while i < nprompt {
      dequant_row(g_nsv_buf, g_nsv_mt[4], g_nsv_mt[5], g_nsv_ids[i], ne, g_nsv_x1, g_nsv_tmp)
      nsv_step(i, mode)
      i = i + 1
  }
  rmsnorm_gamma_row_q24(g_nsv_h1, g_nsv_gout, 0, ne, g_nsv_normed, 0)
  var j: i64 = 0
  while j < ne { outvec[j] = g_nsv_normed[j]; j = j + 1 }
  return nprompt
942}
943
944// ---- HTTP layer (in-process; the daemon shell only moves bytes) ----
945func nsv_resp(resb: *u8, rescap: i64, code: i64, ctype: *u8, body: *u8, blen: i64) -> i64 {
  var o: i64 = 0
  o = nsv_cat(resb, o, "HTTP/1.1 " as *u8)
  o = nsv_catn(resb, o, code)
  if code == 200 { o = nsv_cat(resb, o, " OK" as *u8) } else { o = nsv_cat(resb, o, " X" as *u8) }
  o = nsv_cat(resb, o, "\r\nContent-Type: " as *u8)
  o = nsv_cat(resb, o, ctype)
  o = nsv_cat(resb, o, "\r\nContent-Length: " as *u8)
  o = nsv_catn(resb, o, blen)
  o = nsv_cat(resb, o, "\r\nConnection: close\r\n\r\n" as *u8)
  if o + blen < rescap { o = nsv_catb(resb, o, body, blen) }
  return o
957}
958// JSON-escape ONE byte into dst at o; returns new o (early-return ladder -- no else-chains).
959func nsv_jesc1(dst: *u8, o: i64, c: i64) -> i64 {
  if c == 34 { dst[o]=92 as u8; dst[o+1]=34 as u8; return o+2 }
  if c == 92 { dst[o]=92 as u8; dst[o+1]=92 as u8; return o+2 }
  if c == 10 { dst[o]=92 as u8; dst[o+1]=110 as u8; return o+2 }
  if c == 13 { dst[o]=92 as u8; dst[o+1]=114 as u8; return o+2 }
  if c == 9 { dst[o]=92 as u8; dst[o+1]=116 as u8; return o+2 }
  if c < 32 { dst[o]=32 as u8; return o+1 }
  dst[o]=c as u8
  return o+1
968}
969// JSON-escape src[0,n) into dst at off
970func nsv_jesc(dst: *u8, off: i64, src: *u8, n: i64) -> i64 {
  var o: i64 = off
  var i: i64 = 0
  while i < n { o = nsv_jesc1(dst, o, src[i] & 0xff); i = i + 1 }
  return o
975}
976// find "key":  in body[0,n); return index just after the colon, -1 if absent.
977func nsv_jkey(body: *u8, n: i64, key: *u8) -> i64 {
  let kl: i64 = nsv_slen(key)
  var i: i64 = 0
  while i + kl + 3 < n {
      if body[i] == (34 as u8) {
          var k: i64 = 0
          var ok: i64 = 1
          while k < kl { if body[i+1+k] != key[k] { ok = 0; k = kl } else { k = k + 1 } }
          if ok == 1 { if body[i+1+kl] == (34 as u8) {
              var j: i64 = i + 2 + kl
              while j < n { if body[j] == (58 as u8) { return j + 1 } if body[j] == (34 as u8) { j = n } else { j = j + 1 } }
          } }
      }
      i = i + 1
  }
  return 0 - 1
993}
994// extract a JSON string value starting at/after p (skips ws to the opening quote); unescapes into dst; returns len (-1 if absent).
995func nsv_jstr(body: *u8, n: i64, p: i64, dst: *u8, dcap: i64) -> i64 {
  var i: i64 = p
  while i < n { if body[i] == (34 as u8) { i = i + 1; var o: i64 = 0
          while i < n {
              let c: i64 = body[i] & 0xff
              if c == 34 { return o }
              if c == 92 { if i + 1 < n {
                  let e: i64 = body[i+1] & 0xff
                  var w: i64 = e
                  if e == 110 { w = 10 }
                  if e == 116 { w = 9 }
                  if e == 114 { w = 13 }
                  if o < dcap { dst[o] = w as u8; o = o + 1 }
                  i = i + 2
              } else { i = i + 1 } } else {
                  if o < dcap { dst[o] = c as u8; o = o + 1 }
                  i = i + 1
              }
          }
          return 0 - 1
      }
      if body[i] == (32 as u8) { i = i + 1 } else { if body[i] == (9 as u8) { i = i + 1 } else { return 0 - 1 } }
  }
  return 0 - 1
1019}
1020// extract a JSON integer at/after p; returns value (def if absent).
1021func nsv_jint(body: *u8, n: i64, p: i64, def: i64) -> i64 {
  if p < 0 { return def }
  var i: i64 = p
  var skipping: i64 = 1
  while skipping == 1 {
      if i >= n { skipping = 0 } else {
          if body[i] == (32 as u8) { i = i + 1 } else { skipping = 0 }
      }
  }
  var v: i64 = 0
  var any: i64 = 0
  var going: i64 = 1
  while going == 1 {
      if i >= n { going = 0 } else {
          let c: i64 = body[i] & 0xff
          if c >= 48 { if c <= 57 { v = v * 10 + (c - 48); any = 1; i = i + 1 } else { going = 0 } } else { going = 0 }
      }
  }
  if any == 0 { return def }
  return v
1041}
1042
1043// the app page: served at GET /. NOTE: NishiLang literals cannot carry the two banned bytes, so the page uses
1044// rgb() colors, class selectors and no doctype -- functional, clean, dark.
1045func nsv_page(dst: *u8, cap: i64) -> i64 {
  var o: i64 = 0
  o = nsv_cat(dst, o, "<html><head><meta charset=\"utf-8\"><meta name=\"viewport\" content=\"width=device-width, initial-scale=1\"><title>Nishi No-Float LLM</title><style>body{font-family:system-ui,Segoe UI,Roboto,sans-serif;background:rgb(16,17,22);color:rgb(226,228,235);max-width:760px;margin:4vh auto;padding:0 20px;line-height:1.55}h1{font-size:1.4rem;margin-bottom:.2rem}p.sub{color:rgb(150,155,170);font-size:.9rem;margin-top:0}textarea{width:100%;min-height:90px;background:rgb(28,30,38);color:rgb(230,232,240);border:1px solid rgb(60,63,75);border-radius:8px;padding:10px;font-size:1rem;box-sizing:border-box}select,input{background:rgb(28,30,38);color:rgb(230,232,240);border:1px solid rgb(60,63,75);border-radius:6px;padding:6px 8px}button{background:rgb(58,110,235);color:white;border:none;border-radius:8px;padding:9px 18px;font-size:1rem;cursor:pointer}button:disabled{opacity:.5}.row{display:flex;gap:10px;align-items:center;margin:10px 0;flex-wrap:wrap}.out{white-space:pre-wrap;background:rgb(24,26,33);border:1px solid rgb(55,58,70);border-radius:8px;padding:12px;min-height:60px;margin-top:8px;font-size:1.02rem}.st{color:rgb(140,200,150);font-size:.85rem;min-height:1.2em}.ft{margin-top:2rem;color:rgb(120,124,138);font-size:.78rem}</style></head><body><h1>Nishi No-Float LLM</h1><p class=\"sub\">Qwen2.5-0.5B-Instruct on the sovereign 100 percent integer inference stack. Deterministic: same prompt, same bytes.</p><textarea class=\"pr\" placeholder=\"Type a prompt...\">The capital of France is</textarea><div class=\"row\"><label>tokens <input class=\"mn\" type=\"number\" value=\"24\" min=\"1\" max=\"96\" style=\"width:70px\"></label><label>mode <select class=\"md\"><option value=\"i32\">i32 lossless</option><option value=\"i8\">i8 fast</option></select></label><label>temp <select class=\"tp\"><option value=\"0\">0 (greedy, bit-exact)</option><option value=\"700\">0.7</option><option value=\"800\">0.8</option><option value=\"1000\">1.0</option><option value=\"1200\">1.2</option></select></label><label>seed <input class=\"sd\" type=\"number\" value=\"12345\" style=\"width:90px\"></label><button class=\"go\" onclick=\"go()\">Generate</button></div><div class=\"st\"></div><div class=\"out\"></div><div class=\"ft\">endpoints: POST /gen · GET /health · GET /api — served by nx_nofloat_serve (no gcc, no python, no float)</div><script>async function go(){var b=document.querySelector('.go');var st=document.querySelector('.st');var out=document.querySelector('.out');var t=document.querySelector('.pr').value;var mn=parseInt(document.querySelector('.mn').value);var md=document.querySelector('.md').value;var tp=parseInt(document.querySelector('.tp').value);var sd=parseInt(document.querySelector('.sd').value);b.disabled=true;st.textContent='thinking...';out.textContent=t;try{var r=await fetch('/gen',{method:'POST',headers:{'Content-Type':'application/json'},body:JSON.stringify({prompt:t,max_new:mn,mode:md,temp:tp,seed:sd,stream:1})});var rd=r.body.getReader();var dec=new TextDecoder();var acc='';var SEP=String.fromCharCode(10)+String.fromCharCode(10);var going=true;while(going){var ch=await rd.read();if(ch.done){going=false}else{acc=acc+dec.decode(ch.value,{stream:true});var parts=acc.split(SEP);acc=parts.pop();for(var pi=0;pi<parts.length;pi=pi+1){var ln=parts[pi];if(ln.indexOf('data: ')==0){var j=JSON.parse(ln.slice(6));if(j.piece){out.textContent=out.textContent+j.piece}if(j.done==1){if(j.ok==1){st.textContent=j.gen_tokens+' tokens · '+j.ms_per_token+' ms/token · '+md+(tp>0?' · temp '+(tp/1000)+' seed '+sd:' · greedy')+(j.eos==1?' · eos':'')}else{st.textContent='error '+j.err}}}}}}}catch(e){st.textContent='request failed: '+e}b.disabled=false;}</script></body></html>" as *u8)
  return o
1049}
1050
1051// parse a POST /gen request body into gp: [0]=prompt [1]=plen [2]=max_new [3]=mode(0=i32,1=i8)
1052// [8]=temp_pm(0=greedy) [9]=top_p_pm [10]=top_k [11]=seed [12]=stream(0/1). 0 ok, -1 bad.
1053func nsv_parse_gen(req: *u8, rn: i64, gp: *i64) -> i64 {
  var hb: i64 = 0 - 1
  var i: i64 = 0
  while i + 3 < rn {
      if req[i]==(13 as u8) { if req[i+1]==(10 as u8) { if req[i+2]==(13 as u8) { if req[i+3]==(10 as u8) { hb = i + 4; i = rn } } } }
      i = i + 1
  }
  if hb < 0 { return 0 - 1 }
  let bb: *u8 = ((req as i64) + hb) as *u8
  let bn: i64 = rn - hb
  let prompt: *u8 = sys_mmap(32768)
  let kp: i64 = nsv_jkey(bb, bn, "prompt" as *u8)
  var pl2: i64 = 0 - 1
  if kp >= 0 { pl2 = nsv_jstr(bb, bn, kp, prompt, 32760) }
  if pl2 < 1 { return 0 - 1 }
  gp[0]=prompt as i64
  gp[1]=pl2
  gp[2]=nsv_jint(bb, bn, nsv_jkey(bb, bn, "max_new" as *u8), 24)
  // mode: default is the route whose caches this serve actually built -- a resident-Q4_K serve has NO i32/i16
  // layer cache, so an explicit i32/i8 there is REFUSED (400) rather than dereferencing an absent cache; and
  // "q4k" on a serve that did not build the slot tables is refused the same way.
  var mode: i64 = NSV_MODE_I32
  if g_nsv_q4k == 1 { mode = NSV_MODE_Q4K }
  // an i8-only serve (nsv_init_i8: no i32 cache) defaults to i8 and REFUSES an explicit i32 -- mode 0 there would
  // read the absent cache (2026-09-16, the LAN rewrite engine runs i8-only beside other jobs in a 16 GB VM)
  if g_nsv_i8only == 1 { if g_nsv_q4k == 0 { mode = NSV_MODE_I8 } }
  let kd: i64 = nsv_jkey(bb, bn, "mode" as *u8)
  if kd >= 0 {
      let ms: *u8 = sys_mmap(16)
      let ml: i64 = nsv_jstr(bb, bn, kd, ms, 8)
      if ml == 2 { if ms[0]==(105 as u8) { if ms[1]==(56 as u8) { mode = NSV_MODE_I8 } } }
      if ml == 3 { if ms[0]==(105 as u8) { if ms[1]==(51 as u8) { if ms[2]==(50 as u8) { mode = NSV_MODE_I32 } } } }
      if ml == 3 { if ms[0]==(113 as u8) { if ms[1]==(52 as u8) { if ms[2]==(107 as u8) { mode = NSV_MODE_Q4K } } } }
      if ml == 2 { if ms[0]==(113 as u8) { if ms[1]==(56 as u8) { mode = NSV_MODE_Q4K } } }   // "q8": the resident lane over a Q8_0 gguf (search R0s)
      if g_nsv_q4k == 1 { if mode != NSV_MODE_Q4K { return 0 - 1 } }
      if g_nsv_q4k == 0 { if mode == NSV_MODE_Q4K { return 0 - 1 } }
      if g_nsv_i8only == 1 { if mode == NSV_MODE_I32 { return 0 - 1 } }
  }
  gp[3]=mode
  gp[8]=nsv_jint(bb, bn, nsv_jkey(bb, bn, "temp" as *u8), 0)
  gp[9]=nsv_jint(bb, bn, nsv_jkey(bb, bn, "top_p" as *u8), 950)
  gp[10]=nsv_jint(bb, bn, nsv_jkey(bb, bn, "top_k" as *u8), 64)
  gp[11]=nsv_jint(bb, bn, nsv_jkey(bb, bn, "seed" as *u8), 12345)
  // SLOT-COLLISION FIX (2026-07-15): "stream" used to land in gp[12], but the forge-era nsv_generate
  // contract made gp[12] = CHATML -- so every streamed request silently chatml-wrapped (caught by the
  // serve gate T6: streamed 'The capital of France is' returned chat-'Paris', 13 prompt tokens, not the
  // raw ' Paris' continuation, 5 tokens). Streaming discriminator now gp[13]; gp[12] = the EXPLICIT
  // "chat" body key (default 0 = raw) -- both transports get both behaviors, explicitly.
  gp[12]=nsv_jint(bb, bn, nsv_jkey(bb, bn, "chat" as *u8), 0)
  gp[13]=nsv_jint(bb, bn, nsv_jkey(bb, bn, "stream" as *u8), 0)
  return 0
1104}
1105// jina-code-embeddings task instruction prefixes (VERBATIM from the jina-code-embeddings-0.5b model card /
1106// arXiv:2508.21290 -- protocol constants, cited not invented). Task selected by (len, first byte):
1107// qa=2, code2code=9, code2completion=15, code2nl=7+'c', default nl2code. kq=1 -> query prefix, else passage.
1108func nsv_embed_prefix(task: *u8, tl: i64, kq: i64) -> *u8 {
  if tl == 2 {
      if kq == 1 { return "Find the most relevant answer given the following question:\n" as *u8 }
      return "Candidate answer:\n" as *u8
  }
  if tl == 9 {
      if kq == 1 { return "Find an equivalent code snippet given the following code snippet:\n" as *u8 }
      return "Candidate code snippet:\n" as *u8
  }
  if tl == 15 {
      if kq == 1 { return "Find the most relevant completion given the following start of code snippet:\n" as *u8 }
      return "Candidate completion:\n" as *u8
  }
  if tl == 7 { if task[0] == (99 as u8) {
      if kq == 1 { return "Find the most relevant comment given the following code snippet:\n" as *u8 }
      return "Candidate comment:\n" as *u8
  } }
  if kq == 1 { return "Find the most relevant code snippet given the following query:\n" as *u8 }
  return "Candidate code snippet:\n" as *u8
1127}
1128
1129// parse POST /embed body {"text","task","kind","mode"} -> ep: [0]=text ptr [1]=text len [2]=mode(1=i8 default)
1130// [3]=kind_q(1=query default) [4]=task ptr [5]=task len (0 = default nl2code). 0 ok, -1 bad (text required).
1131func nsv_parse_embed(req: *u8, rn: i64, ep: *i64) -> i64 {
  var hb: i64 = 0 - 1
  var i: i64 = 0
  while i + 3 < rn {
      if req[i]==(13 as u8) { if req[i+1]==(10 as u8) { if req[i+2]==(13 as u8) { if req[i+3]==(10 as u8) { hb = i + 4; i = rn } } } }
      i = i + 1
  }
  if hb < 0 { return 0 - 1 }
  let bb: *u8 = ((req as i64) + hb) as *u8
  let bn: i64 = rn - hb
  let text: *u8 = sys_mmap(8192)
  let kt: i64 = nsv_jkey(bb, bn, "text" as *u8)
  var tl: i64 = 0 - 1
  if kt >= 0 { tl = nsv_jstr(bb, bn, kt, text, 8100) }
  if tl < 1 { return 0 - 1 }
  ep[0]=text as i64
  ep[1]=tl
  var mode: i64 = 1
  let kd: i64 = nsv_jkey(bb, bn, "mode" as *u8)
  if kd >= 0 {
      let ms: *u8 = sys_mmap(16)
      let ml: i64 = nsv_jstr(bb, bn, kd, ms, 8)
      // NOTE: mode 2 (GPU oracle) is BENCH-ONLY and deliberately NOT reachable from the HTTP
      // surface -- the run lane is sovereign CPU end-to-end (operator law 2026-07-15: C/libcuda
      // = benchmark oracle, never the run lane). Gates drive mode 2 in-process.
      if ml == 3 { mode = 0 }
  }
  ep[2]=mode
  var kq: i64 = 1
  let kk: i64 = nsv_jkey(bb, bn, "kind" as *u8)
  if kk >= 0 {
      let ks: *u8 = sys_mmap(16)
      let kl: i64 = nsv_jstr(bb, bn, kk, ks, 12)
      if kl > 0 { if ks[0]==(112 as u8) { kq = 0 } }
  }
  ep[3]=kq
  let task: *u8 = sys_mmap(32)
  var tkl: i64 = 0
  let kta: i64 = nsv_jkey(bb, bn, "task" as *u8)
  if kta >= 0 {
      let r: i64 = nsv_jstr(bb, bn, kta, task, 24)
      if r > 0 { tkl = r }
  }
  ep[4]=task as i64
  ep[5]=tkl
  return 0
1177}
1178
1179// STREAMING route: if the request is POST /gen with "stream":1, serve it as Server-Sent Events DIRECTLY on
1180// fd (headers -> start frame -> one data frame per token from nsv_generate -> done frame with meta) and
1181// return 1. Any other request returns 0 (caller falls through to the buffered nsv_handle). The daemon calls
1182// this FIRST; the gate drives it with a file fd -- same bytes either way.
1183func nsv_handle_stream(fd: i64, req: *u8, rn: i64) -> i64 {
  var is_post: i64 = 0
  if rn > 5 { if req[0]==(80 as u8) { is_post = 1 } }
  if is_post == 0 { return 0 }
  if req[6] != (103 as u8) { return 0 }
  let gp: *i64 = sys_mmap(16*8) as *i64
  let prc: i64 = nsv_parse_gen(req, rn, gp)
  if prc != 0 { return 0 }
  if gp[13] != 1 { return 0 }
  let hdrs: *u8 = "HTTP/1.1 200 OK\r\nContent-Type: text/event-stream\r\nCache-Control: no-cache\r\nConnection: close\r\n\r\n" as *u8
  var hl: i64 = nsv_slen(hdrs)
  var w: i64 = 0
  while w < hl { let k1: i64 = sys_write(fd, ((hdrs as i64)+w) as *u8, hl-w); if k1 <= 0 { w = hl } else { w = w + k1 } }
  let text: *u8 = sys_mmap(65536)
  let meta: *i64 = sys_mmap(8*8) as *i64
  gp[4]=text as i64
  gp[5]=65000
  gp[6]=meta as i64
  gp[7]=fd
  let tl: i64 = nsv_generate(gp)
  let fin: *u8 = sys_mmap(1024)
  var fo: i64 = 0
  if tl < 0 {
      fo = nsv_cat(fin, 0, "data: {\"done\":1,\"ok\":0,\"err\":" as *u8)
      fo = nsv_catn(fin, fo, meta[5])
      fo = nsv_cat(fin, fo, "}\n\n" as *u8)
  } else {
      fo = nsv_cat(fin, 0, "data: {\"done\":1,\"ok\":1,\"prompt_tokens\":" as *u8)
      fo = nsv_catn(fin, fo, meta[0])
      fo = nsv_cat(fin, fo, ",\"gen_tokens\":" as *u8)
      fo = nsv_catn(fin, fo, meta[1])
      fo = nsv_cat(fin, fo, ",\"ms_per_token\":" as *u8)
      fo = nsv_catn(fin, fo, meta[3])
      fo = nsv_cat(fin, fo, ",\"prefill_ms\":" as *u8)
      fo = nsv_catn(fin, fo, meta[6])
      fo = nsv_cat(fin, fo, ",\"eos\":" as *u8)
      fo = nsv_catn(fin, fo, meta[4])
      fo = nsv_cat(fin, fo, "}\n\n" as *u8)
  }
  w = 0
  while w < fo { let k2: i64 = sys_write(fd, ((fin as i64)+w) as *u8, fo-w); if k2 <= 0 { w = fo } else { w = w + k2 } }
  return 1
1225}
1226
1227// route + serve one request. returns response length in resb.
1228func nsv_handle(req: *u8, rn: i64, resb: *u8, rescap: i64) -> i64 {
  let body: *u8 = sys_mmap(65536)
  var blen: i64 = 0
  // method + path
  var is_get: i64 = 0
  var is_post: i64 = 0
  if rn > 4 { if req[0]==(71 as u8) { is_get=1 } }
  if rn > 5 { if req[0]==(80 as u8) { is_post=1 } }
  var ps: i64 = 4
  if is_post == 1 { ps = 5 }
  var pe: i64 = ps
  var scanning: i64 = 1
  while scanning == 1 {
      if pe >= rn { scanning = 0 } else {
          if req[pe]==(32 as u8) { scanning = 0 } else { pe = pe + 1 }
      }
  }
  let plen: i64 = pe - ps
  // GET /
  if is_get == 1 { if plen == 1 { if req[ps]==(47 as u8) {
      let page: *u8 = sys_mmap(16384)
      let pn: i64 = nsv_page(page, 16384)
      return nsv_resp(resb, rescap, 200, "text/html; charset=utf-8" as *u8, page, pn)
  } } }
  // GET /health
  if is_get == 1 { if plen == 7 { if req[ps+1]==(104 as u8) {
      var o: i64 = 0
      o = nsv_cat(body, o, "{\"ok\":" as *u8)
      o = nsv_catn(body, o, g_nsv_mt[6])
      o = nsv_cat(body, o, ",\"model\":\"" as *u8)
      o = nsv_jesc(body, o, g_nsv_mpath, nsv_slen(g_nsv_mpath))
      if g_nsv_q4k == 1 { o = nsv_cat(body, o, "\",\"modes\":[\"q4k\"],\"route\":\"q4k-resident\",\"maxt\":" as *u8) } else {
          o = nsv_cat(body, o, "\",\"modes\":[\"i32\",\"i8\"],\"route\":\"dequant-once-i32+i8\",\"maxt\":" as *u8) }
      o = nsv_catn(body, o, NSV_MAXT)
      o = nsv_cat(body, o, ",\"init_ms\":" as *u8)
      o = nsv_catn(body, o, g_nsv_mt[7])
      if g_nsv_q4k == 1 {
          // per-route decode profile (cumulative since init; diff two reads around one generation): where a token's
          // time goes is a measurement here, never a guess in a seat
          o = nsv_cat(body, o, ",\"prof\":{\"q4k_gemm_ns\":" as *u8); o = nsv_catn(body, o, nq_prof_get(NQ_PROF_Q4K_NS))
          o = nsv_cat(body, o, ",\"q4k_gemm_calls\":" as *u8); o = nsv_catn(body, o, nq_prof_get(NQ_PROF_Q4K_CALLS))
          o = nsv_cat(body, o, ",\"i16_ns\":" as *u8); o = nsv_catn(body, o, nq_prof_get(NQ_PROF_I16_NS))
          o = nsv_cat(body, o, ",\"i16_calls\":" as *u8); o = nsv_catn(body, o, nq_prof_get(NQ_PROF_I16_CALLS))
          o = nsv_cat(body, o, ",\"inplace_tensors\":" as *u8); o = nsv_catn(body, o, g_nsv_q4st[0])
          o = nsv_cat(body, o, ",\"fallback_i16_tensors\":" as *u8); o = nsv_catn(body, o, g_nsv_q4st[1])
          o = nsv_cat(body, o, "}" as *u8)
      }
      o = nsv_cat(body, o, "}" as *u8)
      return nsv_resp(resb, rescap, 200, "application/json" as *u8, body, o)
  } } }
  // GET /api
  if is_get == 1 { if plen == 4 { if req[ps+1]==(97 as u8) {
      let o: i64 = nsv_cat(body, 0, "{\"organ\":\"nx_nofloat_serve\",\"endpoints\":[{\"m\":\"POST\",\"p\":\"/gen\",\"body\":{\"prompt\":\"str\",\"max_new\":\"int 1-96 (default 24)\",\"mode\":\"i32|i8|q4k (q4k only on a route=q4k-resident serve; i32/i8 refused there)\",\"stream\":\"0|1 SSE\",\"chat\":\"0|1 ChatML wrap\"}},{\"m\":\"POST\",\"p\":\"/embed\",\"body\":{\"text\":\"str required <=8100B\",\"task\":\"nl2code|qa|code2code|code2nl|code2completion (default nl2code)\",\"kind\":\"query|passage (default query)\",\"mode\":\"i8|i32 (default i8)\"},\"returns\":\"dim=896 q24 int vector (last-token pooled final-norm hidden, arXiv 2508.21290)\"},{\"m\":\"GET\",\"p\":\"/health\"},{\"m\":\"GET\",\"p\":\"/\"}],\"stack\":\"sovereign 100pct-integer Qwen2.5-0.5B, dequant-once i32 lossless + i8 SIMD fast, KV-cached greedy\"}" as *u8)
      return nsv_resp(resb, rescap, 200, "application/json" as *u8, body, o)
  } } }
  // POST /gen
  if is_post == 1 { if plen == 4 { if req[ps+1]==(103 as u8) {
      let gp: *i64 = sys_mmap(16*8) as *i64
      let prc: i64 = nsv_parse_gen(req, rn, gp)
      if prc != 0 {
          let o: i64 = nsv_cat(body, 0, "{\"ok\":0,\"err\":1}" as *u8)
          return nsv_resp(resb, rescap, 400, "application/json" as *u8, body, o)
      }
      let text: *u8 = sys_mmap(65536)
      let meta: *i64 = sys_mmap(8*8) as *i64
      gp[4]=text as i64
      gp[5]=65000
      gp[6]=meta as i64
      gp[7]=0-1
      let mode: i64 = gp[3]
      let tl: i64 = nsv_generate(gp)
      if tl < 0 {
          var o: i64 = nsv_cat(body, 0, "{\"ok\":0,\"err\":" as *u8)
          o = nsv_catn(body, o, meta[5])
          o = nsv_cat(body, o, "}" as *u8)
          return nsv_resp(resb, rescap, 400, "application/json" as *u8, body, o)
      }
      var o: i64 = 0
      o = nsv_cat(body, o, "{\"ok\":1,\"mode\":\"" as *u8)
      if mode == NSV_MODE_Q4K { o = nsv_cat(body, o, "q4k" as *u8) } else {
          if mode == 1 { o = nsv_cat(body, o, "i8" as *u8) } else { o = nsv_cat(body, o, "i32" as *u8) } }
      o = nsv_cat(body, o, "\",\"prompt_tokens\":" as *u8)
      o = nsv_catn(body, o, meta[0])
      o = nsv_cat(body, o, ",\"gen_tokens\":" as *u8)
      o = nsv_catn(body, o, meta[1])
      o = nsv_cat(body, o, ",\"ms_total\":" as *u8)
      o = nsv_catn(body, o, meta[2])
      o = nsv_cat(body, o, ",\"ms_per_token\":" as *u8)
      o = nsv_catn(body, o, meta[3])
      o = nsv_cat(body, o, ",\"prefill_ms\":" as *u8)
      o = nsv_catn(body, o, meta[6])
      o = nsv_cat(body, o, ",\"prefill\":\"" as *u8)
      if g_nsv_prefill_batched == 1 { o = nsv_cat(body, o, "batched" as *u8) } else { o = nsv_cat(body, o, "sequential" as *u8) }
      o = nsv_cat(body, o, "\",\"eos\":" as *u8)
      o = nsv_catn(body, o, meta[4])
      o = nsv_cat(body, o, ",\"temp\":" as *u8)
      o = nsv_catn(body, o, gp[8])
      o = nsv_cat(body, o, ",\"seed\":" as *u8)
      o = nsv_catn(body, o, gp[11])
      o = nsv_cat(body, o, ",\"text\":\"" as *u8)
      o = nsv_jesc(body, o, text, tl)
      o = nsv_cat(body, o, "\"}" as *u8)
      return nsv_resp(resb, rescap, 200, "application/json" as *u8, body, o)
  } } }
  // POST /embed (jina-code-embeddings recipe arXiv:2508.21290: the embedding IS the last-token pooled
  // final-norm hidden state; instruction prefix prepended server-side). Returns the raw Q24 int vector --
  // cosine/ranking is the caller's (or the index organ's) job, integer math end to end.
  if is_post == 1 { if plen == 6 { if req[ps+1]==(101 as u8) {
      if g_nsv_mt[6] != 1 {
          let o: i64 = nsv_cat(body, 0, "{\"ok\":0,\"err\":9}" as *u8)
          return nsv_resp(resb, rescap, 503, "application/json" as *u8, body, o)
      }
      let ep: *i64 = sys_mmap(8*8) as *i64
      let erc: i64 = nsv_parse_embed(req, rn, ep)
      if erc != 0 {
          let o: i64 = nsv_cat(body, 0, "{\"ok\":0,\"err\":1}" as *u8)
          return nsv_resp(resb, rescap, 400, "application/json" as *u8, body, o)
      }
      let pre: *u8 = nsv_embed_prefix(ep[4] as *u8, ep[5], ep[3])
      let txt: *u8 = sys_mmap(NSV_MAXIN)
      var l: i64 = nsv_cat(txt, 0, pre)
      l = nsv_catb(txt, l, ep[0] as *u8, ep[1])
      let ne: i64 = g_nsv_cfgA[1]
      let vec: *i64 = sys_mmap(ne*8) as *i64
      let t0: i64 = sys_now_ms()
      let n: i64 = nsv_embed(txt, l, ep[2], vec)
      let t1: i64 = sys_now_ms()
      if n < 1 {
          var o: i64 = nsv_cat(body, 0, "{\"ok\":0,\"err\":" as *u8)
          o = nsv_catn(body, o, n)
          o = nsv_cat(body, o, "}" as *u8)
          return nsv_resp(resb, rescap, 400, "application/json" as *u8, body, o)
      }
      var o: i64 = 0
      o = nsv_cat(body, o, "{\"ok\":1,\"dim\":" as *u8)
      o = nsv_catn(body, o, ne)
      o = nsv_cat(body, o, ",\"ntok\":" as *u8)
      o = nsv_catn(body, o, n)
      o = nsv_cat(body, o, ",\"ms\":" as *u8)
      o = nsv_catn(body, o, t1 - t0)
      o = nsv_cat(body, o, ",\"scale\":\"q24\",\"mode\":\"" as *u8)
      if ep[2] == 1 { o = nsv_cat(body, o, "i8" as *u8) } else { o = nsv_cat(body, o, "i32" as *u8) }
      o = nsv_cat(body, o, "\",\"vec\":[" as *u8)
      var vi: i64 = 0
      while vi < ne {
          if vi > 0 { o = nsv_cat(body, o, "," as *u8) }
          o = nsv_catn(body, o, vec[vi])
          vi = vi + 1
      }
      o = nsv_cat(body, o, "]}" as *u8)
      return nsv_resp(resb, rescap, 200, "application/json" as *u8, body, o)
  } } }
  let o: i64 = nsv_cat(body, 0, "{\"ok\":0,\"err\":404}" as *u8)
  return nsv_resp(resb, rescap, 404, "application/json" as *u8, body, o)
1382}
nx_nofloat_serve_core.nx source

`nx_nofloat_serve_core.nx` source
