`nx_import.nx` source

↩ module page · 1341 lines · 52844 B
1// import.nx -- sovereign import preprocessor (replaces main.c logic).
2//
3// Responsibility: given a root source path, return a single null-
4// terminated buffer containing every imported file's text spliced
5// inline, recursively, with each file visited at most once.  Output
6// is exactly what parse_module consumes.
7//
8// Subsystem boundary:
9//   - syscalls.nx : file I/O (sys_read_file)
10//   - str helpers : cstr_len / cstr_eq / u8_copy (below; no external dep)
11//   - import.nx   : path ops + import expansion (this file)
12//   - nxc.nx      : CLI driver that owns argv and calls expand_imports
13//
14// Invariants (enforced, not hoped):
15//   I1  Each canonicalised absolute path is expanded at most once --
16//       the `seen` path table dedupes.  Repeat imports emit nothing.
17//   I2  Canonicalisation is pure textual (.. pops, . drops,
18//       forward-slashes unified).  No realpath(3).  Identical output
19//       on Windows and Linux/NishiOS.
20//   I3  Import syntax: exactly `import "relative.nx"` at start-of-
21//       line after optional whitespace.  Nothing else parses as an
22//       import; a substring match mid-line passes through.
23//   I4  Buffer overruns fail loudly (negative return).  Never
24//       silently truncate -- correctness over convenience.
25//   I5  Fixed capacity: MAX_IMPORTS distinct imports per tree;
26//       paths up to IMPORT_PATH_LEN; output buffer sized by caller.
27//       A build that needs more raises one constant in one place.
28//
29// Complexity: O(N * F) where N is total source bytes across all
30// files and F is average imports-per-file.  One read per file.
31
32// nx_safety_envelope:
33//   intended_use:       AUTO_APPLIED -- primitive-specific tuning queued
34//   sil_target:         SIL1
35//   evidence:           [bulk_applied_2026-05-16, see-file-comment-for-detail]
36//   verdict:            NOT_YET_EVALUATED
37
38import "nx_syscalls.nx"
39import "nx_linemap.nx"
40
41// ---- sizing knobs --------------------------------------------------
42
43// Bumped 64 -> 256 (2026-05-20) -- bits-up HTTPS arc transitively
44// imports ~100 .nx files; previously failed at 64.  256 gives
45// headroom for AES-GCM, HTTP/2, image decoders without re-bumping.
46const MAX_IMPORTS:     i64 = 256
47const IMPORT_PATH_LEN: i64 = 1024
48
49// Error codes returned by expand functions (negative = error).
50const ERR_IMPORTS_FULL: i64 = -1
51const ERR_READ_FAILED:  i64 = -2
52const ERR_OUT_OVERFLOW: i64 = -3
53const ERR_BAD_IMPORT:   i64 = -4
54
55// ---- LN14 QUALIFIED IMPORTS: sizing + refusal codes ----------------
56//
57// MAX_ALIASES is DERIVED, not chosen: an alias can only be introduced by an
58// `as` clause on an import line, and MAX_IMPORTS already bounds how many
59// distinct imports a tree may hold, so the alias table can never be the thing
60// that overflows first -- ERR_IMPORTS_FULL fires before ERR_ALIAS_FULL can.
61const MAX_ALIASES:    i64 = 256
62
63// Per-alias record, stored as AL_FIELDS parallel i64 slots in one flat table.
64const AL_FIELDS:      i64 = 6
65const AL_F_NAMEOFF:   i64 = 0   // byte offset of the alias spelling in al_names
66const AL_F_EXPADDR:   i64 = 1   // *i64: absolute address of each export name
67const AL_F_EXPLEN:    i64 = 2   // *i64: length of each export name
68const AL_F_EXPN:      i64 = 3   // export count
69const AL_F_RWBUF:     i64 = 4   // *u8: this module's line-rewrite scratch
70const AL_F_RWCAP:     i64 = 5   // bytes in AL_F_RWBUF
71
72// THE SHORTEST TOP-LEVEL DECLARATION THIS SCANNER CAN RECOGNISE is `func x(`
73// plus its newline = 8 bytes, so a module of L bytes declares at most
74// L/EXP_MIN_DECL_BYTES + 1 exports. The export table is sized from THAT, from
75// the file's own measured length -- never from a guessed ceiling that would
76// truncate a big module in silence.
77const EXP_MIN_DECL_BYTES: i64 = 8
78
79// A renamed identifier grows by len(alias)+2 (the __ separator). The shortest
80// identifier is one byte, so an N-byte line holds at most N identifiers and
81// cannot exceed N*(alias_len+RW_GROWTH_SLACK) after rewriting. The rewrite
82// buffer is sized from the module's OWN longest line times that factor,
83// measured in the same pass that collects the exports. The bound is sound, so
84// ERR_ALIAS_LINE_CAP cannot fire -- it exists so that if it ever does, it
85// ANNOUNCES instead of truncating.
86const RW_GROWTH_SLACK: i64 = 3
87
88// One page for the ExpandCtx. The previous allocation was an exact 64-byte fit
89// with a comment warning that a 9th field would write past it: that is a
90// landmine wearing a comment, and this rung had to add four fields. A page is
91// the smallest thing sys_mmap can hand back, so no future field can outgrow
92// this without also outgrowing the allocator's own granule.
93const EXPAND_CTX_BYTES: i64 = 4096
94
95// Every refusal has its OWN code, because a refusal that will not say WHICH
96// rule fired cannot tell a right answer from a right-for-the-wrong-reason one.
97const ERR_ALIAS_FULL:     i64 = -5
98const ERR_ALIAS_CONFLICT: i64 = -6
99const ERR_ALIAS_UNKNOWN:  i64 = -7
100const ERR_ALIAS_NOEXPORT: i64 = -8
101const ERR_ALIAS_BADNAME:  i64 = -9
102const ERR_ALIAS_LINE_CAP: i64 = -10
103
104// ---- cstring helpers ----------------------------------------------
105
106func cstr_len(s: *u8) -> i64 {
  var n: i64 = 0
  while s[n] != 0 { n = n + 1 }
  return n
110}
111
112func cstr_eq(a: *u8, b: *u8) -> i64 {
  var i: i64 = 0
  while a[i] != 0 {
      if a[i] != b[i] { return 0 }
      i = i + 1
  }
  if b[i] != 0 { return 0 }
  return 1
120}
121
122// Copy exactly `n` bytes from src to dst.  No null-term responsibility.
123func u8_copy(dst: *u8, src: *u8, n: i64) -> i64 {
  var i: i64 = 0
  while i < n { dst[i] = src[i]; i = i + 1 }
  return n
127}
128
129// Shift a *u8 pointer by `delta` bytes (address arithmetic).
130func ptr_at(p: *u8, delta: i64) -> *u8 {
  let a: i64 = (p as i64) + delta
  return a as *u8
133}
134
135// ---- LN14 lexical predicates + diagnostics -------------------------
136// These sit beside the cstring helpers on purpose: they are the only new
137// machinery that has no dependency on ExpandCtx, so a reader can check them
138// without holding the rest of the rung in their head.
139
140// Identifier byte: [A-Za-z0-9_]. The renamer's whole notion of a word boundary.
141func imp_ident_ch(b: i64) -> i64 {
  if b >= 0x30 { if b <= 0x39 { return 1 } }
  if b >= 0x41 { if b <= 0x5A { return 1 } }
  if b >= 0x61 { if b <= 0x7A { return 1 } }
  if b == 0x5F { return 1 }
  return 0
147}
148
149// Does src[p..] begin with keyword `kw` followed by exactly one space? Used to
150// find top-level declarations, which in this dialect start at column 0.
151func imp_kw_at(src: *u8, p: i64, kw: *u8) -> i64 {
  var i: i64 = 0
  while kw[i] != 0 {
      if src[p + i] != kw[i] { return 0 }
      i = i + 1
  }
  if src[p + i] == 0x20 { return 1 }
  return 0
159}
160
161// Is the span src[s..s+n) exactly `main`?  main is DELIBERATELY never exported:
162// expand_imports_inner strips it from every non-root module, so it is not part
163// of any module's surface and mangling it would rename a symbol that is about
164// to be deleted.
165func imp_is_main(src: *u8, s: i64, n: i64) -> i64 {
  if n != 4 { return 0 }
  if src[s] != 0x6D { return 0 }
  if src[s+1] != 0x61 { return 0 }
  if src[s+2] != 0x69 { return 0 }
  if src[s+3] != 0x6E { return 0 }
  return 1
172}
173
174// Refusals go to fd 2 from HERE rather than from the driver, so the rule that
175// fired travels with the failure instead of being flattened into one exit code
176// three layers up.
177func imp_err(s: *u8) -> i64 {
  var n: i64 = 0
  while s[n] != 0 { n = n + 1 }
  sys_write(2, s, n)
  return 0
182}
183
184func imp_err_span(p: *u8, n: i64) -> i64 {
  if n > 0 { sys_write(2, p, n) }
  return 0
187}
188
189// Does the line src[s..e) contain a `::` at all?  This is the ONE cheap test
190// that keeps an unaliased compile on exactly the path it took before this rung
191// existed: single colons are everywhere in type annotations, doubled ones are
192// not, so almost every line answers no in a few compares.
193func imp_has_qual(src: *u8, s: i64, e: i64) -> i64 {
  var i: i64 = s
  while i + 1 < e {
      if src[i] == 0x3A { if src[i+1] == 0x3A { return 1 } }
      i = i + 1
  }
  return 0
200}
201
202// ---- ImportSet -----------------------------------------------------
203//
204// Flat MAX_IMPORTS * IMPORT_PATH_LEN byte buffer.  Entry i lives at
205// offset i * IMPORT_PATH_LEN.  Counter held externally.
206
207// WHICH slot holds `path`, or -1. LN14 needs the INDEX, not the boolean: the
208// alias a module was expanded under is recorded in a parallel array, and a
209// yes/no answer cannot address it. import_already delegates so there stays
210// exactly ONE seen-set search in this file rather than two that can drift.
211func imp_path_index(paths: *u8, n: i64, path: *u8) -> i64 {
  var i: i64 = 0
  while i < n {
      let entry: *u8 = ptr_at(paths, i * IMPORT_PATH_LEN)
      if cstr_eq(entry, path) == 1 { return i }
      i = i + 1
  }
  return 0 - 1
219}
220
221func import_already(paths: *u8, n: i64, path: *u8) -> i64 {
  if imp_path_index(paths, n, path) >= 0 { return 1 }
  return 0
224}
225
226func import_add(paths: *u8, n: i64, path: *u8) -> i64 {
  if n >= MAX_IMPORTS { return 0 }
  let entry: *u8 = ptr_at(paths, n * IMPORT_PATH_LEN)
  var plen: i64 = cstr_len(path)
  if plen > IMPORT_PATH_LEN - 1 { plen = IMPORT_PATH_LEN - 1 }
  u8_copy(entry, path, plen)
  entry[plen] = 0
  return 1
234}
235
236// ---- path ops ------------------------------------------------------
237
238// Extract directory portion of `path`.  Everything before the final
239// '/' or '\'.  Writes null-terminated to `out`.  Returns length.
240func path_dir(path: *u8, out: *u8) -> i64 {
  let n: i64 = cstr_len(path)
  var last: i64 = 0 - 1
  var i: i64 = 0
  while i < n {
      if path[i] == 0x2F { last = i }   // '/'
      if path[i] == 0x5C { last = i }   // '\\'
      i = i + 1
  }
  if last < 0 { out[0] = 0; return 0 }
  u8_copy(out, path, last)
  out[last] = 0
  return last
253}
254
255// Compose `dir/name` into `out`.  If name is absolute (leading '/' or
256// 'X:' drive letter), copy name verbatim.  Returns length.
257func join_path(dir: *u8, name: *u8, out: *u8) -> i64 {
  if name[0] == 0x2F {
      let nlen: i64 = cstr_len(name)
      u8_copy(out, name, nlen)
      out[nlen] = 0
      return nlen
  }
  if name[0] != 0 {
      if name[1] == 0x3A {   // Windows drive letter 'X:'
          let nlen: i64 = cstr_len(name)
          u8_copy(out, name, nlen)
          out[nlen] = 0
          return nlen
      }
  }
  let dlen: i64 = cstr_len(dir)
  if dlen == 0 {
      let nlen: i64 = cstr_len(name)
      u8_copy(out, name, nlen)
      out[nlen] = 0
      return nlen
  }
  u8_copy(out, dir, dlen)
  out[dlen] = 0x2F
  let nlen: i64 = cstr_len(name)
  u8_copy(ptr_at(out, dlen + 1), name, nlen)
  let total: i64 = dlen + 1 + nlen
  out[total] = 0
  return total
286}
287
288// Return 1 if byte is a path separator.
289func is_sep(b: i64) -> i64 {
  if b == 0x2F { return 1 }
  if b == 0x5C { return 1 }
  return 0
293}
294
295// Canonicalise `path` so semantically-identical forms collapse to one
296// key.  Pure textual: pops `..`, drops `.`, unifies '/' separators.
297// `scratch` must hold >= 4096 bytes (two segment tables).  Returns
298// output length.
299func canonicalise_path(path: *u8, out: *u8, scratch: *u8) -> i64 {
  let n: i64 = cstr_len(path)
301
  // First pass: extract segments.  Each entry is (offset, length)
  // into the original path buffer.
  let seg_offs: *i64 = scratch as *i64
  let seg_lens: *i64 = ptr_at(scratch, 1024) as *i64
  var n_seg: i64 = 0
  var i: i64 = 0
  while i < n {
      while i < n {
          if is_sep(path[i]) == 0 { break }
          i = i + 1
      }
      if i >= n { break }
      let start: i64 = i
      while i < n {
          if is_sep(path[i]) == 1 { break }
          i = i + 1
      }
      let seg_len: i64 = i - start
      if seg_len > 0 {
          if n_seg < 128 {
              seg_offs[n_seg] = start
              seg_lens[n_seg] = seg_len
              n_seg = n_seg + 1
          }
      }
  }
328
  // Second pass: apply `.` drop and `..` pop.
  let out_offs: *i64 = ptr_at(scratch, 2048) as *i64
  let out_lens: *i64 = ptr_at(scratch, 3072) as *i64
  var outn: i64 = 0
  var k: i64 = 0
  while k < n_seg {
      let o: i64 = seg_offs[k]
      let l: i64 = seg_lens[k]
      // Is this segment "." ?
      if l == 1 {
          if path[o] == 0x2E {
              k = k + 1
              continue
          }
      }
      // Is this segment ".." ?
      if l == 2 {
          if path[o] == 0x2E {
              if path[o + 1] == 0x2E {
                  if outn > 0 {
                      outn = outn - 1
                  } else {
                      out_offs[outn] = o
                      out_lens[outn] = l
                      outn = outn + 1
                  }
                  k = k + 1
                  continue
              }
          }
      }
      out_offs[outn] = o
      out_lens[outn] = l
      outn = outn + 1
      k = k + 1
  }
365
  // Rejoin with '/' separator.  Preserve leading slash if absolute.
  var pos: i64 = 0
  if is_sep(path[0]) == 1 { out[pos] = 0x2F; pos = pos + 1 }
  var j: i64 = 0
  while j < outn {
      if j > 0 { out[pos] = 0x2F; pos = pos + 1 }
      let o: i64 = out_offs[j]
      let l: i64 = out_lens[j]
      u8_copy(ptr_at(out, pos), ptr_at(path, o), l)
      pos = pos + l
      j = j + 1
  }
  out[pos] = 0
  return pos
380}
381
382// ---- import line detection ----------------------------------------
383
384// Does src[p..] begin with `import` followed by space or tab?
385func starts_with_import(src: *u8, p: i64) -> i64 {
  if src[p + 0] != 0x69 { return 0 }   // 'i'
  if src[p + 1] != 0x6D { return 0 }   // 'm'
  if src[p + 2] != 0x70 { return 0 }   // 'p'
  if src[p + 3] != 0x6F { return 0 }   // 'o'
  if src[p + 4] != 0x72 { return 0 }   // 'r'
  if src[p + 5] != 0x74 { return 0 }   // 't'
  let c: i64 = src[p + 6]
  if c == 0x20 { return 1 }
  if c == 0x09 { return 1 }
  return 0
396}
397
398// ---- state singleton ----------------------------------------------
399//
400// expand_imports is naturally recursive.  Rather than pass many args
401// through each recursive call, we stash shared state in a small
402// struct allocated once by the top-level caller.
403struct ExpandCtx {
  paths:     *u8,     // seen-set storage (MAX_IMPORTS * IMPORT_PATH_LEN)
  n_paths:   *i64,    // counter into `paths`
  out:       *u8,     // destination buffer
  out_pos:   *i64,    // current write offset into `out`
  out_cap:   i64,     // destination capacity (bytes)
  scratch:   *u8,     // >= 4096 bytes for canonicalise
  // The two slots this struct reserved for "future instrumentation (import
  // depth, error line numbers)" -- now spent on exactly that.
  lm:        *LineMap,  // 0 = mapping disabled (the default -- zero behaviour change)
  out_line:  i64,       // current line in the EXPANDED output, 1-based
  // ---- LN14 QUALIFIED IMPORTS (2026-08-25) ----
  // This comment used to read "the field COUNT is unchanged at 8 (64 bytes)
  // and that matters: expand_ctx_new mmaps exactly 64, so a 9th field would
  // have written past the allocation." That was true, and it made the struct
  // unextendable by anyone who did not read the comment first -- a heap
  // overrun guarded by prose. expand_ctx_new now takes a whole PAGE
  // (EXPAND_CTX_BYTES), which is the smallest unit sys_mmap can return, so
  // the hazard is gone rather than re-documented.
  al_names:   *u8,      // MAX_ALIASES * IMPORT_PATH_LEN; 0 until the first `as`
  al_tab:     *i64,     // MAX_ALIASES * AL_FIELDS slots; 0 until the first `as`
  al_n:       i64,      // declared aliases. 0 means every LN14 branch is skipped
  path_alias: *i64,     // per seen-path slot: the alias it was expanded under, or -1
426}
427
428// Allocate an ExpandCtx with heap-backed storage.  Caller owns the
429// pointer; compiler is run-once so OS reclaims at exit.
430func expand_ctx_new(out: *u8, out_cap: i64) -> *ExpandCtx {
  let ctx_raw: *u8 = sys_mmap(EXPAND_CTX_BYTES)
  let ctx: *ExpandCtx = ctx_raw as *ExpandCtx
  ctx.paths    = sys_mmap(MAX_IMPORTS * IMPORT_PATH_LEN)
  let n_raw: *u8 = sys_mmap(16)
  let np: *i64 = n_raw as *i64
  *np = 0
  ctx.n_paths  = np
  ctx.out      = out
  let op_raw: *u8 = sys_mmap(16)
  let op: *i64 = op_raw as *i64
  *op = 0
  ctx.out_pos  = op
  ctx.out_cap  = out_cap
  ctx.scratch  = sys_mmap(4096)
  ctx.lm       = 0 as *LineMap
  ctx.out_line = 1
  // LN14. The alias PLANE is lazy -- nothing is mapped until an `as` clause is
  // actually seen -- but path_alias is not, because it must already hold -1 for
  // every slot the seen-set fills BEFORE the first alias appears. Its cost is
  // MAX_IMPORTS i64 = 2048 bytes for the life of one compiler run, and it is the
  // only thing this rung charges a closure that never qualifies a name.
  ctx.al_names   = 0 as *u8
  ctx.al_tab     = 0 as *i64
  ctx.al_n       = 0
  let pa_raw: *u8 = sys_mmap(MAX_IMPORTS * 8)
  let pa: *i64 = pa_raw as *i64
  var pi: i64 = 0
  while pi < MAX_IMPORTS { pa[pi] = 0 - 1; pi = pi + 1 }
  ctx.path_alias = pa
  return ctx
461}
462
463// OPT-IN. A caller that wants per-file diagnostics asks for them; every existing
464// caller keeps byte-identical behaviour because the map stays null. Same additive
465// contract as nx_diag_set_source: unset yields the OLD output, never a wrong one.
466func expand_ctx_enable_linemap(ctx: *ExpandCtx) -> *LineMap {
  ctx.lm = lm_new()
  return ctx.lm
469}
470
471// Append one byte to the output buffer.  Returns 0 on success,
472// ERR_OUT_OVERFLOW on out-of-room.
473func out_push(ctx: *ExpandCtx, b: i64) -> i64 {
  let op: *i64 = ctx.out_pos
  let pos: i64 = *op
  if pos + 1 >= ctx.out_cap { return ERR_OUT_OVERFLOW }
  ctx.out[pos] = b
  *op = pos + 1
  // The output line counter is maintained HERE, at the single byte-level chokepoint
  // every spliced byte passes through, rather than at the call sites that think they
  // are writing a line. A counter kept beside the writer can disagree with it; a
  // counter kept INSIDE the writer cannot.
  if b == 0x0A { ctx.out_line = ctx.out_line + 1 }
  return 0
485}
486
487// Append n bytes that are KNOWN to contain no 0x0A (a single source line without its
488// terminator). Skips out_append's newline scan because there is nothing to count; the
489// caller pushes the terminator through out_push, which is where ctx.out_line advances.
490// Returns 0 or ERR_OUT_OVERFLOW; on overflow NOTHING is written.
491func out_append_line(ctx: *ExpandCtx, src: *u8, n: i64) -> i64 {
  let op: *i64 = ctx.out_pos
  let pos: i64 = *op
  if pos + n + 1 >= ctx.out_cap { return ERR_OUT_OVERFLOW }
  u8_copy(ptr_at(ctx.out, pos), src, n)
  *op = pos + n
  return 0
498}
499
500// Append n bytes.  Returns 0 or ERR_OUT_OVERFLOW.
501func out_append(ctx: *ExpandCtx, src: *u8, n: i64) -> i64 {
  let op: *i64 = ctx.out_pos
  let pos: i64 = *op
  if pos + n + 1 >= ctx.out_cap { return ERR_OUT_OVERFLOW }
  u8_copy(ptr_at(ctx.out, pos), src, n)
  *op = pos + n
  // Same invariant as out_push. This path is not on today's splice route, but a
  // writer that can advance the buffer without advancing the line counter is a
  // desync waiting for its first caller.
  var k: i64 = 0
  while k < n {
      if src[k] == 0x0A { ctx.out_line = ctx.out_line + 1 }
      k = k + 1
  }
  return 0
516}
517
518// ==== LN14 QUALIFIED IMPORTS ========================================
519//
520// `import "mod.nx" as ns` gives that module a namespace of its own: every
521// top-level name IT declares is rewritten to `ns__<name>` throughout its own
522// text, and a reference `ns::<name>` anywhere in the closure resolves to that
523// same mangled symbol. Two organs may therefore export the same identifier and
524// BOTH stay reachable -- which is the whole defect class the shadow census
525// counts, where a same-named module reachable by two paths puts two definitions
526// of one symbol into one flat program.
527//
528// WHY THE PREPROCESSOR AND NOT THE PARSER. The splice is already a whole-program
529// text transform and mangling is a text transform. Doing it here means the
530// tokenizer and the parser see ordinary identifiers and are not touched at all,
531// so the feature cannot regress anything that does not use it.
532//
533// COST WHEN UNUSED IS ZERO BY CONSTRUCTION. Every branch below is reached only
534// via `ctx.al_n > 0` (some alias was declared) or `alias_idx >= 0` (this frame
535// IS an aliased module). A closure with no `as` clause takes byte-for-byte the
536// same path it took before this rung, including the bulk-copy fast path, and
537// allocates nothing beyond the 2 KB path_alias array.
538//
539// WHAT IT DELIBERATELY DOES NOT DO, said plainly so the next reader does not
540// have to assume:
541//   * `ns__name` is a RESERVED spelling. A program that already declares that
542//     literal identifier gets a redefinition from the parser -- loud, not silent.
543//   * Renaming is suppressed inside "..." literals, inside // comments, for an
544//     identifier immediately preceded by '.', and for the FIRST identifier of a
545//     line inside a top-level `struct { }` body (that is the field name; the
546//     rest of the line is a type and IS renamed).
547//   * `main` is never exported -- see imp_is_main.
548//   * A module reached by TWO import paths in one closure canonicalises to two
549//     different keys and is spliced twice; that was true before this rung and
550//     is unchanged. Qualification is what makes the resulting duplicate symbols
551//     addressable, not what prevents the second splice.
552
553// Map the alias plane. Called only from imp_alias_add, so a closure that never
554// writes `as` never pays for this.
555func imp_alias_init(ctx: *ExpandCtx) -> i64 {
  if ctx.al_names != (0 as *u8) { return 0 }
  ctx.al_names = sys_mmap(MAX_ALIASES * IMPORT_PATH_LEN)
  let t_raw: *u8 = sys_mmap(MAX_ALIASES * AL_FIELDS * 8)
  ctx.al_tab = t_raw as *i64
  return 0
561}
562
563func imp_alias_slot(ctx: *ExpandCtx, k: i64, f: i64) -> i64 {
  return ctx.al_tab[k * AL_FIELDS + f]
565}
566
567func imp_alias_set(ctx: *ExpandCtx, k: i64, f: i64, v: i64) -> i64 {
  ctx.al_tab[k * AL_FIELDS + f] = v
  return 0
570}
571
572func imp_alias_name(ctx: *ExpandCtx, k: i64) -> *u8 {
  return ptr_at(ctx.al_names, imp_alias_slot(ctx, k, AL_F_NAMEOFF))
574}
575
576// Which alias is spelled src[s..s+n)?  -1 = none declared.
577func imp_alias_find(ctx: *ExpandCtx, src: *u8, s: i64, n: i64) -> i64 {
  var k: i64 = 0
  while k < ctx.al_n {
      let nm: *u8 = imp_alias_name(ctx, k)
      if cstr_len(nm) == n {
          var i: i64 = 0
          var eq: i64 = 1
          while i < n {
              if nm[i] != src[s + i] { eq = 0 }
              i = i + 1
          }
          if eq == 1 { return k }
      }
      k = k + 1
  }
  return 0 - 1
593}
594
595// Declare the alias spelled src[s..s+n). Returns its slot, or a negative ERR_*.
596func imp_alias_add(ctx: *ExpandCtx, src: *u8, s: i64, n: i64) -> i64 {
  if n <= 0 { return ERR_ALIAS_BADNAME }
  if n >= IMPORT_PATH_LEN { return ERR_ALIAS_BADNAME }
  imp_alias_init(ctx)
  if ctx.al_n >= MAX_ALIASES { return ERR_ALIAS_FULL }
  if imp_alias_find(ctx, src, s, n) >= 0 { return ERR_ALIAS_CONFLICT }
  let k: i64 = ctx.al_n
  let off: i64 = k * IMPORT_PATH_LEN
  let dst: *u8 = ptr_at(ctx.al_names, off)
  u8_copy(dst, ptr_at(src, s), n)
  dst[n] = 0
  imp_alias_set(ctx, k, AL_F_NAMEOFF, off)
  imp_alias_set(ctx, k, AL_F_EXPADDR, 0)
  imp_alias_set(ctx, k, AL_F_EXPLEN, 0)
  imp_alias_set(ctx, k, AL_F_EXPN, 0)
  imp_alias_set(ctx, k, AL_F_RWBUF, 0)
  imp_alias_set(ctx, k, AL_F_RWCAP, 0)
  ctx.al_n = k + 1
  return k
615}
616
617// Collect alias k's export surface from the module text it is about to splice,
618// and size that module's rewrite buffer. BOTH facts come out of passes over
619// bytes already read -- the longest line is what bounds the rewrite, so it is
620// measured rather than assumed.
621func imp_alias_scan_exports(ctx: *ExpandCtx, k: i64, src: *u8, n: i64) -> i64 {
  var maxline: i64 = 0
  var ls: i64 = 0
  var p: i64 = 0
  while p < n {
      if src[p] == 0x0A {
          if p - ls > maxline { maxline = p - ls }
          ls = p + 1
      }
      p = p + 1
  }
  if n - ls > maxline { maxline = n - ls }
633
  let cap_n: i64 = n / EXP_MIN_DECL_BYTES + 1
  let ea_raw: *u8 = sys_mmap(cap_n * 8)
  let el_raw: *u8 = sys_mmap(cap_n * 8)
  let eaddr: *i64 = ea_raw as *i64
  let elen:  *i64 = el_raw as *i64
  var cnt: i64 = 0
640
  p = 0
  while p < n {
      var at_ls: i64 = 0
      if p == 0 { at_ls = 1 }
      if p > 0 { if src[p-1] == 0x0A { at_ls = 1 } }
      if at_ls == 1 {
          var np: i64 = 0 - 1
          if imp_kw_at(src, p, "func\x00" as *u8)   == 1 { np = p + 5 }
          if imp_kw_at(src, p, "const\x00" as *u8)  == 1 { np = p + 6 }
          if imp_kw_at(src, p, "struct\x00" as *u8) == 1 { np = p + 7 }
          if np >= 0 {
              while np < n {
                  if src[np] != 0x20 { break }
                  np = np + 1
              }
              var q: i64 = np
              while q < n {
                  if imp_ident_ch(src[q] as i64) == 0 { break }
                  q = q + 1
              }
              let ln: i64 = q - np
              if ln > 0 {
                  if imp_is_main(src, np, ln) == 0 {
                      // The bound above is sound (8 bytes is the shortest
                      // declaration that can exist), so this cannot fire --
                      // and if it ever does it REFUSES rather than quietly
                      // exporting a prefix of the module.
                      if cnt >= cap_n { return ERR_ALIAS_FULL }
                      eaddr[cnt] = (src as i64) + np
                      elen[cnt] = ln
                      cnt = cnt + 1
                  }
              }
          }
      }
      p = p + 1
  }
678
  let alen: i64 = cstr_len(imp_alias_name(ctx, k))
  let rwcap: i64 = maxline * (alen + RW_GROWTH_SLACK) + 2
  let rw_raw: *u8 = sys_mmap(rwcap)
  imp_alias_set(ctx, k, AL_F_EXPADDR, eaddr as i64)
  imp_alias_set(ctx, k, AL_F_EXPLEN, elen as i64)
  imp_alias_set(ctx, k, AL_F_EXPN, cnt)
  imp_alias_set(ctx, k, AL_F_RWBUF, rw_raw as i64)
  imp_alias_set(ctx, k, AL_F_RWCAP, rwcap)
  return cnt
688}
689
690// Does alias k's module declare the top-level name src[s..s+n)?
691func imp_alias_exports(ctx: *ExpandCtx, k: i64, src: *u8, s: i64, n: i64) -> i64 {
  let ea: i64 = imp_alias_slot(ctx, k, AL_F_EXPADDR)
  if ea == 0 { return 0 }
  let eaddr: *i64 = ea as *i64
  let elen:  *i64 = imp_alias_slot(ctx, k, AL_F_EXPLEN) as *i64
  let cnt:   i64  = imp_alias_slot(ctx, k, AL_F_EXPN)
  var j: i64 = 0
  while j < cnt {
      if elen[j] == n {
          let nm: *u8 = eaddr[j] as *u8
          var i: i64 = 0
          var eq: i64 = 1
          while i < n {
              if nm[i] != src[s + i] { eq = 0 }
              i = i + 1
          }
          if eq == 1 { return 1 }
      }
      j = j + 1
  }
  return 0
712}
713
714// THE LN14 RESOLVER. src[s..e) is a qualified reference `<ns>::<name>`; write
715// the mangled `<ns>__<name>` into out and return its length, or return a
716// negative ERR_ALIAS_* naming WHICH rule refused. The two refusals below are
717// the ones a caller can actually provoke, and each prints the namespace and the
718// name it was given: a suite that can only ask "was it refused?" cannot tell a
719// right answer from a right-for-the-wrong-reason one.
720func imp_qualified_name(ctx: *ExpandCtx, src: *u8, s: i64, e: i64, out: *u8, ocap: i64) -> i64 {
  var c: i64 = 0 - 1
  var i: i64 = s
  while i + 1 < e {
      if c < 0 { if src[i] == 0x3A { if src[i+1] == 0x3A { c = i } } }
      i = i + 1
  }
  if c < 0 { return ERR_ALIAS_BADNAME }
  let nsn: i64 = c - s
  let nms: i64 = c + 2
  let nmn: i64 = e - nms
  if nsn <= 0 { return ERR_ALIAS_BADNAME }
  if nmn <= 0 { return ERR_ALIAS_BADNAME }
  let k: i64 = imp_alias_find(ctx, src, s, nsn)
  if k < 0 {
      imp_err("nx-import: REFUSED rule=ALIAS-UNKNOWN-NAMESPACE ns=\x00" as *u8)
      imp_err_span(ptr_at(src, s), nsn)
      imp_err(" -- no import declared this namespace before its first use\n\x00" as *u8)
      return ERR_ALIAS_UNKNOWN
  }
  if imp_alias_exports(ctx, k, src, nms, nmn) == 0 {
      imp_err("nx-import: REFUSED rule=ALIAS-NO-SUCH-EXPORT ns=\x00" as *u8)
      imp_err_span(ptr_at(src, s), nsn)
      imp_err(" name=\x00" as *u8)
      imp_err_span(ptr_at(src, nms), nmn)
      imp_err(" -- that module declares no top-level func, const or struct of that name\n\x00" as *u8)
      return ERR_ALIAS_NOEXPORT
  }
  let need: i64 = nsn + 2 + nmn
  if need > ocap { return ERR_ALIAS_LINE_CAP }
  u8_copy(out, ptr_at(src, s), nsn)
  out[nsn] = 0x5F
  out[nsn + 1] = 0x5F
  u8_copy(ptr_at(out, nsn + 2), ptr_at(src, nms), nmn)
  return need
755}
756
757// Rewrite one source line src[s..e) into dst. Applies qualification everywhere,
758// and this module's own mangling when alias_idx >= 0. st[0] carries the
759// top-level struct-body flag ACROSS lines; st[1] is this line's seen-an-
760// identifier flag. Returns bytes written or a negative ERR_*.
761//
762// WHEN alias_idx < 0 THE TRANSFORM IS LENGTH-PRESERVING (`::` and `__` are both
763// two bytes), so the caller passes dst = src + s and the rewrite happens IN
764// PLACE with no buffer at all. Every write lands on a byte already read, so
765// there is no aliasing hazard -- that is why the mangled separator is two
766// characters and not one.
767func imp_rw_line(ctx: *ExpandCtx, src: *u8, s: i64, e: i64, alias_idx: i64,
               dst: *u8, dcap: i64, st: *i64) -> i64 {
  var o: i64 = 0
  var p: i64 = s
  var instr: i64 = 0
  var incom: i64 = 0
  st[1] = 0
  var opens_struct: i64 = 0
  if imp_kw_at(src, s, "struct\x00" as *u8) == 1 { opens_struct = 1 }
  var closes_struct: i64 = 0
  if src[s] == 0x7D { closes_struct = 1 }
778
  while p < e {
      let c: i64 = src[p] as i64
      if incom == 1 {
          if o >= dcap { return ERR_ALIAS_LINE_CAP }
          dst[o] = src[p]
          o = o + 1
          p = p + 1
          continue
      }
      if instr == 1 {
          if c == 0x5C {
              if p + 1 < e {
                  if o + 1 >= dcap { return ERR_ALIAS_LINE_CAP }
                  dst[o] = src[p]
                  dst[o+1] = src[p+1]
                  o = o + 2
                  p = p + 2
                  continue
              }
          }
          if c == 0x22 { instr = 0 }
          if o >= dcap { return ERR_ALIAS_LINE_CAP }
          dst[o] = src[p]
          o = o + 1
          p = p + 1
          continue
      }
      if c == 0x22 {
          instr = 1
          if o >= dcap { return ERR_ALIAS_LINE_CAP }
          dst[o] = src[p]
          o = o + 1
          p = p + 1
          continue
      }
      if c == 0x2F {
          if src[p+1] == 0x2F { incom = 1 }
          if o >= dcap { return ERR_ALIAS_LINE_CAP }
          dst[o] = src[p]
          o = o + 1
          p = p + 1
          continue
      }
      if imp_ident_ch(c) == 0 {
          if o >= dcap { return ERR_ALIAS_LINE_CAP }
          dst[o] = src[p]
          o = o + 1
          p = p + 1
          continue
      }
      var q: i64 = p
      while q < e {
          if imp_ident_ch(src[q] as i64) == 0 { break }
          q = q + 1
      }
      let il: i64 = q - p
      var isqual: i64 = 0
      if q + 1 < e { if src[q] == 0x3A { if src[q+1] == 0x3A { isqual = 1 } } }
      if isqual == 1 {
          var r: i64 = q + 2
          while r < e {
              if imp_ident_ch(src[r] as i64) == 0 { break }
              r = r + 1
          }
          let wl: i64 = imp_qualified_name(ctx, src, p, r, ptr_at(dst, o), dcap - o)
          if wl < 0 { return wl }
          o = o + wl
          p = r
          st[1] = 1
          continue
      }
      var mangle: i64 = 0
      if alias_idx >= 0 {
          var blocked: i64 = 0
          if p > s { if src[p-1] == 0x2E { blocked = 1 } }
          if st[0] == 1 { if st[1] == 0 { blocked = 1 } }
          if blocked == 0 {
              if imp_alias_exports(ctx, alias_idx, src, p, il) == 1 { mangle = 1 }
          }
      }
      st[1] = 1
      if mangle == 1 {
          let an: *u8 = imp_alias_name(ctx, alias_idx)
          let al: i64 = cstr_len(an)
          if o + al + 2 + il > dcap { return ERR_ALIAS_LINE_CAP }
          u8_copy(ptr_at(dst, o), an, al)
          o = o + al
          dst[o] = 0x5F
          o = o + 1
          dst[o] = 0x5F
          o = o + 1
          u8_copy(ptr_at(dst, o), ptr_at(src, p), il)
          o = o + il
          p = q
          continue
      }
      if o + il > dcap { return ERR_ALIAS_LINE_CAP }
      u8_copy(ptr_at(dst, o), ptr_at(src, p), il)
      o = o + il
      p = q
  }
  if opens_struct == 1 { st[0] = 1 }
  if closes_struct == 1 { st[0] = 0 }
  return o
883}
884
885// Recursively expand `path` (relative or absolute) into ctx->out.
886// Returns 0 on success, or a negative ERR_* code on failure.
887// Match `func main(` (with optional leading whitespace already consumed)
888// at offset p in src.  Returns 1 if matched, 0 otherwise.  Used to
889// strip self-test main functions out of imported (non-root) files,
890// mirroring the C anchor's main.c logic so a self-host compile
891// doesn't produce N duplicate `main` symbols at link time.
892func is_func_main_line(src: *u8, p: i64) -> i64 {
  if src[p] != 0x66 { return 0 }       // 'f'
  if src[p+1] != 0x75 { return 0 }     // 'u'
  if src[p+2] != 0x6E { return 0 }     // 'n'
  if src[p+3] != 0x63 { return 0 }     // 'c'
  if src[p+4] != 0x20 { return 0 }     // ' '
  if src[p+5] != 0x6D { return 0 }     // 'm'
  if src[p+6] != 0x61 { return 0 }     // 'a'
  if src[p+7] != 0x69 { return 0 }     // 'i'
  if src[p+8] != 0x6E { return 0 }     // 'n'
  // followed by '(' or ' ('
  if src[p+9] == 0x28 { return 1 }     // '('
  if src[p+9] == 0x20 {
      if src[p+10] == 0x28 { return 1 }
  }
  return 0
908}
909
910// Skip past a `func main(...) ... { ... }` body, returning the new
911// cursor position past the closing '}' + trailing newline (if any).
912// STRING/COMMENT-AWARE (2026-08-04, debt 1785894599): the raw brace count died on
913// nx_js_lex's gate-main, whose KAT6 asserts the lexeme "}" -- the in-STRING 0x7D
914// closed the skip mid-body and spilled the rest of main to module level, where the
915// same-day strict stray-statement check (nx_parse 1785883072) refused the unit. The
916// dual failure is worse: a '{' inside a string OVER-skips and silently eats the
917// functions after main. Braces now count only outside "..." literals (backslash
918// escapes honored) and // line comments -- the same classes the real lexer tokenizes.
919func skip_func_main(src: *u8, p: i64) -> i64 {
  var q: i64 = p
  while src[q] != 0 {
      if src[q] == 0x7B { break }      // '{'
      q = q + 1
  }
  if src[q] == 0x7B {
      var depth: i64 = 1
      q = q + 1
      var instr: i64 = 0               // inside a "..." string literal
      var incom: i64 = 0               // inside a // line comment
      while src[q] != 0 {
          if depth == 0 { break }
          var c: i64 = src[q] as i64
          if incom == 1 {
              if c == 0x0A { incom = 0 }
              q = q + 1
          } else { if instr == 1 {
              if c == 0x5C {           // backslash: the escaped char is literal
                  q = q + 2
              } else {
                  if c == 0x22 { instr = 0 }
                  q = q + 1
              }
          } else {
              if c == 0x22 { instr = 1; q = q + 1 } else {
              if c == 0x2F {
                  var c2: i64 = src[q + 1] as i64
                  if c2 == 0x2F { incom = 1; q = q + 2 } else { q = q + 1 }
              } else {
                  if c == 0x7B { depth = depth + 1 }
                  if c == 0x7D { depth = depth - 1 }
                  q = q + 1
              } }
          } }
      }
  }
  while src[q] != 0 {
      if src[q] == 0x0A { break }
      q = q + 1
  }
  if src[q] == 0x0A { q = q + 1 }
  return q
962}
963
964// Forward decl so expand_imports can call expand_imports_inner
965// before it's defined (NishiLang requires top-down declaration
966// order today).
967func expand_imports_inner(ctx: *ExpandCtx, path: *u8, is_root: i64, alias_idx: i64) -> i64;
968
969// SITES-LIVE 2026-05-27 per operator full-blessing directive to get
970// nishifamily.com + andelinwest.com live on west NAS via native Nishi
971// containers. Resolver walk-up + sibling-subroot search: hub/foo.nx
972// imports bare nx_syscalls.nx (lives at runtime/) AND runtime/* imports
973// bare nx_search_query_parser.nx (lives at runtime/hub/). Walks parent
974// dirs + at each level tries known substrate subroots ("", "hub",
975// "wiki", "bin", "kernel"). Mirrors C bootstrap try_resolve_import.
976// (Earlier this session, I incorrectly edited runtime/import.nx --
977// that file is for the OLDER nxc.nx driver, not the native ELF's
978// nx_compile_x86.nx driver which imports THIS file. Lesson logged.)
979
980func file_exists(path: *u8) -> i64 {
  let fd: i64 = sys_openat_rd(path)
  if fd < 0 { return 0 }
  sys_close(fd)
  return 1
985}
986
987func try_subroot(dir: *u8, subroot: *u8, ipath: *u8,
                  scratch: *u8, out: *u8) -> i64 {
  let dir_n: i64 = cstr_len(dir)
  let sub_n: i64 = cstr_len(subroot)
  let ipath_n: i64 = cstr_len(ipath)
  var pos: i64 = 0
  if dir_n > 0 {
      u8_copy(ptr_at(scratch, pos), dir, dir_n)
      pos = pos + dir_n
      scratch[pos] = 0x2F
      pos = pos + 1
  }
  if sub_n > 0 {
      u8_copy(ptr_at(scratch, pos), subroot, sub_n)
      pos = pos + sub_n
      scratch[pos] = 0x2F
      pos = pos + 1
  }
  u8_copy(ptr_at(scratch, pos), ipath, ipath_n)
  pos = pos + ipath_n
  scratch[pos] = 0
  if file_exists(scratch) == 1 {
      u8_copy(out, scratch, pos + 1)
      return 1
  }
  return 0
1013}
1014
1015func try_resolve_import(dir: *u8, ipath: *u8, out: *u8) -> i64 {
  if ipath[0] == 0x2F {
      u8_copy(out, ipath, cstr_len(ipath) + 1)
      return 1
  }
  let trydir: *u8 = sys_mmap(IMPORT_PATH_LEN)
  let scratch: *u8 = sys_mmap(IMPORT_PATH_LEN)
  u8_copy(trydir, dir, cstr_len(dir) + 1)
  let empty: *u8 = sys_mmap(2)
  empty[0] = 0
  let sub_hub: *u8 = sys_mmap(8)
  sub_hub[0] = 0x68
  sub_hub[1] = 0x75
  sub_hub[2] = 0x62
  sub_hub[3] = 0
  let sub_wik: *u8 = sys_mmap(8)
  sub_wik[0] = 0x77
  sub_wik[1] = 0x69
  sub_wik[2] = 0x6B
  sub_wik[3] = 0x69
  sub_wik[4] = 0
  let sub_bin: *u8 = sys_mmap(8)
  sub_bin[0] = 0x62
  sub_bin[1] = 0x69
  sub_bin[2] = 0x6E
  sub_bin[3] = 0
  let sub_krn: *u8 = sys_mmap(8)
  sub_krn[0] = 0x6B
  sub_krn[1] = 0x65
  sub_krn[2] = 0x72
  sub_krn[3] = 0x6E
  sub_krn[4] = 0x65
  sub_krn[5] = 0x6C
  sub_krn[6] = 0
  // "_hdl_build" -- debt 1785608999: runtime/ entries could not import
  // _hdl_build/ modules (one-way ceiling; _hdl_build->runtime worked via
  // walk-up). Tried LAST at every level, so no import that resolves
  // today can change -- only previously-FAILING ones can start to.
  let sub_hdl: *u8 = sys_mmap(16)
  sub_hdl[0] = 0x5F
  sub_hdl[1] = 0x68
  sub_hdl[2] = 0x64
  sub_hdl[3] = 0x6C
  sub_hdl[4] = 0x5F
  sub_hdl[5] = 0x62
  sub_hdl[6] = 0x75
  sub_hdl[7] = 0x69
  sub_hdl[8] = 0x6C
  sub_hdl[9] = 0x64
  sub_hdl[10] = 0
  var hop: i64 = 0
  while hop < 16 {
      if try_subroot(trydir, empty,   ipath, scratch, out) == 1 { return 1 }
      if try_subroot(trydir, sub_hub, ipath, scratch, out) == 1 { return 1 }
      if try_subroot(trydir, sub_wik, ipath, scratch, out) == 1 { return 1 }
      if try_subroot(trydir, sub_bin, ipath, scratch, out) == 1 { return 1 }
      if try_subroot(trydir, sub_krn, ipath, scratch, out) == 1 { return 1 }
      if try_subroot(trydir, sub_hdl, ipath, scratch, out) == 1 { return 1 }
      let trydir_n: i64 = cstr_len(trydir)
      if trydir_n == 0 { break }
      var i: i64 = trydir_n - 1
      var found: i64 = 0
      while i >= 0 {
          if trydir[i] == 0x2F {
              trydir[i] = 0
              found = 1
              i = 0 - 1
          }
          if i >= 0 { i = i - 1 }
      }
      if found == 0 { trydir[0] = 0 }
      hop = hop + 1
  }
  join_path(dir, ipath, out)
  return 0
1090}
1091
1092// The public entry point is UNCHANGED, so no caller of this preprocessor had to
1093// be touched for LN14: the root file is by definition not an aliased module.
1094func expand_imports(ctx: *ExpandCtx, path: *u8) -> i64 {
  return expand_imports_inner(ctx, path, 1, 0 - 1)
1096}
1097
1098func expand_imports_inner(ctx: *ExpandCtx, path: *u8, is_root: i64, alias_idx: i64) -> i64 {
  // Canonicalise for dedupe.
  let abspath_raw: *u8 = sys_mmap(IMPORT_PATH_LEN)
  canonicalise_path(path, abspath_raw, ctx.scratch)
  let np: *i64 = ctx.n_paths
  let seen: i64 = imp_path_index(ctx.paths, *np, abspath_raw)
  if seen >= 0 {
      // LN14. A module's SYMBOL NAMES depend on whether it was aliased, so one
      // closure cannot reach the same module both ways: the plain importer's
      // calls would name symbols the aliased splice has already renamed away.
      // Refuse by name rather than silently serve whichever spelling arrived
      // first -- a wrong answer here compiles, links and runs.
      var clash: i64 = 0
      if alias_idx >= 0 { clash = 1 }
      if ctx.path_alias[seen] >= 0 { clash = 1 }
      if clash == 1 {
          imp_err("nx-import: REFUSED rule=ALIAS-MODULE-ALREADY-IMPORTED path=\x00" as *u8)
          imp_err(path)
          imp_err(" -- a module may be imported plainly OR under exactly one alias, never both\n\x00" as *u8)
          return ERR_ALIAS_CONFLICT
      }
      return 0
  }
  if import_add(ctx.paths, *np, abspath_raw) == 0 {
      return ERR_IMPORTS_FULL
  }
  ctx.path_alias[*np] = alias_idx
  *np = *np + 1
1126
  // Read the file.
  let len_raw: *u8 = sys_mmap(16)
  let len_out: *i64 = len_raw as *i64
  *len_out = 0
  let src: *u8 = sys_read_file(path, len_out)
  if src == (0 as *u8) { return ERR_READ_FAILED }
1133
  // LN14. An ALIASED module has its export surface collected BEFORE any of its
  // text is spliced, because the renamer must decide the very first identifier
  // on the very first line and cannot do that from a set it is still building.
  // One pass over bytes already in hand; nothing is re-read.
  if alias_idx >= 0 {
      let ecnt: i64 = imp_alias_scan_exports(ctx, alias_idx, src, *len_out)
      if ecnt < 0 { return ecnt }
  }
  // Struct-body state for imp_rw_line, carried across the lines of THIS frame.
  // Mapped lazily at the first line that actually needs rewriting, so a frame
  // in an unaliased closure allocates nothing.
  var sst: *i64 = 0 as *i64
1146
  // Compute this file's dir for resolving relative imports.
  let dir: *u8 = sys_mmap(IMPORT_PATH_LEN)
  path_dir(path, dir)
1150
  // LINE MAP -- span 1 of this frame. This file's region of the expanded buffer
  // begins at the current output line and starts at its own source line 1. Every
  // later span in this frame re-anchors the SAME file, so interning once is enough.
  // All four re-anchor points below exist for one reason: they are precisely the
  // places where the output line and the source line stop advancing together.
  let fid: i64 = lm_intern_file(ctx.lm, path)
  lm_add_span(ctx.lm, ctx.out_line, fid, 1)
  var src_line: i64 = 1
1159
  // Walk src line by line, BY MEASURED LENGTH, never to a NUL. LN24 root cause (2026-09-02): this walk
  // used `src[p] != 0`, so a raw NUL anywhere in a user file silently dropped the REST OF THAT FILE from
  // the unit before the lexer ever saw a byte of it -- an open literal then ran on into the next spliced
  // file (the auto-appended crash handler) and every error named nx_crash.nx (measured twice). The
  // lexer's desync attribution (diag_desync_origin) can only fire on bytes it receives, so the NUL must
  // pass through here and be refused THERE, by file and line, in the teaching voice.
  let n: i64 = *len_out
  var p: i64 = 0
  while p < n {
      // Leading whitespace scan, preserving cursor so we can copy
      // the original bytes if this line isn't an import.
      let line_start: i64 = p
      while src[p] == 0x20 { p = p + 1 }
      while src[p] == 0x09 { p = p + 1 }
1174
      // Strip `func main(...)` from non-root files so a self-host
      // compile doesn't see N duplicate main symbols.  Mirrors
      // main.c lines 228-274.
      if is_root == 0 {
          if is_func_main_line(src, p) == 1 {
              let mstart: i64 = p
              p = skip_func_main(src, p)
              // RE-ANCHOR 2: stripping a self-test main consumes SOURCE lines and
              // emits NO output, so the counters diverge by exactly the size of the
              // body we swallowed. Count it rather than estimate it.
              var mq: i64 = mstart
              while mq < p {
                  if src[mq] == 0x0A { src_line = src_line + 1 }
                  mq = mq + 1
              }
              lm_add_span(ctx.lm, ctx.out_line, fid, src_line)
              continue
          }
      }
1194
      if starts_with_import(src, p) == 1 {
          p = p + 7
          while src[p] == 0x20 { p = p + 1 }
          while src[p] == 0x09 { p = p + 1 }
          if src[p] != 0x22 { return ERR_BAD_IMPORT }
          p = p + 1
1201
          // Read quoted relative path.
          let ipath: *u8 = sys_mmap(IMPORT_PATH_LEN)
          var il: i64 = 0
          while p < n {
              if src[p] == 0x22 { break }
              if il + 1 >= IMPORT_PATH_LEN { return ERR_BAD_IMPORT }
              ipath[il] = src[p]
              il = il + 1
              p = p + 1
          }
          ipath[il] = 0
          if src[p] == 0x22 { p = p + 1 }
1214
          // LN14: the optional `as <ns>` clause. Recognised ONLY as the literal
          // two bytes `as` followed by a space or tab, immediately after the
          // closing quote and its whitespace -- so a trailing `// as ...`
          // comment cannot be mistaken for a namespace declaration.
          var al_idx: i64 = 0 - 1
          while src[p] == 0x20 { p = p + 1 }
          while src[p] == 0x09 { p = p + 1 }
          var has_as: i64 = 0
          if src[p] == 0x61 { if src[p+1] == 0x73 {
              if src[p+2] == 0x20 { has_as = 1 }
              if src[p+2] == 0x09 { has_as = 1 }
          } }
          if has_as == 1 {
              p = p + 2
              while src[p] == 0x20 { p = p + 1 }
              while src[p] == 0x09 { p = p + 1 }
              let ns_s: i64 = p
              while imp_ident_ch(src[p] as i64) == 1 { p = p + 1 }
              let ns_n: i64 = p - ns_s
              al_idx = imp_alias_add(ctx, src, ns_s, ns_n)
              if al_idx < 0 {
                  imp_err("nx-import: REFUSED rule=ALIAS-BAD-OR-DUPLICATE-NAMESPACE ns=\x00" as *u8)
                  imp_err_span(ptr_at(src, ns_s), ns_n)
                  imp_err(" -- a namespace name must be a non-empty identifier and may be declared once\n\x00" as *u8)
                  return al_idx
              }
          }
1242
          // Skip to end-of-line.
          while p < n {
              if src[p] == 0x0A { break }
              p = p + 1
          }
          if src[p] == 0x0A { p = p + 1; src_line = src_line + 1 }
1249
          // SITES-LIVE 2026-05-27: walk-up + sibling-subroot resolver
          // so hub/foo.nx can import bare runtime/* siblings + vice
          // versa. See try_resolve_import above.
          let full: *u8 = sys_mmap(IMPORT_PATH_LEN)
          try_resolve_import(dir, ipath, full)
1255
          // Recurse with is_root=0 so any nested file's `func main`
          // gets stripped (see top of expand_imports_inner).
          let rc: i64 = expand_imports_inner(ctx, full, 0, al_idx)
          if rc < 0 { return rc }
          // Terminating newline between spliced files.
          let rc2: i64 = out_push(ctx, 0x0A)
          if rc2 < 0 { return rc2 }
          // RE-ANCHOR 3: the nested file wrote an arbitrary number of output lines
          // (or ZERO, when the seen-set already had it). Re-anchor the PARENT here,
          // at the source line just past its own `import` statement. This is the span
          // that makes a diagnostic in file A stay attributed to A after A imports B.
          lm_add_span(ctx.lm, ctx.out_line, fid, src_line)
          continue
      }
1270
      // Not an import -- copy the whole line through. This is the ONLY path where
      // output and source advance in lockstep, which is why it needs no span: the
      // arithmetic in lm_lookup already covers it.
      //
      // ONE BOUNDED COPY PER LINE, NOT ONE CALL PER BYTE (2026-08-18, /compare/toolchain).
      // This loop used to route every byte of every non-import line through out_push --
      // a call, a cap check, an out_pos deref and a newline test per byte -- and it was
      // 30% of a typical gate's whole compile (measured 31 ms of 96 ms on a ~600 KB
      // expanded closure; the syscall census was ~250 calls, so the cost was pure CPU).
      // Now the line end is found first, the bytes [line_start, e) are copied once, and
      // only the terminating newline goes through out_push so ctx.out_line still advances
      // at the single chokepoint that owns it. Output bytes are IDENTICAL: the copied
      // span contains no 0x0A by construction, so nothing the counter would have seen is
      // skipped. The only observable difference is on OVERFLOW: a line that does not fit
      // is refused before any of it is written instead of after a partial write, and the
      // caller fails the compile on that code either way.
      p = line_start
      var e: i64 = p
      while e < n {
          if src[e] == 0x0A { break }
          e = e + 1
      }
      if e > p {
          // LN14. THE FAST PATH IS THE DEFAULT AND STAYS EXACTLY AS IT WAS.
          // A line is rewritten only when this frame is an aliased module, or
          // when some alias has been declared AND this line actually contains a
          // `::`. A closure with no `as` clause anywhere therefore takes the
          // identical bulk copy, byte for byte and branch for branch.
          var need_rw: i64 = 0
          if alias_idx >= 0 { need_rw = 1 }
          if need_rw == 0 {
              if ctx.al_n > 0 {
                  if imp_has_qual(src, p, e) == 1 { need_rw = 1 }
              }
          }
          var rcl: i64 = 0
          if need_rw == 0 {
              rcl = out_append_line(ctx, ptr_at(src, p), e - p)
          } else {
              if sst == (0 as *i64) {
                  let sst_raw: *u8 = sys_mmap(16)
                  sst = sst_raw as *i64
                  sst[0] = 0
                  sst[1] = 0
              }
              // An unaliased frame only ever turns `::` into `__`, which is
              // length-preserving, so it rewrites IN PLACE in its own private
              // copy of the source and needs no buffer. An aliased frame grows
              // lines and uses the buffer sized from its own longest line.
              var dst: *u8 = ptr_at(src, p)
              var dcap: i64 = e - p
              if alias_idx >= 0 {
                  dst = imp_alias_slot(ctx, alias_idx, AL_F_RWBUF) as *u8
                  dcap = imp_alias_slot(ctx, alias_idx, AL_F_RWCAP)
              }
              let wl: i64 = imp_rw_line(ctx, src, p, e, alias_idx, dst, dcap, sst)
              if wl < 0 { return wl }
              rcl = out_append_line(ctx, dst, wl)
          }
          if rcl < 0 { return rcl }
      }
      p = e
      if src[p] == 0x0A {
          let rc: i64 = out_push(ctx, 0x0A)
          if rc < 0 { return rc }
          p = p + 1
          src_line = src_line + 1
      }
  }
  return 0
1341}
nx_import.nx source

`nx_import.nx` source
