`nx_lsp.nx` source

↩ module page · 1756 lines · 71816 B
1// ============================================================================================
2// nx_lsp.nx -- LN11: THE NISHILANG LANGUAGE SERVER. LSP 3.17 over stdio, JSON-RPC 2.0,
3// Content-Length framed.
4//
5// THE ARCHITECTURE BAR (lang.plan, rust-analyzer 2020 architecture note): the front end is ONE
6// query surface serving the IDE, the CLI and agents -- a language server that ships a SECOND parser
7// is a second source of truth that drifts from the compiler, and every drift is a diagnostic the
8// editor shows and the build does not (or worse, the reverse). So this organ contains NO lexer, NO
9// parser and NO diagnostic text of its own. It calls, verbatim:
10//     nx_import.nx     expand_imports / expand_ctx_enable_linemap   (the import closure + LineMap)
11//     nx_tokenizer.nx  lex_source                                    (the tokens)
12//     nx_parse.nx      parse_module / nx_diag_set_source / nx_diag_set_linemap
13//                                                                    (the caret + did-you-mean
14//                                                                     diagnostics, live since 08-05)
15// Every message a user sees in their editor is a byte the compiler wrote.
16//
17// WHY A FORK PER ANALYSIS. The compiler's diagnostic sites sys_exit(2) by design -- recovery stops
18// at NX_DIAG_MAX_ERRS and every parser DESYNC site is fatal on purpose (past a desync each further
19// diagnostic points at innocent code). Calling parse_module in-process would therefore let one bad
20// keystroke KILL THE LANGUAGE SERVER. The analysis runs in a forked child with fd 2 redirected to a
21// per-document artifact; the parent survives sys_exit, SIGSEGV and SIGALRM alike and reports WHICH.
22// This is the same isolation rust-analyzer gives flycheck, reached for the same reason.
23//
24// WHY A SHADOW FILE. expand_imports resolves an import by walking UP from the IMPORTING file's own
25// directory. An unsaved buffer analysed from anywhere else would resolve a DIFFERENT import set --
26// the measured-a-different-subject defect, and it would show up as a flood of phantom "I do not know
27// the name" errors for every symbol the real build resolves fine. So the dirty buffer is written to
28// <document-directory>/<shadow-dir-name>/<basename>: exactly one hop below the document, so the
29// resolver walks the identical chain. When the directory cannot be created the server analyses the
30// SAVED file and SAYS SO over window/logMessage rather than silently reporting stale diagnostics.
31//
32// TRUTHFUL CAPABILITIES. initialize advertises textDocumentSync=Full, definitionProvider and
33// hoverProvider and NOTHING ELSE. A server that advertises a capability it does not serve is the
34// stub-carrying-the-contract-name defect wearing an editor's clothes: the client greys out its own
35// working fallback and the user gets silence instead of a feature.
36//
37// POSITIONS ARE UTF-16 CODE UNITS, as LSP requires by default. The compiler counts BYTES, so every
38// column crosses lsp_u16_of_bytes / lsp_bytes_of_u16. Getting this wrong is invisible in ASCII and
39// silently off-by-N in every file with an accent in a comment.
40//
41// DECLARED IMPRECISION (read this before trusting a column):
42//   1. lex_source pre-expands @macro bodies BEFORE tokenising, while the caret is drawn from the
43//      pre-expansion buffer. In a document that USES an arg macro the caret column can therefore be
44//      the compiler's own -- this organ inherits that behaviour rather than inventing a second
45//      answer, and a fix belongs in nx_tokenizer, not here.
46//   2. Diagnostics whose location the LineMap cannot resolve to THIS document are COUNTED and
47//      logged, never published. A diagnostic attributed to the wrong file is worse than none --
48//      nx_parse's own nx_diag_loc says exactly this and falls back rather than guessing.
49//   3. Imports are read from DISK. An unsaved edit in file A is not seen while analysing file B.
50//
51// usage: nx_lsp serve                 LSP over stdin/stdout (the editor entry point)
52//        nx_lsp diag <file.nx>        one-shot: the publishDiagnostics payload, unframed, to stdout
53//        nx_lsp symbols <file.nx>     one-shot: the symbol index artifact, to stdout
54// exit:  0 ok | 1 exit-without-shutdown | 3 usage | 4 config refusal
55// license_tier: ORIGINAL   No hardware writes (Rule 26).
56// ============================================================================================
57
58import "nx_syscalls.nx"
59import "nx_types.nx"
60import "nx_lex_kinds.nx"
61import "nx_ir.nx"
62import "nx_linemap.nx"
63import "nx_tokenizer.nx"
64import "nx_parse.nx"
65import "nx_import.nx"
66import "nx_json_lib.nx"
67import "nx_lineconf_lib.nx"
68
69// ---- byte values. NishiLang has no character literal, so every byte this file compares against is
70// ---- named once here. These are FACTS about ASCII, not thresholds -- nothing here is tunable.
71const LSP_BS:        i64 = 8
72const LSP_TAB:       i64 = 9
73const LSP_LF:        i64 = 10
74const LSP_FF:        i64 = 12
75const LSP_CR:        i64 = 13
76const LSP_SPACE:     i64 = 32
77const LSP_QUOTE:     i64 = 34
78const LSP_PCT:       i64 = 37
79const LSP_COMMA:     i64 = 44
80const LSP_MINUS:     i64 = 45
81const LSP_DOT:       i64 = 46
82const LSP_SLASH:     i64 = 47
83const LSP_D0:        i64 = 48
84const LSP_D9:        i64 = 57
85const LSP_COLON:     i64 = 58
86const LSP_UA:        i64 = 65
87const LSP_UF:        i64 = 70
88const LSP_UZ:        i64 = 90
89const LSP_BSLASH:    i64 = 92
90const LSP_CARET:     i64 = 94
91const LSP_USCORE:    i64 = 95
92const LSP_LA:        i64 = 97
93const LSP_LF_HEX:    i64 = 102
94const LSP_LZ:        i64 = 122
95const LSP_RBRACE:    i64 = 125
96const LSP_TILDE:     i64 = 126
97
98const LSP_B10:       i64 = 10
99const LSP_B16:       i64 = 16
100const LSP_WORD:      i64 = 8
101const LSP_NUMBUF:    i64 = 32
102
103// UTF-8 lead-byte boundaries, and the one codepoint class that costs TWO UTF-16 code units.
104const LSP_U8_2:      i64 = 192
105const LSP_U8_3:      i64 = 224
106const LSP_U8_4:      i64 = 240
107
108// LSP wire enums (specification values, not choices).
109const LSP_SYNC_FULL: i64 = 1
110const LSP_SEV_ERROR: i64 = 1
111const LSP_SEV_WARN:  i64 = 2
112const LSP_MSG_ERROR: i64 = 1
113const LSP_MSG_WARN:  i64 = 2
114const LSP_MSG_INFO:  i64 = 3
115const LSP_RPC_METHOD_NOT_FOUND: i64 = 0 - 32601
116
117const LSP_EXIT_OK:          i64 = 0
118const LSP_EXIT_NO_SHUTDOWN: i64 = 1
119const LSP_EXIT_USAGE:       i64 = 3
120const LSP_EXIT_CONF:        i64 = 4
121
122// A JSON escape of ONE byte is at most six bytes -- backslash u 0 0 X X. That is arithmetic about
123// the JSON grammar, so every response buffer below is sized as (input bytes * this) + scaffolding
124// rather than guessed. LSP_SCAFFOLD_BYTES / LSP_PER_DIAG_BYTES bound the FIXED literal text this
125// file emits around the payload; they are countable by reading the emitters, and an underestimate
126// cannot truncate silently because every appender sets g_ovf and the send path REFUSES on it.
127const LSP_JSON_ESC_MAX:  i64 = 6
128const LSP_SCAFFOLD_BYTES: i64 = 2048
129const LSP_PER_DIAG_BYTES: i64 = 256
130const LSP_URI_ESC_MAX:    i64 = 3
131// "Content-Length: " + 20 decimal digits + CRLFCRLF fits well inside this. Structural.
132const LSP_OUTHDR_BYTES:   i64 = 64
133const LSP_ID_BYTES:       i64 = 256
134const LSP_SYMROW_BYTES:   i64 = 192
135const LSP_KINDBUF:        i64 = 32
136const LSP_NAMEBUF:        i64 = 128
137
138// ---- configuration. Every one of these is a row in knowledge/nx_lsp.conf and a MISSING ROW IS A
139// ---- REFUSAL (exit 4) naming the row -- there is no default to silently inherit.
140static g_hdr_max: i64
141static g_timeout_s: i64
142static g_max_docs: i64
143static g_uri_bytes: i64
144static g_expand_reserve: i64
145static g_scratch: *u8
146static g_shadow_name: *u8
147
148// ---- document store
149static g_ndocs: i64
150static g_doc_uri: *u8
151static g_doc_path: *u8
152static g_doc_shadow: *u8
153static g_doc_txt: *i64
154static g_doc_len: *i64
155static g_doc_live: *i64
156
157static g_shutdown: i64
158static g_ovf: i64
159
160// ============================================================================================
161// SECTION 1 -- bytes out, bytes in
162// ============================================================================================
163
164func lsp_slen(s: *u8) -> i64 { var n: i64 = 0; while s[n] != (0 as u8) { n = n + 1 } return n }
165
166// FORWARD DECLARATIONS. Both are used above their definition; the estate's own front end declares
167// forward like this (nx_parse parse_module_const, nx_import expand_imports_inner) rather than
168// reordering a file to satisfy a one-pass reader.
169func lsp_dec_at(b: *u8, s: i64, e: i64) -> i64;
170func lsp_slen_bounded(b: *u8, cap: i64) -> i64;
171
172func lsp_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
180}
181
182// A short write on a pipe is normal, not an error. Loop or lose the tail of every large payload.
183func lsp_write_all(fd: i64, buf: *u8, n: i64) -> i64 {
  var off: i64 = 0
  var run: i64 = 1
  while run == 1 {
      if off >= n { run = 0 } else {
          let w: i64 = sys_write(fd, ((buf as i64) + off) as *u8, n - off)
          if w <= 0 { run = 0 } else { off = off + w }
      }
  }
  return off
193}
194
195func lsp_log(s: *u8) -> i64 { lsp_write_all(2, s, lsp_slen(s)); return 0 }
196
197func lsp_lognum(v: i64) -> i64 {
  let b: *u8 = sys_mmap(LSP_NUMBUF)
  let t: *u8 = sys_mmap(LSP_NUMBUF)
  var m: i64 = v
  var p: i64 = 0
  if m < 0 { b[p] = LSP_MINUS as u8; p = p + 1; m = 0 - m }
  var k: i64 = 0
  if m == 0 { t[0] = LSP_D0 as u8; k = 1 }
  while m > 0 { t[k] = (LSP_D0 + (m % LSP_B10)) as u8; m = m / LSP_B10; k = k + 1 }
  var i: i64 = 0
  while i < k { b[p] = t[k - 1 - i]; p = p + 1; i = i + 1 }
  lsp_write_all(2, b, p)
  return 0
210}
211
212// ---- bounded appenders. EVERY clip sets g_ovf; nothing that overflowed is ever sent, because a
213// ---- truncated JSON message is not a smaller message, it is a protocol violation the client
214// ---- reports as a server crash.
215func lsp_put(d: *u8, o: i64, cap: i64, c: i64) -> i64 {
  if o < cap { d[o] = c as u8; return o + 1 }
  g_ovf = 1
  return o
219}
220
221func lsp_str_into(d: *u8, o: i64, cap: i64, s: *u8) -> i64 {
  var p: i64 = o
  var i: i64 = 0
  while s[i] != (0 as u8) { p = lsp_put(d, p, cap, s[i] as i64); i = i + 1 }
  return p
226}
227
228func lsp_bytes_into(d: *u8, o: i64, cap: i64, s: *u8, n: i64) -> i64 {
  var p: i64 = o
  var i: i64 = 0
  while i < n { p = lsp_put(d, p, cap, s[i] as i64); i = i + 1 }
  return p
233}
234
235func lsp_num_into(d: *u8, o: i64, cap: i64, v: i64) -> i64 {
  var p: i64 = o
  var m: i64 = v
  if m < 0 { p = lsp_put(d, p, cap, LSP_MINUS); m = 0 - m }
  let t: *u8 = sys_mmap(LSP_NUMBUF)
  var k: i64 = 0
  if m == 0 { t[0] = LSP_D0 as u8; k = 1 }
  while m > 0 { t[k] = (LSP_D0 + (m % LSP_B10)) as u8; m = m / LSP_B10; k = k + 1 }
  var i: i64 = 0
  while i < k { p = lsp_put(d, p, cap, t[k - 1 - i] as i64); i = i + 1 }
  return p
246}
247
248func lsp_hexdig(v: i64) -> i64 {
  if v < LSP_B10 { return LSP_D0 + v }
  return LSP_LA + (v - LSP_B10)
251}
252
253// JSON string CONTENT (callers supply the quotes). UTF-8 above 0x1F passes through untouched, which
254// is what the spec wants: JSON is UTF-8 and escaping non-ASCII would only cost bytes.
255func lsp_jstr_into(d: *u8, o: i64, cap: i64, s: *u8, n: i64) -> i64 {
  var p: i64 = o
  var i: i64 = 0
  while i < n {
      let c: i64 = s[i] as i64
      if c == LSP_QUOTE { p = lsp_str_into(d, p, cap, "\\\"" as *u8) } else {
      if c == LSP_BSLASH { p = lsp_str_into(d, p, cap, "\\\\" as *u8) } else {
      if c == LSP_LF { p = lsp_str_into(d, p, cap, "\\n" as *u8) } else {
      if c == LSP_CR { p = lsp_str_into(d, p, cap, "\\r" as *u8) } else {
      if c == LSP_TAB { p = lsp_str_into(d, p, cap, "\\t" as *u8) } else {
      if c < LSP_SPACE {
          p = lsp_str_into(d, p, cap, "\\u00" as *u8)
          p = lsp_put(d, p, cap, lsp_hexdig(c / LSP_B16))
          p = lsp_put(d, p, cap, lsp_hexdig(c % LSP_B16))
      } else {
          p = lsp_put(d, p, cap, c)
      } } } } } }
      i = i + 1
  }
  return p
275}
276
277func lsp_jstrz_into(d: *u8, o: i64, cap: i64, s: *u8) -> i64 {
  return lsp_jstr_into(d, o, cap, s, lsp_slen(s))
279}
280
281// ============================================================================================
282// SECTION 2 -- configuration (Rule 20: validate at startup, never on first request)
283// ============================================================================================
284
285func lsp_conf_int(key: *u8) -> i64 {
  let v: i64 = lcf_int_of("knowledge/nx_lsp.conf" as *u8, key)
  if v == LCF_MISS {
      lsp_log("nx_lsp: REFUSED at startup -- knowledge/nx_lsp.conf has no numeric row named " as *u8)
      lsp_log(key)
      lsp_log(". A missing bound is a refusal, never a default.\n" as *u8)
      sys_exit(LSP_EXIT_CONF)
  }
  return v
294}
295
296func lsp_conf_str(key: *u8) -> *u8 {
  let out: *u8 = sys_mmap(SYS_PATH_MAX)
  let r: i64 = lcf_str_of("knowledge/nx_lsp.conf" as *u8, key, out, SYS_PATH_MAX)
  if r <= 0 {
      lsp_log("nx_lsp: REFUSED at startup -- knowledge/nx_lsp.conf has no string row named " as *u8)
      lsp_log(key)
      lsp_log(". A missing path is a refusal, never a default.\n" as *u8)
      sys_exit(LSP_EXIT_CONF)
  }
  return out
306}
307
308func lsp_cfg_load() -> i64 {
  g_hdr_max        = lsp_conf_int("header-bytes-max" as *u8)
  g_timeout_s      = lsp_conf_int("analysis-timeout-s" as *u8)
  g_max_docs       = lsp_conf_int("max-open-docs" as *u8)
  g_uri_bytes      = lsp_conf_int("doc-uri-bytes" as *u8)
  g_expand_reserve = lsp_conf_int("expand-reserve-bytes" as *u8)
  g_scratch        = lsp_conf_str("scratch-dir" as *u8)
  g_shadow_name    = lsp_conf_str("shadow-dir-name" as *u8)
  sys_mkdir(g_scratch, MODE_0755)
  g_doc_uri    = sys_mmap(g_max_docs * g_uri_bytes + LSP_WORD)
  g_doc_path   = sys_mmap(g_max_docs * SYS_PATH_MAX + LSP_WORD)
  g_doc_shadow = sys_mmap(g_max_docs * SYS_PATH_MAX + LSP_WORD)
  g_doc_txt    = sys_mmap(g_max_docs * LSP_WORD + LSP_WORD) as *i64
  g_doc_len    = sys_mmap(g_max_docs * LSP_WORD + LSP_WORD) as *i64
  g_doc_live   = sys_mmap(g_max_docs * LSP_WORD + LSP_WORD) as *i64
  g_ndocs = 0
  g_shutdown = 0
  g_ovf = 0
  return 0
327}
328
329// ============================================================================================
330// SECTION 3 -- positions. LSP characters are UTF-16 code units; the compiler counts bytes.
331// ============================================================================================
332
333// byte offset of the start of 0-based line `line0`, or -1 when the document has no such line.
334func lsp_line_start(t: *u8, n: i64, line0: i64) -> i64 {
  if line0 <= 0 { return 0 }
  var cur: i64 = 0
  var i: i64 = 0
  var found: i64 = 0 - 1
  var run: i64 = 1
  while run == 1 {
      if i >= n { run = 0 } else {
          if t[i] == (LSP_LF as u8) {
              cur = cur + 1
              if cur == line0 { found = i + 1; run = 0 }
          }
          i = i + 1
      }
  }
  return found
350}
351
352func lsp_line_end(t: *u8, n: i64, start: i64) -> i64 {
  var e: i64 = start
  var run: i64 = 1
  while run == 1 {
      if e >= n { run = 0 } else {
          if t[e] == (LSP_LF as u8) { run = 0 } else { e = e + 1 }
      }
  }
  return e
361}
362
363// bytes -> UTF-16 code units within one line. A 4-byte UTF-8 sequence is a surrogate PAIR: 2 units.
364func lsp_u16_of_bytes(lp: *u8, n: i64, byte_off: i64) -> i64 {
  var u: i64 = 0
  var i: i64 = 0
  var run: i64 = 1
  while run == 1 {
      if i >= byte_off { run = 0 } else {
          if i >= n { run = 0 } else {
              let c: i64 = lp[i] as i64
              var adv: i64 = 1
              var units: i64 = 1
              if c >= LSP_U8_4 { adv = 4; units = 2 } else {
              if c >= LSP_U8_3 { adv = 3 } else {
              if c >= LSP_U8_2 { adv = 2 } } }
              u = u + units
              i = i + adv
          }
      }
  }
  return u
383}
384
385func lsp_bytes_of_u16(lp: *u8, n: i64, u16col: i64) -> i64 {
  var u: i64 = 0
  var i: i64 = 0
  var run: i64 = 1
  while run == 1 {
      if u >= u16col { run = 0 } else {
          if i >= n { run = 0 } else {
              let c: i64 = lp[i] as i64
              var adv: i64 = 1
              var units: i64 = 1
              if c >= LSP_U8_4 { adv = 4; units = 2 } else {
              if c >= LSP_U8_3 { adv = 3 } else {
              if c >= LSP_U8_2 { adv = 2 } } }
              u = u + units
              i = i + adv
          }
      }
  }
  return i
404}
405
406func lsp_is_word(c: i64) -> i64 {
  if c >= LSP_D0 { if c <= LSP_D9 { return 1 } }
  if c >= LSP_UA { if c <= LSP_UZ { return 1 } }
  if c >= LSP_LA { if c <= LSP_LZ { return 1 } }
  if c == LSP_USCORE { return 1 }
  return 0
412}
413
414// identifier extent containing (or immediately ending at) byte offset `off`.
415func lsp_word_at(t: *u8, n: i64, off: i64, s_out: *i64, e_out: *i64) -> i64 {
  s_out[0] = off
  e_out[0] = off
  if off < 0 { return 0 }
  if off > n { return 0 }
  var a: i64 = off
  if a >= n { a = n - 1 }
  if a < 0 { return 0 }
  if lsp_is_word(t[a] as i64) == 0 {
      if a > 0 { a = a - 1 } else { return 0 }
      if lsp_is_word(t[a] as i64) == 0 { return 0 }
  }
  var s: i64 = a
  var run: i64 = 1
  while run == 1 {
      if s <= 0 { run = 0 } else {
          if lsp_is_word(t[s - 1] as i64) == 1 { s = s - 1 } else { run = 0 }
      }
  }
  var e: i64 = a + 1
  run = 1
  while run == 1 {
      if e >= n { run = 0 } else {
          if lsp_is_word(t[e] as i64) == 1 { e = e + 1 } else { run = 0 }
      }
  }
  s_out[0] = s
  e_out[0] = e
  return 1
444}
445
446// ============================================================================================
447// SECTION 4 -- URI <-> path
448// ============================================================================================
449
450func lsp_hexval(c: i64) -> i64 {
  if c >= LSP_D0 { if c <= LSP_D9 { return c - LSP_D0 } }
  if c >= LSP_LA { if c <= LSP_LF_HEX { return c - LSP_LA + LSP_B10 } }
  if c >= LSP_UA { if c <= LSP_UF { return c - LSP_UA + LSP_B10 } }
  return 0 - 1
455}
456
457// file:///a/b%20c.nx -> /a/b c.nx . A URI with no scheme is taken as a plain path (the CLI modes
458// and the gate use plain paths; being lenient here costs nothing and refusing would cost a mode).
459func lsp_uri_to_path(uri: *u8, out: *u8, cap: i64) -> i64 {
  let n: i64 = lsp_slen(uri)
  var s: i64 = 0
  if jx_find(uri, n, 0, "file://" as *u8) == 0 { s = 7 }
  var o: i64 = 0
  var i: i64 = s
  while i < n {
      let c: i64 = uri[i] as i64
      var taken: i64 = 0
      if c == LSP_PCT {
          if i + 2 < n {
              let h1: i64 = lsp_hexval(uri[i + 1] as i64)
              let h2: i64 = lsp_hexval(uri[i + 2] as i64)
              if h1 >= 0 { if h2 >= 0 {
                  if o < cap - 1 { out[o] = (h1 * LSP_B16 + h2) as u8; o = o + 1 }
                  i = i + 3
                  taken = 1
              } }
          }
      }
      if taken == 0 {
          if o < cap - 1 { out[o] = uri[i]; o = o + 1 }
          i = i + 1
      }
  }
  out[o] = 0 as u8
  return o
486}
487
488func lsp_uri_unreserved(c: i64) -> i64 {
  if lsp_is_word(c) == 1 { return 1 }
  if c == LSP_MINUS { return 1 }
  if c == LSP_DOT { return 1 }
  if c == LSP_TILDE { return 1 }
  if c == LSP_SLASH { return 1 }
  return 0
495}
496
497// absolute path -> file:// URI. A relative path is made absolute against the CWD first, because a
498// Location the client cannot open is indistinguishable from no answer at all.
499func lsp_path_to_uri(path: *u8, out: *u8, cap: i64) -> i64 {
  let abs: *u8 = sys_mmap(SYS_PATH_MAX * 2)
  var an: i64 = 0
  if path[0] != (LSP_SLASH as u8) {
      let cwd: *u8 = sys_mmap(SYS_PATH_MAX)
      let r: i64 = sys_getcwd(cwd, SYS_PATH_MAX)
      if r > 0 {
          an = lsp_str_into(abs, 0, SYS_PATH_MAX * 2, cwd)
          an = lsp_put(abs, an, SYS_PATH_MAX * 2, LSP_SLASH)
      }
  }
  an = lsp_str_into(abs, an, SYS_PATH_MAX * 2, path)
  var o: i64 = lsp_str_into(out, 0, cap, "file://" as *u8)
  var i: i64 = 0
  while i < an {
      let c: i64 = abs[i] as i64
      if lsp_uri_unreserved(c) == 1 { o = lsp_put(out, o, cap, c) } else {
          o = lsp_put(out, o, cap, LSP_PCT)
          o = lsp_put(out, o, cap, lsp_hexdig(c / LSP_B16))
          o = lsp_put(out, o, cap, lsp_hexdig(c % LSP_B16))
      }
      i = i + 1
  }
  if o < cap { out[o] = 0 as u8 }
  return o
524}
525
526func lsp_basename(path: *u8) -> *u8 {
  let n: i64 = lsp_slen(path)
  var last: i64 = 0 - 1
  var i: i64 = 0
  while i < n {
      if path[i] == (LSP_SLASH as u8) { last = i }
      i = i + 1
  }
  return ((path as i64) + last + 1) as *u8
535}
536
537// ============================================================================================
538// SECTION 5 -- document store
539// ============================================================================================
540
541func lsp_uri_slot(i: i64) -> *u8 { return ((g_doc_uri as i64) + i * g_uri_bytes) as *u8 }
542func lsp_path_slot(i: i64) -> *u8 { return ((g_doc_path as i64) + i * SYS_PATH_MAX) as *u8 }
543func lsp_shadow_slot(i: i64) -> *u8 { return ((g_doc_shadow as i64) + i * SYS_PATH_MAX) as *u8 }
544
545func lsp_doc_find(uri: *u8) -> i64 {
  var i: i64 = 0
  while i < g_ndocs {
      if g_doc_live[i] == 1 {
          if lsp_streq(lsp_uri_slot(i), uri) == 1 { return i }
      }
      i = i + 1
  }
  return 0 - 1
554}
555
556// Returns the slot, or -1 when the store is full or the URI does not fit. BOTH refusals are the
557// caller's to announce: silently evicting a document the editor still tracks would make every later
558// request answer about nothing, with no error anywhere.
559func lsp_doc_put(uri: *u8, txt: *u8, n: i64) -> i64 {
  if lsp_slen(uri) >= g_uri_bytes { return 0 - 1 }
  var slot: i64 = lsp_doc_find(uri)
  if slot < 0 {
      var i: i64 = 0
      while i < g_ndocs {
          if g_doc_live[i] == 0 { if slot < 0 { slot = i } }
          i = i + 1
      }
  }
  if slot < 0 {
      if g_ndocs >= g_max_docs { return 0 - 1 }
      slot = g_ndocs
      g_ndocs = g_ndocs + 1
  }
  let up: *u8 = lsp_uri_slot(slot)
  var k: i64 = 0
  while uri[k] != (0 as u8) { up[k] = uri[k]; k = k + 1 }
  up[k] = 0 as u8
  lsp_uri_to_path(uri, lsp_path_slot(slot), SYS_PATH_MAX)
  g_doc_txt[slot] = txt as i64
  g_doc_len[slot] = n
  g_doc_live[slot] = 1
  return slot
583}
584
585// ============================================================================================
586// SECTION 6 -- the analysis child: the compiler's own front end, crash-isolated
587// ============================================================================================
588
589func lsp_scratch_path(slot: i64, ext: *u8, out: *u8, cap: i64) -> i64 {
  var o: i64 = lsp_str_into(out, 0, cap, g_scratch)
  o = lsp_str_into(out, o, cap, "/doc" as *u8)
  o = lsp_num_into(out, o, cap, slot)
  o = lsp_str_into(out, o, cap, ext)
  if o < cap { out[o] = 0 as u8 }
  return o
596}
597
598func lsp_write_file(path: *u8, buf: *u8, n: i64) -> i64 {
  let fd: i64 = sys_openat_wr(path, MODE_0644)
  if fd < 0 { return 0 - 1 }
  let w: i64 = lsp_write_all(fd, buf, n)
  sys_close(fd)
  if w != n { return 0 - 1 }
  return 0
605}
606
607func lsp_truncate_file(path: *u8) -> i64 {
  let fd: i64 = sys_openat_wr(path, MODE_0644)
  if fd >= 0 { sys_close(fd) }
  return 0
611}
612
613// Materialise the unsaved buffer ONE directory below the document so try_resolve_import walks the
614// identical chain. Returns 1 when the shadow exists, 0 when we must fall back to the saved file.
615func lsp_shadow_make(path: *u8, txt: *u8, n: i64, out: *u8, cap: i64) -> i64 {
  let dir: *u8 = sys_mmap(SYS_PATH_MAX)
  path_dir(path, dir)
  if dir[0] == (0 as u8) { dir[0] = LSP_DOT as u8; dir[1] = 0 as u8 }
  let sdir: *u8 = sys_mmap(SYS_PATH_MAX)
  var o: i64 = lsp_str_into(sdir, 0, SYS_PATH_MAX, dir)
  o = lsp_put(sdir, o, SYS_PATH_MAX, LSP_SLASH)
  o = lsp_str_into(sdir, o, SYS_PATH_MAX, g_shadow_name)
  sdir[o] = 0 as u8
  sys_mkdir(sdir, MODE_0755)
  var p: i64 = lsp_str_into(out, 0, cap, sdir)
  p = lsp_put(out, p, cap, LSP_SLASH)
  p = lsp_str_into(out, p, cap, lsp_basename(path))
  if p < cap { out[p] = 0 as u8 }
  if lsp_write_file(out, txt, n) != 0 { out[0] = 0 as u8; return 0 }
  return 1
631}
632
633// The symbol artifact. Deliberately a readable text file, not an in-memory-only structure: it is
634// what `nx_lsp symbols` prints, so the index a query answers from is the index a human can audit.
635//   V1 expand=<OK|FAIL> rc=<n> syms=<n> unmapped=<n> files=<n> coverage_complete=<0|1>
636//   F<TAB><idx><TAB><path>
637//   S<TAB><kind><TAB><line><TAB><col><TAB><fileidx><TAB><name>
638func lsp_child_analyze(path: *u8, symp: *u8) -> i64 {
  let ebuf: *u8 = sys_mmap(g_expand_reserve + LSP_WORD)
  let ctx: *ExpandCtx = expand_ctx_new(ebuf, g_expand_reserve)
  let lm: *LineMap = expand_ctx_enable_linemap(ctx)
  let rc: i64 = expand_imports(ctx, path)
643
  let hdr: *u8 = sys_mmap(LSP_SCAFFOLD_BYTES)
  if rc < 0 {
      var ho: i64 = lsp_str_into(hdr, 0, LSP_SCAFFOLD_BYTES, "V1 expand=FAIL rc=" as *u8)
      ho = lsp_num_into(hdr, ho, LSP_SCAFFOLD_BYTES, rc)
      ho = lsp_str_into(hdr, ho, LSP_SCAFFOLD_BYTES, " syms=0 unmapped=0 files=0 coverage_complete=0\n" as *u8)
      lsp_write_file(symp, hdr, ho)
      return 0
  }
652
  let op: *i64 = ctx.out_pos
  let endp: i64 = *op
  ebuf[endp] = 0 as u8
656
  let toks: *Tok = lex_source(ebuf, 0)
658
  // count tokens so the row buffer is DERIVED from the input rather than guessed
  var ntok: i64 = 0
  var run: i64 = 1
  while run == 1 {
      let t: *Tok = ((toks as i64) + ntok * TOK_BYTES) as *Tok
      if t.kind == TK_EOF { run = 0 } else { ntok = ntok + 1 }
  }
666
  let rowcap: i64 = ntok * LSP_SYMROW_BYTES + LSP_SCAFFOLD_BYTES
  let rows: *u8 = sys_mmap(rowcap + LSP_WORD)
  let files: *i64 = sys_mmap(MAX_IMPORTS * LSP_WORD + LSP_WORD) as *i64
  var nfiles: i64 = 0
  let lp: *i64 = sys_mmap(LSP_WORD * 4) as *i64
  let fp: *i64 = lp
  let sp: *i64 = ((lp as i64) + LSP_WORD) as *i64
674
  var ro: i64 = 0
  var nsym: i64 = 0
  var unmapped: i64 = 0
  var i: i64 = 0
  while i < ntok {
      let t: *Tok = ((toks as i64) + i * TOK_BYTES) as *Tok
      var kn: *u8 = 0 as *u8
      if t.kind == TK_FUNC   { kn = "func" as *u8 }
      if t.kind == TK_STRUCT { kn = "struct" as *u8 }
      if t.kind == TK_ENUM   { kn = "enum" as *u8 }
      if t.kind == TK_CONST  { kn = "const" as *u8 }
      if t.kind == TK_STATIC { kn = "static" as *u8 }
      if (kn as i64) != 0 {
          let nt: *Tok = ((toks as i64) + (i + 1) * TOK_BYTES) as *Tok
          if nt.kind == TK_IDENT {
              fp[0] = 0
              sp[0] = 0
              if lm_lookup(lm, nt.line, fp, sp) == 1 {
                  let fidx: i64 = fp[0]
                  var seen: i64 = 0
                  var k: i64 = 0
                  while k < nfiles { if files[k] == fidx { seen = 1 } k = k + 1 }
                  if seen == 0 { if nfiles < MAX_IMPORTS { files[nfiles] = fidx; nfiles = nfiles + 1 } }
                  ro = lsp_str_into(rows, ro, rowcap, "S\t" as *u8)
                  ro = lsp_str_into(rows, ro, rowcap, kn)
                  ro = lsp_put(rows, ro, rowcap, LSP_TAB)
                  ro = lsp_num_into(rows, ro, rowcap, sp[0])
                  ro = lsp_put(rows, ro, rowcap, LSP_TAB)
                  ro = lsp_num_into(rows, ro, rowcap, nt.col)
                  ro = lsp_put(rows, ro, rowcap, LSP_TAB)
                  ro = lsp_num_into(rows, ro, rowcap, fidx)
                  ro = lsp_put(rows, ro, rowcap, LSP_TAB)
                  ro = lsp_str_into(rows, ro, rowcap, tok_text_ptr(nt))
                  ro = lsp_put(rows, ro, rowcap, LSP_LF)
                  nsym = nsym + 1
              } else { unmapped = unmapped + 1 }
          }
      }
      i = i + 1
  }
715
  var cov: i64 = 1
  if unmapped > 0 { cov = 0 }
  if g_ovf == 1 { cov = 0 }
  var ho: i64 = lsp_str_into(hdr, 0, LSP_SCAFFOLD_BYTES, "V1 expand=OK rc=0 syms=" as *u8)
  ho = lsp_num_into(hdr, ho, LSP_SCAFFOLD_BYTES, nsym)
  ho = lsp_str_into(hdr, ho, LSP_SCAFFOLD_BYTES, " unmapped=" as *u8)
  ho = lsp_num_into(hdr, ho, LSP_SCAFFOLD_BYTES, unmapped)
  ho = lsp_str_into(hdr, ho, LSP_SCAFFOLD_BYTES, " files=" as *u8)
  ho = lsp_num_into(hdr, ho, LSP_SCAFFOLD_BYTES, nfiles)
  ho = lsp_str_into(hdr, ho, LSP_SCAFFOLD_BYTES, " coverage_complete=" as *u8)
  ho = lsp_num_into(hdr, ho, LSP_SCAFFOLD_BYTES, cov)
  ho = lsp_put(hdr, ho, LSP_SCAFFOLD_BYTES, LSP_LF)
728
  let sfd: i64 = sys_openat_wr(symp, MODE_0644)
  if sfd >= 0 {
      lsp_write_all(sfd, hdr, ho)
      let frow: *u8 = sys_mmap(SYS_PATH_MAX + LSP_SCAFFOLD_BYTES)
      var k: i64 = 0
      while k < nfiles {
          var fo: i64 = lsp_str_into(frow, 0, SYS_PATH_MAX, "F\t" as *u8)
          fo = lsp_num_into(frow, fo, SYS_PATH_MAX, files[k])
          fo = lsp_put(frow, fo, SYS_PATH_MAX, LSP_TAB)
          fo = lsp_str_into(frow, fo, SYS_PATH_MAX, lm_file_path(lm, files[k]))
          fo = lsp_put(frow, fo, SYS_PATH_MAX, LSP_LF)
          lsp_write_all(sfd, frow, fo)
          k = k + 1
      }
      lsp_write_all(sfd, rows, ro)
      sys_close(sfd)
  }
746
  // THE DIAGNOSTICS. Source + linemap plumbed exactly as nx_compile_x86 plumbs them, so the caret,
  // the did-you-mean note and the file:line attribution are the compiler's, byte for byte.
  nx_diag_set_source(ebuf, endp)
  nx_diag_set_linemap(lm)
  parse_module(toks, 0 as *Module)
  return 0
753}
754
755// Runs one analysis. Returns the child's exit code; *sig_out carries the terminating signal (0 when
756// it exited normally) so a TIMEOUT is never reported in the same word as a CRASH.
757func lsp_analyze(slot: i64, sig_out: *i64) -> i64 {
  let errp: *u8 = sys_mmap(SYS_PATH_MAX)
  let symp: *u8 = sys_mmap(SYS_PATH_MAX)
  lsp_scratch_path(slot, ".err" as *u8, errp, SYS_PATH_MAX)
  lsp_scratch_path(slot, ".sym" as *u8, symp, SYS_PATH_MAX)
  // Truncate BOTH before the fork: a child that dies before writing must leave an EMPTY artifact,
  // never the previous run's. A stale fixture silences a gate; a stale artifact lies to an editor.
  lsp_truncate_file(errp)
  lsp_truncate_file(symp)
766
  let path: *u8 = lsp_path_slot(slot)
  let shadow: *u8 = lsp_shadow_slot(slot)
  let txt: *u8 = g_doc_txt[slot] as *u8
  let have: i64 = lsp_shadow_make(path, txt, g_doc_len[slot], shadow, SYS_PATH_MAX)
  var target: *u8 = path
  if have == 1 { target = shadow } else {
      lsp_log("nx_lsp: shadow=UNAVAILABLE for " as *u8)
      lsp_log(path)
      lsp_log(" -- diagnostics reflect the SAVED file, not your buffer\n" as *u8)
  }
777
  sig_out[0] = 0
  let pid: i64 = sys_fork()
  if pid < 0 { return 0 - 1 }
  if pid == 0 {
      let efd: i64 = sys_openat_wr(errp, MODE_0644)
      if efd >= 0 { sys_dup3(efd, 2, 0) }
      sys_alarm(g_timeout_s)
      lsp_child_analyze(target, symp)
      sys_exit(0)
  }
  let st: *i64 = sys_mmap(LSP_WORD * 2) as *i64
  st[0] = 0
  sys_wait4(pid, st, 0)
  sig_out[0] = wait_term_signal(st[0])
  return wait_status_rc(st[0])
793}
794
795// ============================================================================================
796// SECTION 7 -- reading the compiler's diagnostics back out
797// ============================================================================================
798
799func lsp_starts(b: *u8, n: i64, at: i64, s: *u8) -> i64 {
  let sl: i64 = lsp_slen(s)
  if at + sl > n { return 0 }
  var i: i64 = 0
  while i < sl {
      if b[at + i] != s[i] { return 0 }
      i = i + 1
  }
  return 1
808}
809
810// A caret line is ALL space/tab and then a single '^'. It always immediately follows the echoed
811// source line, so the pair is what we match -- a source line that happens to be indented XOR would
812// otherwise read as a caret. Returns the 1-based COLUMN, or 0.
813func lsp_caret_col(b: *u8, ls: i64, le: i64) -> i64 {
  var i: i64 = ls
  var seen: i64 = 0
  while i < le {
      let c: i64 = b[i] as i64
      if c == LSP_CARET {
          if seen == 0 { return 0 }
          if i + 1 != le { return 0 }
          return i - ls - 1
      }
      if c != LSP_SPACE { if c != LSP_TAB { return 0 } }
      seen = 1
      i = i + 1
  }
  return 0
828}
829
830// THE COMPILER'S STDERR IS A STREAM, NOT A SET OF LINES. nx_parse fixes the contract in its own
831// note: the literal "error at " is a strict prefix of BOTH the mapped and unmapped location forms
832// precisely so a reader can anchor on it, and nx_mgmt_api already anchors its build-log window on
833// exactly that string. A LINE anchor is therefore the wrong reader -- and MEASURED 2026-08-25 it is
834// wrong in the worst available direction: nx_parse.nx:6047 parse_function writes "<name>:" to fd 2
835// for EVERY function with no terminator, so the FIRST diagnostic of every compile is glued to the end
836// of that trace, and a line-anchored reader reports ZERO PROBLEMS in a file that has one. A detector
837// whose failure mode is silence about a real defect is worse than absent. Anchoring on the marker is
838// matching the documented contract, not widening the reader: a false anchor still publishes nothing,
839// because the location grammar behind it must parse before any diagnostic is emitted.
840func lsp_next_marker(b: *u8, n: i64, from: i64, kind_out: *i64) -> i64 {
  kind_out[0] = 0
  let a: i64 = jx_find(b, n, from, "error at " as *u8)
  let c: i64 = jx_find(b, n, from, "nx_parse: " as *u8)
  let d: i64 = jx_find(b, n, from, "nx_tokenizer: " as *u8)
  var best: i64 = 0 - 1
  var kind: i64 = 0
  if a >= 0 { best = a; kind = 1 }
  if c >= 0 {
      if best < 0 { best = c; kind = 2 } else { if c < best { best = c; kind = 2 } }
  }
  if d >= 0 {
      if best < 0 { best = d; kind = 3 } else { if d < best { best = d; kind = 3 } }
  }
  kind_out[0] = kind
  return best
856}
857
858// Parses the child's stderr into positional diagnostics for THIS document. Everything it cannot
859// attribute truthfully is counted into *dropped and reported, never published against a guess.
860func lsp_parse_diags(b: *u8, n: i64, base: *u8, cap: i64,
                   dline: *i64, dcol: *i64, dsev: *i64, dms: *i64, dml: *i64,
                   dropped: *i64) -> i64 {
  dropped[0] = 0
  var count: i64 = 0
  var ls: i64 = 0
  let kp: *i64 = sys_mmap(LSP_WORD * 2) as *i64
  var scanning: i64 = 1
  while scanning == 1 {
      kp[0] = 0
      let m: i64 = lsp_next_marker(b, n, ls, kp)
      if m < 0 { scanning = 0 } else {
      let le: i64 = lsp_line_end(b, n, m)
      var pp: i64 = m + 9
      var sev: i64 = LSP_SEV_ERROR
      var positional: i64 = 1
      if kp[0] == 2 { pp = m + 10 }
      if kp[0] == 3 {
          pp = m
          sev = LSP_SEV_WARN
          positional = 0
      }
      if pp >= 0 {
          var ok: i64 = 0
          var srcline: i64 = 1
          var mstart: i64 = pp
          if positional == 0 {
              ok = 1
              mstart = pp
          } else {
              // <basename>:<line>: <message>   (the mapped form; "line <n>" means UNMAPPED)
              var q: i64 = pp
              var colon: i64 = 0 - 1
              while q < le {
                  if b[q] == (LSP_COLON as u8) { if colon < 0 { colon = q } }
                  q = q + 1
              }
              if colon > pp {
                  let bl: i64 = colon - pp
                  var same: i64 = 1
                  if lsp_slen(base) != bl { same = 0 }
                  var k: i64 = 0
                  while k < bl { if b[pp + k] != base[k] { same = 0 } k = k + 1 }
                  if same == 1 {
                      var d: i64 = colon + 1
                      var got: i64 = 0
                      var v: i64 = 0
                      var run: i64 = 1
                      while run == 1 {
                          if d >= le { run = 0 } else {
                              let c: i64 = b[d] as i64
                              if c < LSP_D0 { run = 0 } else {
                              if c > LSP_D9 { run = 0 } else {
                                  v = v * LSP_B10 + (c - LSP_D0)
                                  got = got + 1
                                  d = d + 1
                              } }
                          }
                      }
                      if got > 0 {
                          srcline = v
                          ok = 1
                          mstart = d
                          if mstart < le { if b[mstart] == (LSP_COLON as u8) { mstart = mstart + 1 } }
                          if mstart < le { if b[mstart] == (LSP_SPACE as u8) { mstart = mstart + 1 } }
                      }
                  }
              }
          }
          if ok == 0 { dropped[0] = dropped[0] + 1 } else {
              var col: i64 = 1
              if positional == 1 {
                  // the echo+caret pair, before the next diagnostic starts
                  let k2: *i64 = sys_mmap(LSP_WORD * 2) as *i64
                  k2[0] = 0
                  let nxt: i64 = lsp_next_marker(b, n, le + 1, k2)
                  var limit: i64 = n
                  if nxt >= 0 { limit = nxt }
                  var es: i64 = le + 1
                  var scan: i64 = 1
                  while scan == 1 {
                      if es >= limit { scan = 0 } else {
                          let ee: i64 = lsp_line_end(b, n, es)
                          if ee > limit { scan = 0 } else {
                              let cc: i64 = lsp_caret_col(b, es, ee)
                              if cc > 0 { col = cc; scan = 0 } else { es = ee + 1 }
                          }
                      }
                  }
              }
              if count < cap {
                  dline[count] = srcline
                  dcol[count] = col
                  dsev[count] = sev
                  dms[count] = mstart
                  dml[count] = le - mstart
                  count = count + 1
              } else { dropped[0] = dropped[0] + 1 }
          }
      }
      ls = le + 1
      if ls <= m { ls = m + 1 }
      }
  }
  return count
965}
966
967// ============================================================================================
968// SECTION 8 -- the symbol index, read back
969// ============================================================================================
970
971// Finds `name` in the slot's symbol artifact. Returns 1 on a hit, filling kind/line/col/path.
972func lsp_sym_find(slot: i64, name: *u8, kind_out: *u8, kcap: i64,
                line_out: *i64, col_out: *i64, path_out: *u8, pcap: i64) -> i64 {
  let symp: *u8 = sys_mmap(SYS_PATH_MAX)
  lsp_scratch_path(slot, ".sym" as *u8, symp, SYS_PATH_MAX)
  let lp: *i64 = sys_mmap(LSP_WORD * 2) as *i64
  lp[0] = 0
  let b: *u8 = sys_read_file(symp, lp)
  if (b as i64) == 0 { return 0 }
  let n: i64 = lp[0]
  if n <= 0 { return 0 }
982
  var found: i64 = 0
  var want_file: i64 = 0 - 1
  var ls: i64 = 0
  while ls < n {
      let le: i64 = lsp_line_end(b, n, ls)
      if found == 0 {
          if lsp_starts(b, n, ls, "S\t" as *u8) == 1 {
              // S <kind> <line> <col> <fileidx> <name>
              var f: i64 = 0
              var fs: i64 = ls + 2
              var kstart: i64 = fs
              var klen: i64 = 0
              var vline: i64 = 0
              var vcol: i64 = 0
              var vfile: i64 = 0
              var nstart: i64 = 0 - 1
              var i: i64 = fs
              var cur: i64 = 0
              while i <= le {
                  var brk: i64 = 0
                  if i == le { brk = 1 }
                  if brk == 0 { if b[i] == (LSP_TAB as u8) { brk = 1 } }
                  if brk == 1 {
                      if f == 0 { kstart = fs; klen = i - fs }
                      if f == 1 { vline = lsp_dec_at(b, fs, i) }
                      if f == 2 { vcol = lsp_dec_at(b, fs, i) }
                      if f == 3 { vfile = lsp_dec_at(b, fs, i) }
                      if f == 4 { nstart = fs }
                      f = f + 1
                      fs = i + 1
                  }
                  i = i + 1
              }
              if nstart >= 0 {
                  let nlen: i64 = le - nstart
                  var same: i64 = 1
                  if lsp_slen(name) != nlen { same = 0 }
                  var k: i64 = 0
                  while k < nlen { if b[nstart + k] != name[k] { same = 0 } k = k + 1 }
                  if same == 1 {
                      var ko: i64 = 0
                      while ko < klen { if ko < kcap - 1 { kind_out[ko] = b[kstart + ko] } ko = ko + 1 }
                      kind_out[klen] = 0 as u8
                      line_out[0] = vline
                      col_out[0] = vcol
                      want_file = vfile
                      found = 1
                  }
              }
          }
      }
      ls = le + 1
  }
  if found == 0 { return 0 }
1037
  path_out[0] = 0 as u8
  ls = 0
  while ls < n {
      let le: i64 = lsp_line_end(b, n, ls)
      if lsp_starts(b, n, ls, "F\t" as *u8) == 1 {
          var i: i64 = ls + 2
          var t1: i64 = 0 - 1
          while i < le { if b[i] == (LSP_TAB as u8) { if t1 < 0 { t1 = i } } i = i + 1 }
          if t1 > 0 {
              if lsp_dec_at(b, ls + 2, t1) == want_file {
                  var po: i64 = 0
                  var k: i64 = t1 + 1
                  while k < le { if po < pcap - 1 { path_out[po] = b[k]; po = po + 1 } k = k + 1 }
                  path_out[po] = 0 as u8
              }
          }
      }
      ls = le + 1
  }
  return 1
1058}
1059
1060func lsp_dec_at(b: *u8, s: i64, e: i64) -> i64 {
  var v: i64 = 0
  var i: i64 = s
  while i < e {
      let c: i64 = b[i] as i64
      if c >= LSP_D0 { if c <= LSP_D9 { v = v * LSP_B10 + (c - LSP_D0) } }
      i = i + 1
  }
  return v
1069}
1070
1071// ============================================================================================
1072// SECTION 9 -- LSP wire emission
1073// ============================================================================================
1074
1075func lsp_send(body: *u8, n: i64) -> i64 {
  if g_ovf == 1 {
      lsp_log("nx_lsp: REFUSED to send -- a response buffer overflowed and a truncated JSON message\n" as *u8)
      lsp_log("        is a protocol violation, not a shorter answer. Nothing was written.\n" as *u8)
      g_ovf = 0
      return 0 - 1
  }
  let h: *u8 = sys_mmap(LSP_OUTHDR_BYTES)
  var o: i64 = lsp_str_into(h, 0, LSP_OUTHDR_BYTES, "Content-Length: " as *u8)
  o = lsp_num_into(h, o, LSP_OUTHDR_BYTES, n)
  o = lsp_put(h, o, LSP_OUTHDR_BYTES, LSP_CR)
  o = lsp_put(h, o, LSP_OUTHDR_BYTES, LSP_LF)
  o = lsp_put(h, o, LSP_OUTHDR_BYTES, LSP_CR)
  o = lsp_put(h, o, LSP_OUTHDR_BYTES, LSP_LF)
  lsp_write_all(1, h, o)
  lsp_write_all(1, body, n)
  return 0
1092}
1093
1094func lsp_window_log(kind: i64, msg: *u8) -> i64 {
  let cap: i64 = lsp_slen(msg) * LSP_JSON_ESC_MAX + LSP_SCAFFOLD_BYTES
  let b: *u8 = sys_mmap(cap + LSP_WORD)
  var o: i64 = lsp_str_into(b, 0, cap, "{\"jsonrpc\":\"2.0\",\"method\":\"window/logMessage\",\"params\":{\"type\":" as *u8)
  o = lsp_num_into(b, o, cap, kind)
  o = lsp_str_into(b, o, cap, ",\"message\":\"" as *u8)
  o = lsp_jstrz_into(b, o, cap, msg)
  o = lsp_str_into(b, o, cap, "\"}}" as *u8)
  return lsp_send(b, o)
1103}
1104
1105// TRUTHFUL CAPABILITIES ONLY. textDocumentSync 1 = Full: we do not implement incremental sync, so we
1106// do not claim it, and a client that honours this never sends us a range we would have to guess at.
1107func lsp_reply_initialize(id: *u8) -> i64 {
  let cap: i64 = LSP_SCAFFOLD_BYTES + LSP_ID_BYTES
  let b: *u8 = sys_mmap(cap + LSP_WORD)
  var o: i64 = lsp_str_into(b, 0, cap, "{\"jsonrpc\":\"2.0\",\"id\":" as *u8)
  o = lsp_str_into(b, o, cap, id)
  o = lsp_str_into(b, o, cap, ",\"result\":{\"capabilities\":{\"textDocumentSync\":" as *u8)
  o = lsp_num_into(b, o, cap, LSP_SYNC_FULL)
  o = lsp_str_into(b, o, cap, ",\"definitionProvider\":true,\"hoverProvider\":true}," as *u8)
  o = lsp_str_into(b, o, cap, "\"serverInfo\":{\"name\":\"nx_lsp\",\"version\":\"LN11\"}}}" as *u8)
  return lsp_send(b, o)
1117}
1118
1119func lsp_reply_null(id: *u8) -> i64 {
  let cap: i64 = LSP_SCAFFOLD_BYTES + LSP_ID_BYTES
  let b: *u8 = sys_mmap(cap + LSP_WORD)
  var o: i64 = lsp_str_into(b, 0, cap, "{\"jsonrpc\":\"2.0\",\"id\":" as *u8)
  o = lsp_str_into(b, o, cap, id)
  o = lsp_str_into(b, o, cap, ",\"result\":null}" as *u8)
  return lsp_send(b, o)
1126}
1127
1128func lsp_reply_error(id: *u8, code: i64, msg: *u8) -> i64 {
  let cap: i64 = LSP_SCAFFOLD_BYTES + LSP_ID_BYTES + lsp_slen(msg) * LSP_JSON_ESC_MAX
  let b: *u8 = sys_mmap(cap + LSP_WORD)
  var o: i64 = lsp_str_into(b, 0, cap, "{\"jsonrpc\":\"2.0\",\"id\":" as *u8)
  o = lsp_str_into(b, o, cap, id)
  o = lsp_str_into(b, o, cap, ",\"error\":{\"code\":" as *u8)
  o = lsp_num_into(b, o, cap, code)
  o = lsp_str_into(b, o, cap, ",\"message\":\"" as *u8)
  o = lsp_jstrz_into(b, o, cap, msg)
  o = lsp_str_into(b, o, cap, "\"}}" as *u8)
  return lsp_send(b, o)
1139}
1140
1141// Builds the publishDiagnostics payload for a slot. Returns the byte length; *nd_out carries the
1142// number of diagnostics so the caller can report it without re-deriving it.
1143func lsp_build_diags(slot: i64, out_cap_out: *i64, nd_out: *i64) -> *u8 {
  let sig: *i64 = sys_mmap(LSP_WORD * 2) as *i64
  sig[0] = 0
  lsp_analyze(slot, sig)
1147
  let errp: *u8 = sys_mmap(SYS_PATH_MAX)
  lsp_scratch_path(slot, ".err" as *u8, errp, SYS_PATH_MAX)
  let lp: *i64 = sys_mmap(LSP_WORD * 2) as *i64
  lp[0] = 0
  var eb: *u8 = sys_read_file(errp, lp)
  var en: i64 = lp[0]
  if (eb as i64) == 0 { en = 0 }
  if en < 0 { en = 0 }
1156
  // one diagnostic can never be shorter than its "error at " prefix, so the stderr byte count is a
  // sound upper bound on how many there are -- derived, not guessed.
  var dcap: i64 = en / 9 + 2
  let dline: *i64 = sys_mmap(dcap * LSP_WORD + LSP_WORD) as *i64
  let dcol:  *i64 = sys_mmap(dcap * LSP_WORD + LSP_WORD) as *i64
  let dsev:  *i64 = sys_mmap(dcap * LSP_WORD + LSP_WORD) as *i64
  let dms:   *i64 = sys_mmap(dcap * LSP_WORD + LSP_WORD) as *i64
  let dml:   *i64 = sys_mmap(dcap * LSP_WORD + LSP_WORD) as *i64
  let drop:  *i64 = sys_mmap(LSP_WORD * 2) as *i64
  drop[0] = 0
1167
  var nd: i64 = 0
  if en > 0 {
      nd = lsp_parse_diags(eb, en, lsp_basename(lsp_path_slot(slot)), dcap,
                           dline, dcol, dsev, dms, dml, drop)
  }
1173
  let uri: *u8 = lsp_uri_slot(slot)
  let txt: *u8 = g_doc_txt[slot] as *u8
  let tn: i64 = g_doc_len[slot]
1177
  let uricost: i64 = lsp_slen(uri) * LSP_JSON_ESC_MAX
  let cap: i64 = en * LSP_JSON_ESC_MAX + (nd + 2) * LSP_PER_DIAG_BYTES + uricost + LSP_SCAFFOLD_BYTES
  let b: *u8 = sys_mmap(cap + LSP_WORD)
  var o: i64 = lsp_str_into(b, 0, cap, "{\"jsonrpc\":\"2.0\",\"method\":\"textDocument/publishDiagnostics\",\"params\":{\"uri\":\"" as *u8)
  o = lsp_jstrz_into(b, o, cap, uri)
  o = lsp_str_into(b, o, cap, "\",\"diagnostics\":[" as *u8)
1184
  var emitted: i64 = 0
  var i: i64 = 0
  while i < nd {
      let l0: i64 = dline[i] - 1
      let lstart: i64 = lsp_line_start(txt, tn, l0)
      if lstart >= 0 {
          let lend: i64 = lsp_line_end(txt, tn, lstart)
          let llen: i64 = lend - lstart
          let lptr: *u8 = ((txt as i64) + lstart) as *u8
          var boff: i64 = dcol[i] - 1
          if boff < 0 { boff = 0 }
          if boff > llen { boff = llen }
          let c0: i64 = lsp_u16_of_bytes(lptr, llen, boff)
          let ws: *i64 = sys_mmap(LSP_WORD * 2) as *i64
          let we: *i64 = ((ws as i64) + LSP_WORD) as *i64
          var c1: i64 = c0
          if lsp_word_at(lptr, llen, boff, ws, we) == 1 {
              c1 = lsp_u16_of_bytes(lptr, llen, we[0])
          }
          if c1 <= c0 { c1 = c0 + 1 }
          if emitted > 0 { o = lsp_put(b, o, cap, LSP_COMMA) }
          o = lsp_str_into(b, o, cap, "{\"range\":{\"start\":{\"line\":" as *u8)
          o = lsp_num_into(b, o, cap, l0)
          o = lsp_str_into(b, o, cap, ",\"character\":" as *u8)
          o = lsp_num_into(b, o, cap, c0)
          o = lsp_str_into(b, o, cap, "},\"end\":{\"line\":" as *u8)
          o = lsp_num_into(b, o, cap, l0)
          o = lsp_str_into(b, o, cap, ",\"character\":" as *u8)
          o = lsp_num_into(b, o, cap, c1)
          o = lsp_str_into(b, o, cap, "}},\"severity\":" as *u8)
          o = lsp_num_into(b, o, cap, dsev[i])
          o = lsp_str_into(b, o, cap, ",\"source\":\"nx_lsp\",\"message\":\"" as *u8)
          o = lsp_jstr_into(b, o, cap, ((eb as i64) + dms[i]) as *u8, dml[i])
          o = lsp_str_into(b, o, cap, "\"}" as *u8)
          emitted = emitted + 1
      } else { drop[0] = drop[0] + 1 }
      i = i + 1
  }
1223
  // A CHILD KILLED BY A SIGNAL PRODUCED NO VERDICT -- say which signal, at 0:0, rather than
  // publishing an empty list that reads exactly like a clean file.
  if sig[0] != 0 {
      if emitted > 0 { o = lsp_put(b, o, cap, LSP_COMMA) }
      o = lsp_str_into(b, o, cap, "{\"range\":{\"start\":{\"line\":0,\"character\":0},\"end\":{\"line\":0,\"character\":1}},\"severity\":" as *u8)
      o = lsp_num_into(b, o, cap, LSP_SEV_WARN)
      o = lsp_str_into(b, o, cap, ",\"source\":\"nx_lsp\",\"message\":\"analysis did not complete: the front end was killed by signal " as *u8)
      o = lsp_num_into(b, o, cap, sig[0])
      o = lsp_str_into(b, o, cap, " (14 is the analysis-timeout-s bound in knowledge/nx_lsp.conf; anything else is a front-end crash). This file has NOT been checked.\"}" as *u8)
      emitted = emitted + 1
  }
1235
  o = lsp_str_into(b, o, cap, "]}}" as *u8)
1237
  if drop[0] > 0 {
      lsp_log("nx_lsp: " as *u8)
      lsp_lognum(drop[0])
      lsp_log(" diagnostic(s) not published -- located outside this document or unmappable; a diagnostic attributed to the wrong file is worse than none\n" as *u8)
  }
  out_cap_out[0] = cap
  nd_out[0] = emitted
  return b
1246}
1247
1248func lsp_publish(slot: i64) -> i64 {
  let capo: *i64 = sys_mmap(LSP_WORD * 2) as *i64
  let ndo: *i64 = ((capo as i64) + LSP_WORD) as *i64
  capo[0] = 0
  ndo[0] = 0
  let b: *u8 = lsp_build_diags(slot, capo, ndo)
  return lsp_send(b, lsp_slen_bounded(b, capo[0]))
1255}
1256
1257func lsp_slen_bounded(b: *u8, cap: i64) -> i64 {
  var n: i64 = 0
  while n < cap { if b[n] == (0 as u8) { return n } n = n + 1 }
  return cap
1261}
1262
1263// ============================================================================================
1264// SECTION 10 -- definition and hover, over the symbol index
1265// ============================================================================================
1266
1267// Resolves the identifier under (line0, char0) to its declaration. Returns 1 on a hit.
1268func lsp_resolve(slot: i64, line0: i64, char0: i64,
               name_out: *u8, ncap: i64, kind_out: *u8, kcap: i64,
               dline: *i64, dcol: *i64, dpath: *u8, pcap: i64,
               wc0: *i64, wc1: *i64) -> i64 {
  let txt: *u8 = g_doc_txt[slot] as *u8
  let tn: i64 = g_doc_len[slot]
  let lstart: i64 = lsp_line_start(txt, tn, line0)
  if lstart < 0 { return 0 }
  let lend: i64 = lsp_line_end(txt, tn, lstart)
  let llen: i64 = lend - lstart
  let lptr: *u8 = ((txt as i64) + lstart) as *u8
  let boff: i64 = lsp_bytes_of_u16(lptr, llen, char0)
  let ws: *i64 = sys_mmap(LSP_WORD * 2) as *i64
  let we: *i64 = ((ws as i64) + LSP_WORD) as *i64
  if lsp_word_at(lptr, llen, boff, ws, we) == 0 { return 0 }
  let wl: i64 = we[0] - ws[0]
  if wl <= 0 { return 0 }
  var k: i64 = 0
  while k < wl { if k < ncap - 1 { name_out[k] = lptr[ws[0] + k] } k = k + 1 }
  name_out[wl] = 0 as u8
  wc0[0] = lsp_u16_of_bytes(lptr, llen, ws[0])
  wc1[0] = lsp_u16_of_bytes(lptr, llen, we[0])
  if lsp_sym_find(slot, name_out, kind_out, kcap, dline, dcol, dpath, pcap) == 0 { return 0 }
  // The root file was analysed through its shadow, so a hit in it must be spoken about as the
  // document the editor actually has open -- never as a path under the shadow directory.
  if lsp_streq(dpath, lsp_shadow_slot(slot)) == 1 {
      var p: i64 = 0
      let real: *u8 = lsp_path_slot(slot)
      while real[p] != (0 as u8) { if p < pcap - 1 { dpath[p] = real[p] } p = p + 1 }
      dpath[p] = 0 as u8
  }
  return 1
1300}
1301
1302// The declaration's own source line, for hover. Read from the declaring file; the open document is
1303// answered from the live buffer so an unsaved edit shows the text the user is looking at.
1304// trim=1 strips leading indentation (hover DISPLAY); trim=0 keeps the line byte-exact (COLUMN
1305// ARITHMETIC). One reader, two contracts: converting a byte column against a trimmed line would be
1306// off by exactly the indentation, and every .nx declaration inside a block is indented.
1307func lsp_decl_line(slot: i64, path: *u8, line: i64, out: *u8, cap: i64, trim: i64) -> i64 {
  var txt: *u8 = 0 as *u8
  var tn: i64 = 0
  if lsp_streq(path, lsp_path_slot(slot)) == 1 {
      txt = g_doc_txt[slot] as *u8
      tn = g_doc_len[slot]
  } else {
      let lp: *i64 = sys_mmap(LSP_WORD * 2) as *i64
      lp[0] = 0
      txt = sys_read_file(path, lp)
      tn = lp[0]
  }
  out[0] = 0 as u8
  if (txt as i64) == 0 { return 0 }
  if tn <= 0 { return 0 }
  let s: i64 = lsp_line_start(txt, tn, line - 1)
  if s < 0 { return 0 }
  let e: i64 = lsp_line_end(txt, tn, s)
  var o: i64 = 0
  var i: i64 = s
  while i < e {
      var c: i64 = txt[i] as i64
      var skip: i64 = 0
      if trim == 1 {
          if o == 0 { if c == LSP_SPACE { skip = 1 } }
          if o == 0 { if c == LSP_TAB { skip = 1 } }
      }
      if skip == 0 { if o < cap - 1 { out[o] = txt[i]; o = o + 1 } }
      i = i + 1
  }
  out[o] = 0 as u8
  return o
1339}
1340
1341func lsp_handle_definition(id: *u8, slot: i64, line0: i64, char0: i64) -> i64 {
  let name: *u8 = sys_mmap(LSP_NAMEBUF)
  let kind: *u8 = sys_mmap(LSP_KINDBUF)
  let dpath: *u8 = sys_mmap(SYS_PATH_MAX)
  let sl: *i64 = sys_mmap(LSP_WORD * 8) as *i64
  let dl: *i64 = sl
  let dc: *i64 = ((sl as i64) + LSP_WORD) as *i64
  let w0: *i64 = ((sl as i64) + LSP_WORD * 2) as *i64
  let w1: *i64 = ((sl as i64) + LSP_WORD * 3) as *i64
  dl[0] = 0
  dc[0] = 0
  if lsp_resolve(slot, line0, char0, name, LSP_NAMEBUF, kind, LSP_KINDBUF,
                 dl, dc, dpath, SYS_PATH_MAX, w0, w1) == 0 {
      return lsp_reply_null(id)
  }
  let uri: *u8 = sys_mmap(SYS_PATH_MAX * LSP_URI_ESC_MAX + LSP_SCAFFOLD_BYTES)
  lsp_path_to_uri(dpath, uri, SYS_PATH_MAX * LSP_URI_ESC_MAX + LSP_SCAFFOLD_BYTES)
1358
  // The declaration column is a BYTE column from the tokenizer and LSP wants UTF-16 code units.
  // Convert against the declaring line's OWN UNTRIMMED bytes -- taking the byte value directly
  // would be silently wrong on any line carrying a multi-byte character before the name, which is
  // exactly the class of error nobody notices until a user with an accented comment reports that
  // goto-def lands two columns off.
  let dtxt: *u8 = sys_mmap(SYS_PATH_MAX)
  let dlen: i64 = lsp_decl_line(slot, dpath, dl[0], dtxt, SYS_PATH_MAX, 0)
  var dboff: i64 = dc[0] - 1
  if dboff < 0 { dboff = 0 }
  let nlen: i64 = lsp_slen(name)
  let dc0: i64 = lsp_u16_of_bytes(dtxt, dlen, dboff)
  let dc1: i64 = lsp_u16_of_bytes(dtxt, dlen, dboff + nlen)
1371
  let cap: i64 = lsp_slen(uri) * LSP_JSON_ESC_MAX + LSP_SCAFFOLD_BYTES + LSP_ID_BYTES
  let b: *u8 = sys_mmap(cap + LSP_WORD)
  var o: i64 = lsp_str_into(b, 0, cap, "{\"jsonrpc\":\"2.0\",\"id\":" as *u8)
  o = lsp_str_into(b, o, cap, id)
  o = lsp_str_into(b, o, cap, ",\"result\":{\"uri\":\"" as *u8)
  o = lsp_jstrz_into(b, o, cap, uri)
  o = lsp_str_into(b, o, cap, "\",\"range\":{\"start\":{\"line\":" as *u8)
  o = lsp_num_into(b, o, cap, dl[0] - 1)
  o = lsp_str_into(b, o, cap, ",\"character\":" as *u8)
  o = lsp_num_into(b, o, cap, dc0)
  o = lsp_str_into(b, o, cap, "},\"end\":{\"line\":" as *u8)
  o = lsp_num_into(b, o, cap, dl[0] - 1)
  o = lsp_str_into(b, o, cap, ",\"character\":" as *u8)
  o = lsp_num_into(b, o, cap, dc1)
  o = lsp_str_into(b, o, cap, "}}}}" as *u8)
  return lsp_send(b, o)
1388}
1389
1390func lsp_handle_hover(id: *u8, slot: i64, line0: i64, char0: i64) -> i64 {
  let name: *u8 = sys_mmap(LSP_NAMEBUF)
  let kind: *u8 = sys_mmap(LSP_KINDBUF)
  let dpath: *u8 = sys_mmap(SYS_PATH_MAX)
  let sl: *i64 = sys_mmap(LSP_WORD * 8) as *i64
  let dl: *i64 = sl
  let dc: *i64 = ((sl as i64) + LSP_WORD) as *i64
  let w0: *i64 = ((sl as i64) + LSP_WORD * 2) as *i64
  let w1: *i64 = ((sl as i64) + LSP_WORD * 3) as *i64
  dl[0] = 0
  dc[0] = 0
  w0[0] = 0
  w1[0] = 0
  if lsp_resolve(slot, line0, char0, name, LSP_NAMEBUF, kind, LSP_KINDBUF,
                 dl, dc, dpath, SYS_PATH_MAX, w0, w1) == 0 {
      return lsp_reply_null(id)
  }
  let decl: *u8 = sys_mmap(SYS_PATH_MAX)
  lsp_decl_line(slot, dpath, dl[0], decl, SYS_PATH_MAX, 1)
1409
  let textcost: i64 = (lsp_slen(decl) + lsp_slen(dpath) + LSP_NAMEBUF) * LSP_JSON_ESC_MAX
  let cap: i64 = textcost + LSP_SCAFFOLD_BYTES + LSP_ID_BYTES
  let b: *u8 = sys_mmap(cap + LSP_WORD)
  var o: i64 = lsp_str_into(b, 0, cap, "{\"jsonrpc\":\"2.0\",\"id\":" as *u8)
  o = lsp_str_into(b, o, cap, id)
  o = lsp_str_into(b, o, cap, ",\"result\":{\"contents\":{\"kind\":\"plaintext\",\"value\":\"" as *u8)
  o = lsp_jstrz_into(b, o, cap, kind)
  o = lsp_jstr_into(b, o, cap, " " as *u8, 1)
  o = lsp_jstrz_into(b, o, cap, name)
  o = lsp_str_into(b, o, cap, "\\n" as *u8)
  o = lsp_jstrz_into(b, o, cap, decl)
  o = lsp_str_into(b, o, cap, "\\n" as *u8)
  o = lsp_jstrz_into(b, o, cap, lsp_basename(dpath))
  o = lsp_jstr_into(b, o, cap, ":" as *u8, 1)
  o = lsp_num_into(b, o, cap, dl[0])
  o = lsp_str_into(b, o, cap, "\"},\"range\":{\"start\":{\"line\":" as *u8)
  o = lsp_num_into(b, o, cap, line0)
  o = lsp_str_into(b, o, cap, ",\"character\":" as *u8)
  o = lsp_num_into(b, o, cap, w0[0])
  o = lsp_str_into(b, o, cap, "},\"end\":{\"line\":" as *u8)
  o = lsp_num_into(b, o, cap, line0)
  o = lsp_str_into(b, o, cap, ",\"character\":" as *u8)
  o = lsp_num_into(b, o, cap, w1[0])
  o = lsp_str_into(b, o, cap, "}}}}" as *u8)
  return lsp_send(b, o)
1435}
1436
1437// ============================================================================================
1438// SECTION 11 -- the message loop
1439// ============================================================================================
1440
1441// The id is copied VERBATIM (quotes and all when it is a string), so a client using string ids gets
1442// its own id back with its own type -- a number echoed for a string id is a spec violation clients
1443// report as a hang.
1444func lsp_get_id_raw(b: *u8, n: i64, out: *u8, cap: i64) -> i64 {
  let at: i64 = jx_find(b, n, 0, "\"id\":" as *u8)
  if at < 0 { out[0] = 0 as u8; return 0 }
  var p: i64 = jx_skip_ws(b, n, at + 5)
  var o: i64 = 0
  if p < n {
      if b[p] == (LSP_QUOTE as u8) {
          if o < cap - 1 { out[o] = b[p]; o = o + 1 }
          p = p + 1
          var run: i64 = 1
          while run == 1 {
              if p >= n { run = 0 } else {
                  if b[p] == (LSP_BSLASH as u8) {
                      if o < cap - 2 { out[o] = b[p]; o = o + 1; out[o] = b[p + 1]; o = o + 1 }
                      p = p + 2
                  } else {
                      if o < cap - 1 { out[o] = b[p]; o = o + 1 }
                      if b[p] == (LSP_QUOTE as u8) { run = 0 }
                      p = p + 1
                  }
              }
          }
      } else {
          var run: i64 = 1
          while run == 1 {
              if p >= n { run = 0 } else {
                  let c: i64 = b[p] as i64
                  var stop: i64 = 0
                  if c == LSP_COMMA { stop = 1 }
                  if c == LSP_RBRACE { stop = 1 }
                  if c == LSP_SPACE { stop = 1 }
                  if stop == 1 { run = 0 } else {
                      if o < cap - 1 { out[o] = b[p]; o = o + 1 }
                      p = p + 1
                  }
              }
          }
      }
  }
  out[o] = 0 as u8
  return o
1485}
1486
1487func lsp_read_header(clen_out: *i64) -> i64 {
  clen_out[0] = 0
  let hb: *u8 = sys_mmap(g_hdr_max + LSP_WORD)
  let one: *u8 = sys_mmap(LSP_WORD)
  var o: i64 = 0
  var run: i64 = 1
  var result: i64 = 0
  while run == 1 {
      let r: i64 = sys_read(0, one, 1)
      if r <= 0 { run = 0 } else {
          if o >= g_hdr_max {
              lsp_log("nx_lsp: LSP-HEADER-OVERRUN -- the message header passed header-bytes-max in knowledge/nx_lsp.conf without a blank line. Refusing rather than reading forever.\n" as *u8)
              run = 0
              result = 0 - 1
          } else {
              hb[o] = one[0]
              o = o + 1
              var done: i64 = 0
              if o >= 4 {
                  if hb[o-4] == (LSP_CR as u8) { if hb[o-3] == (LSP_LF as u8) {
                  if hb[o-2] == (LSP_CR as u8) { if hb[o-1] == (LSP_LF as u8) { done = 1 } } } }
              }
              if o >= 2 {
                  if hb[o-2] == (LSP_LF as u8) { if hb[o-1] == (LSP_LF as u8) { done = 1 } }
              }
              if done == 1 { run = 0; result = 1 }
          }
      }
  }
  if result != 1 { return result }
  var at: i64 = jx_find(hb, o, 0, "Content-Length:" as *u8)
  if at < 0 { at = jx_find(hb, o, 0, "content-length:" as *u8) }
  if at < 0 {
      lsp_log("nx_lsp: message header carried no Content-Length -- refusing the frame\n" as *u8)
      return 0 - 1
  }
  var p: i64 = jx_skip_ws(hb, o, at + 15)
  var v: i64 = 0
  var got: i64 = 0
  var run2: i64 = 1
  while run2 == 1 {
      if p >= o { run2 = 0 } else {
          let c: i64 = hb[p] as i64
          if c < LSP_D0 { run2 = 0 } else {
          if c > LSP_D9 { run2 = 0 } else { v = v * LSP_B10 + (c - LSP_D0); got = got + 1; p = p + 1 } }
      }
  }
  if got == 0 { return 0 - 1 }
  clen_out[0] = v
  return 1
1537}
1538
1539func lsp_read_body(n: i64) -> *u8 {
  let b: *u8 = sys_mmap(n + LSP_WORD)
  var off: i64 = 0
  var run: i64 = 1
  while run == 1 {
      if off >= n { run = 0 } else {
          let r: i64 = sys_read(0, ((b as i64) + off) as *u8, n - off)
          if r <= 0 { run = 0 } else { off = off + r }
      }
  }
  if off < n { return 0 as *u8 }
  b[n] = 0 as u8
  return b
1552}
1553
1554func lsp_params_pos(b: *u8, n: i64, l_out: *i64, c_out: *i64) -> i64 {
  l_out[0] = 0
  c_out[0] = 0
  let at: i64 = jx_find(b, n, 0, "\"position\"" as *u8)
  if at < 0 { return 0 }
  let lv: *i64 = sys_mmap(LSP_WORD * 2) as *i64
  let cv: *i64 = ((lv as i64) + LSP_WORD) as *i64
  if jx_get_int(b, n, at, "line" as *u8, lv) < 0 { return 0 }
  if jx_get_int(b, n, at, "character" as *u8, cv) < 0 { return 0 }
  l_out[0] = lv[0]
  c_out[0] = cv[0]
  return 1
1566}
1567
1568func lsp_dispatch(b: *u8, n: i64) -> i64 {
  let method: *u8 = sys_mmap(LSP_NAMEBUF)
  method[0] = 0 as u8
  jx_get_str(b, n, 0, "method" as *u8, method, LSP_NAMEBUF)
  let id: *u8 = sys_mmap(LSP_ID_BYTES)
  let has_id: i64 = lsp_get_id_raw(b, n, id, LSP_ID_BYTES)
1574
  if lsp_streq(method, "initialize" as *u8) == 1 { return lsp_reply_initialize(id) }
  if lsp_streq(method, "initialized" as *u8) == 1 { return 0 }
  if lsp_streq(method, "shutdown" as *u8) == 1 { g_shutdown = 1; return lsp_reply_null(id) }
  if lsp_streq(method, "exit" as *u8) == 1 {
      if g_shutdown == 1 { sys_exit(LSP_EXIT_OK) }
      sys_exit(LSP_EXIT_NO_SHUTDOWN)
  }
1582
  let uri: *u8 = sys_mmap(g_uri_bytes + LSP_WORD)
  uri[0] = 0 as u8
  jx_get_str(b, n, 0, "uri" as *u8, uri, g_uri_bytes)
1586
  if lsp_streq(method, "textDocument/didOpen" as *u8) == 1 {
      let txt: *u8 = sys_mmap(n + LSP_WORD)
      txt[0] = 0 as u8
      jx_get_str_raw(b, n, 0, "text" as *u8, txt, n + 1)
      let slot: i64 = lsp_doc_put(uri, txt, lsp_slen(txt))
      if slot < 0 {
          lsp_window_log(LSP_MSG_ERROR, "nx_lsp REFUSED didOpen: the document store is full or the URI exceeds doc-uri-bytes. Raise max-open-docs / doc-uri-bytes in knowledge/nx_lsp.conf. This file is NOT being checked." as *u8)
          return 0
      }
      return lsp_publish(slot)
  }
1598
  if lsp_streq(method, "textDocument/didChange" as *u8) == 1 {
      let slot0: i64 = lsp_doc_find(uri)
      if slot0 < 0 {
          lsp_window_log(LSP_MSG_WARN, "nx_lsp: didChange for a document that was never opened -- ignored" as *u8)
          return 0
      }
      let cc: i64 = jx_find(b, n, 0, "\"contentChanges\"" as *u8)
      var from: i64 = 0
      if cc >= 0 { from = cc }
      if jx_find(b, n, from, "\"range\"" as *u8) >= 0 {
          lsp_window_log(LSP_MSG_ERROR, "nx_lsp REFUSED an incremental didChange: this server advertises textDocumentSync=Full and does not implement ranges. Applying it as a full replacement would silently corrupt the buffer." as *u8)
          return 0
      }
      let txt: *u8 = sys_mmap(n + LSP_WORD)
      txt[0] = 0 as u8
      jx_get_str_raw(b, n, from, "text" as *u8, txt, n + 1)
      let slot: i64 = lsp_doc_put(uri, txt, lsp_slen(txt))
      if slot < 0 { return 0 }
      return lsp_publish(slot)
  }
1619
  if lsp_streq(method, "textDocument/didClose" as *u8) == 1 {
      let slot: i64 = lsp_doc_find(uri)
      if slot >= 0 { g_doc_live[slot] = 0 }
      // The spec requires clearing: a diagnostic left behind on a closed file outlives its subject.
      let cap: i64 = lsp_slen(uri) * LSP_JSON_ESC_MAX + LSP_SCAFFOLD_BYTES
      let ob: *u8 = sys_mmap(cap + LSP_WORD)
      var o: i64 = lsp_str_into(ob, 0, cap, "{\"jsonrpc\":\"2.0\",\"method\":\"textDocument/publishDiagnostics\",\"params\":{\"uri\":\"" as *u8)
      o = lsp_jstrz_into(ob, o, cap, uri)
      o = lsp_str_into(ob, o, cap, "\",\"diagnostics\":[]}}" as *u8)
      return lsp_send(ob, o)
  }
1631
  if lsp_streq(method, "textDocument/definition" as *u8) == 1 {
      let slot: i64 = lsp_doc_find(uri)
      if slot < 0 { return lsp_reply_null(id) }
      let pv: *i64 = sys_mmap(LSP_WORD * 2) as *i64
      let pc: *i64 = ((pv as i64) + LSP_WORD) as *i64
      if lsp_params_pos(b, n, pv, pc) == 0 { return lsp_reply_null(id) }
      return lsp_handle_definition(id, slot, pv[0], pc[0])
  }
1640
  if lsp_streq(method, "textDocument/hover" as *u8) == 1 {
      let slot: i64 = lsp_doc_find(uri)
      if slot < 0 { return lsp_reply_null(id) }
      let pv: *i64 = sys_mmap(LSP_WORD * 2) as *i64
      let pc: *i64 = ((pv as i64) + LSP_WORD) as *i64
      if lsp_params_pos(b, n, pv, pc) == 0 { return lsp_reply_null(id) }
      return lsp_handle_hover(id, slot, pv[0], pc[0])
  }
1649
  // An unknown REQUEST must be answered or the client waits forever; an unknown NOTIFICATION must
  // be ignored in silence. Telling them apart is the presence of an id, and nothing else.
  if has_id > 0 { return lsp_reply_error(id, LSP_RPC_METHOD_NOT_FOUND, method) }
  return 0
1654}
1655
1656func lsp_serve() -> i64 {
  let cl: *i64 = sys_mmap(LSP_WORD * 2) as *i64
  var run: i64 = 1
  while run == 1 {
      cl[0] = 0
      let h: i64 = lsp_read_header(cl)
      if h != 1 { run = 0 } else {
          if cl[0] <= 0 { run = 0 } else {
              let b: *u8 = lsp_read_body(cl[0])
              if (b as i64) == 0 {
                  lsp_log("nx_lsp: stdin closed mid-body -- the client went away\n" as *u8)
                  run = 0
              } else {
                  g_ovf = 0
                  lsp_dispatch(b, cl[0])
              }
          }
      }
  }
  if g_shutdown == 1 { return LSP_EXIT_OK }
  return LSP_EXIT_NO_SHUTDOWN
1677}
1678
1679// ============================================================================================
1680// SECTION 12 -- one-shot modes (the auditable surface: same code path, no framing)
1681// ============================================================================================
1682
1683func lsp_oneshot_load(path: *u8) -> i64 {
  let lp: *i64 = sys_mmap(LSP_WORD * 2) as *i64
  lp[0] = 0
  let t: *u8 = sys_read_file(path, lp)
  if (t as i64) == 0 {
      lsp_log("nx_lsp: cannot read " as *u8)
      lsp_log(path)
      lsp_log("\n" as *u8)
      return 0 - 1
  }
  return lsp_doc_put(path, t, lp[0])
1694}
1695
1696func lsp_mode_diag(path: *u8) -> i64 {
  let slot: i64 = lsp_oneshot_load(path)
  if slot < 0 { return 1 }
  let capo: *i64 = sys_mmap(LSP_WORD * 2) as *i64
  let ndo: *i64 = ((capo as i64) + LSP_WORD) as *i64
  capo[0] = 0
  ndo[0] = 0
  let b: *u8 = lsp_build_diags(slot, capo, ndo)
  let n: i64 = lsp_slen_bounded(b, capo[0])
  lsp_write_all(1, b, n)
  lsp_write_all(1, "\n" as *u8, 1)
  return 0
1708}
1709
1710func lsp_mode_symbols(path: *u8) -> i64 {
  let slot: i64 = lsp_oneshot_load(path)
  if slot < 0 { return 1 }
  let sig: *i64 = sys_mmap(LSP_WORD * 2) as *i64
  sig[0] = 0
  lsp_analyze(slot, sig)
  let symp: *u8 = sys_mmap(SYS_PATH_MAX)
  lsp_scratch_path(slot, ".sym" as *u8, symp, SYS_PATH_MAX)
  let lp: *i64 = sys_mmap(LSP_WORD * 2) as *i64
  lp[0] = 0
  let b: *u8 = sys_read_file(symp, lp)
  if (b as i64) == 0 { return 1 }
  lsp_write_all(1, b, lp[0])
  if sig[0] != 0 {
      lsp_log("nx_lsp: the analysis child was killed by signal " as *u8)
      lsp_lognum(sig[0])
      lsp_log(" -- this index is PARTIAL\n" as *u8)
  }
  return 0
1729}
1730
1731func lsp_usage() -> i64 {
  lsp_log("nx_lsp -- LN11 NishiLang language server (LSP 3.17 over stdio).\n" as *u8)
  lsp_log("usage: nx_lsp serve            speak LSP on stdin/stdout (the editor entry point)\n" as *u8)
  lsp_log("       nx_lsp diag <file.nx>   the publishDiagnostics payload for one file, unframed\n" as *u8)
  lsp_log("       nx_lsp symbols <file.nx> the symbol index artifact for one file\n" as *u8)
  lsp_log("Diagnostics, goto-definition and hover are served from the compiler's own front end\n" as *u8)
  lsp_log("(nx_import expand_imports + LineMap, nx_tokenizer lex_source, nx_parse parse_module).\n" as *u8)
  lsp_log("Every bound it uses is a row in knowledge/nx_lsp.conf; a missing row is a refusal.\n" as *u8)
  return LSP_EXIT_USAGE
1740}
1741
1742func main(argc: i64, argv: *i64) -> i64 {
  if argc < 2 { lsp_cfg_load(); return lsp_usage() }
  lsp_cfg_load()
  let a1: *u8 = argv[1] as *u8
  if lsp_streq(a1, "serve" as *u8) == 1 { return lsp_serve() }
  if lsp_streq(a1, "diag" as *u8) == 1 {
      if argc < 3 { return lsp_usage() }
      return lsp_mode_diag(argv[2] as *u8)
  }
  if lsp_streq(a1, "symbols" as *u8) == 1 {
      if argc < 3 { return lsp_usage() }
      return lsp_mode_symbols(argv[2] as *u8)
  }
  return lsp_usage()
1756}
nx_lsp.nx source

`nx_lsp.nx` source
