`nx_ale_exec.nx` source

↩ module page · 483 lines · 21480 B
1// nx_ale_exec.nx -- sovereign ALE agent-core EXECUTE/dispatch organ (rung ALE-R2b).
2// THE execute step the whole ALE-R2 agent-core routes through: it CONSUMES the ALE-R2a ordered
3// plan and the task spec and DISPATCHES each step IN ORDER over a sandbox working dir to produce a
4// REAL artifact file -- never re-planning, never opening the reference path. PURE function of:
5//   argv[1] = PLAN  path  (ALE-R2a plan: "step|<n>|<verb>|<arg>" lines, ordered from 1)
6//   argv[2] = TASK  path  (ALE-format task spec: "contract|field|value" lines)
7//   argv[3] = SANDBOX dir (the working dir; staged files + the artifact land here)
8// CONTRACT (data-driven; the step shape comes from ale_exec.spec / ale_plan.spec):
9//   REQUIRED task fields = materials_dir, input_stage, artifact_path. If ANY is absent the
10//   executor REFUSES: exit non-zero, produces NO artifact.
11//   The plan is walked TOP-TO-BOTHOM and consumed STRICTLY in order via a 3-state machine:
12//     step 1 must be stage_input  -> copies materials_dir/input_stage VERBATIM into sandbox/input_stage
13//     step 2 must be run_organ    -> applies the instruction's named DETERMINISTIC transform over the
14//                                    staged bytes (extract_kv_to_units: each "kv|k|v" -> "unit|k|v")
15//     step 3 must be write_artifact -> writes the transform output VERBATIM to sandbox/artifact_path
16//   Any out-of-order verb, an unknown transform token, or a plan MISSING write_artifact => REFUSE
17//   (exit non-zero, NO artifact). The executor reads ONLY argv[1..3] + materials_dir/input_stage;
18//   it NEVER opens the reference path -> the artifact is independent of reference presence (no
19//   leakage, enforced end-to-end). No clock, no rand -> two runs on the same (plan,task,fresh
20//   sandbox) yield a BYTE-IDENTICAL artifact (DETERMINISTIC).
21// Landmines respected: nested ifs (no &&/||), flat exprs, <=6 args/func, no empty-string literal,
22// strings via Write, openat_wr fresh path. Helpers mirror the ALE-R2a/R1a line-grammar (ae_*).
23// license_tier: ORIGINAL
24import "nx_syscalls.nx"
25const K_MAGIC_262144: i64 = 262144
26const K_MAGIC_8192: i64 = 8192
27const K_MAGIC_16384: i64 = 16384
28
29// read whole file at path into buf (cap), return byte count (0 on open-fail)
30func ae_read(path: *u8, buf: *u8, cap: i64) -> i64 {
  let fd: i64 = sys_openat_rd(path)
  if fd < 0 { return 0 }
  var n: i64 = 0
  var go: i64 = 1
  while go == 1 {
      let r: i64 = sys_read(fd, (buf as i64 + n) as *u8, cap - 1 - n)
      if r <= 0 { go = 0 } else { n = n + r }
      if n >= cap - 1 { go = 0 }
  }
  sys_close(fd)
  return n
42}
43
44// length of a C string
45func ae_len(s: *u8) -> i64 { var n: i64 = 0; while s[n] != (0 as u8) { n = n + 1 } return n }
46
47// does buf[pos..] match pat (len pl)?  1/0
48func ae_match(buf: *u8, n: i64, pos: i64, pat: *u8, pl: i64) -> i64 {
  if pos + pl > n { return 0 }
  var k: i64 = 0
  while k < pl {
      if buf[pos + k] != pat[k] { return 0 }
      k = k + 1
  }
  return 1
56}
57
58// is pos a line start? (pos==0 or previous byte is newline)
59func ae_is_bol(buf: *u8, pos: i64) -> i64 {
  if pos == 0 { return 1 }
  if buf[pos - 1] == (10 as u8) { return 1 }
  return 0
63}
64
65// find a line beginning with prefix; return its start index, or -1
66func ae_find_line(buf: *u8, n: i64, prefix: *u8) -> i64 {
  let pl: i64 = ae_len(prefix)
  var i: i64 = 0
  while i < n {
      if ae_is_bol(buf, i) == 1 {
          if ae_match(buf, n, i, prefix, pl) == 1 { return i }
      }
      i = i + 1
  }
  return 0 - 1
76}
77
78// Extract the VALUE of the field whose line starts with prefix: copy bytes from after the prefix
79// up to (not including) the end-of-line newline into out, NUL-terminate, return value length.
80// Returns -1 if the field line is absent (the GROUNDING check). cap bounds the copy.
81func ae_field_val(buf: *u8, n: i64, prefix: *u8, out: *u8, cap: i64) -> i64 {
  let start: i64 = ae_find_line(buf, n, prefix)
  if start < 0 { return 0 - 1 }
  let pl: i64 = ae_len(prefix)
  var p: i64 = start + pl
  var k: i64 = 0
  var go: i64 = 1
  while go == 1 {
      if p >= n { go = 0 } else {
          if buf[p] == (10 as u8) { go = 0 } else {
              if k < cap - 1 { out[k] = buf[p]; k = k + 1 }
              p = p + 1
          }
      }
  }
  out[k] = 0 as u8
  return k
98}
99
100// join a + "/" + b into out (NUL-terminated). a,b are NUL-terminated. returns length.
101func ae_join(a: *u8, b: *u8, out: *u8) -> i64 {
  var k: i64 = 0
  var i: i64 = 0
  while a[i] != (0 as u8) { out[k] = a[i]; k = k + 1; i = i + 1 }
  out[k] = 47 as u8; k = k + 1   // '/'
  var j: i64 = 0
  while b[j] != (0 as u8) { out[k] = b[j]; k = k + 1; j = j + 1 }
  out[k] = 0 as u8
  return k
110}
111
112// write n bytes from buf to a fresh file at path (mode 0644). 1 on success, 0 on open-fail.
113func ae_write_file(path: *u8, buf: *u8, n: i64) -> i64 {
  let fd: i64 = sys_openat_wr(path, 0x1a4)
  if fd < 0 { return 0 }
  if n > 0 { sys_write(fd, buf, n) }
  sys_close(fd)
  return 1
119}
120
121// the run_organ TRANSFORM extract_kv_to_units: for each staged line "kv|<rest>", emit
122// "unit|<rest>\n" into out (in input order). Non-"kv|" lines (comments/blanks) are skipped.
123// Returns the produced byte count. PURE function of the staged bytes (no clock/rand).
124func ae_transform_kv(inb: *u8, n: i64, out: *u8) -> i64 {
  var o: i64 = 0
  var i: i64 = 0
  while i < n {
      if ae_is_bol(inb, i) == 1 {
          if ae_match(inb, n, i, "kv|" as *u8, 3) == 1 {
              // emit "unit|" then the bytes after "kv|" up to and including the newline
              out[o] = 117 as u8; o = o + 1   // u
              out[o] = 110 as u8; o = o + 1   // n
              out[o] = 105 as u8; o = o + 1   // i
              out[o] = 116 as u8; o = o + 1   // t
              out[o] = 124 as u8; o = o + 1   // |
              var p: i64 = i + 3
              var go: i64 = 1
              while go == 1 {
                  if p >= n { out[o] = 10 as u8; o = o + 1; go = 0 } else {
                      if inb[p] == (10 as u8) { out[o] = 10 as u8; o = o + 1; p = p + 1; go = 0 } else {
                          out[o] = inb[p]; o = o + 1; p = p + 1
                      }
                  }
              }
          }
      }
      i = i + 1
  }
  return o
150}
151
152// the run_organ TRANSFORM copy_verbatim (ALE-R3a): the IDENTITY transform -- emit the staged
153// bytes UNCHANGED as the deliverable (artifact == staged input, byte-for-byte). PURE function of
154// the staged bytes: no clock, no rand, no synthesis. Returns the produced byte count (== n).
155func ae_transform_copy(inb: *u8, n: i64, out: *u8) -> i64 {
  var i: i64 = 0
  while i < n { out[i] = inb[i]; i = i + 1 }
  return n
159}
160
161// the run_organ TRANSFORM count_lines (ALE-R4 seed-task DATA/CLI domain skill): count the staged
162// input's newline-terminated lines and emit a SINGLE grading unit "unit|line_count|<N>\n". PURE
163// function of the staged bytes (no clock/rand): N = number of '\n' bytes. A DISTINCT skill
164// (aggregation/counting) beyond kv-extraction/identity-copy -- grows the agent's vocabulary so the
165// harness can measure a counting task end-to-end. Returns the produced byte count.
166func ae_transform_count(inb: *u8, n: i64, out: *u8) -> i64 {
  var lines: i64 = 0
  var i: i64 = 0
  while i < n { if inb[i] == (10 as u8) { lines = lines + 1 } i = i + 1 }
  var o: i64 = 0
  let pre: *u8 = "unit|line_count|" as *u8
  var j: i64 = 0
  while pre[j] != (0 as u8) { out[o] = pre[j]; o = o + 1; j = j + 1 }
  var m: i64 = lines
  let t: *u8 = sys_mmap(28)
  var k: i64 = 0
  if m == 0 { t[0] = 48 as u8; k = 1 }
  while m > 0 { t[k] = (48 + (m % 10)) as u8; m = m / 10; k = k + 1 }
  var p: i64 = 0
  while p < k { out[o] = t[k - 1 - p]; o = o + 1; p = p + 1 }
  out[o] = 10 as u8; o = o + 1
  return o
183}
184
185// find a line in buf (len n) beginning with pat (len pl) at a BOL; return its index, or -1.
186func ae_plan_find(buf: *u8, n: i64, pat: *u8, pl: i64) -> i64 {
  var i: i64 = 0
  while i < n {
      if ae_is_bol(buf, i) == 1 {
          if ae_match(buf, n, i, pat, pl) == 1 { return i }
      }
      i = i + 1
  }
  return 0 - 1
195}
196
197// read the verb of the plan step whose number is num into vbuf (cap); also copy its <arg> into
198// abuf (cap). A plan line is "step|<num>|<verb>|<arg>". Returns 1 if the step line was found, else 0.
199func ae_plan_step(buf: *u8, n: i64, num: i64, vbuf: *u8, abuf: *u8, cap: i64) -> i64 {
  // build prefix "step|<num>|"
  let pb: *u8 = sys_mmap(64)
  pb[0] = 115 as u8; pb[1] = 116 as u8; pb[2] = 101 as u8; pb[3] = 112 as u8; pb[4] = 124 as u8
  var m: i64 = num
  let t: *u8 = sys_mmap(28)
  var k: i64 = 0
  if m == 0 { t[0] = 48; k = 1 }
  while m > 0 { t[k] = (48 + (m % 10)) as u8; m = m / 10; k = k + 1 }
  var w: i64 = 5
  var j: i64 = 0
  while j < k { pb[w] = t[k - 1 - j]; w = w + 1; j = j + 1 }
  pb[w] = 124 as u8; w = w + 1; pb[w] = 0 as u8
  let pl: i64 = w
  let start: i64 = ae_plan_find(buf, n, pb, pl)
  if start < 0 { return 0 }
  // from start, skip the prefix (pl bytes) -> verb starts; copy verb to next '|'
  var q: i64 = start + pl
  var vk: i64 = 0
  var g1: i64 = 1
  while g1 == 1 {
      if q >= n { g1 = 0 } else {
          if buf[q] == (124 as u8) { g1 = 0 } else {
              if vk < cap - 1 { vbuf[vk] = buf[q]; vk = vk + 1 }
              q = q + 1
          }
      }
  }
  vbuf[vk] = 0 as u8
  // after the verb's '|' -> arg starts; copy arg to newline/EOF
  if q < n { q = q + 1 }
  var ak: i64 = 0
  var g2: i64 = 1
  while g2 == 1 {
      if q >= n { g2 = 0 } else {
          if buf[q] == (10 as u8) { g2 = 0 } else {
              if ak < cap - 1 { abuf[ak] = buf[q]; ak = ak + 1 }
              q = q + 1
          }
      }
  }
  abuf[ak] = 0 as u8
  return 1
242}
243
244// equal NUL-terminated strings?  1/0
245func ae_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
253}
254
255// does s start with prefix p (both NUL-terminated)?  1/0  (transform-token dispatch)
256func ae_starts(s: *u8, p: *u8) -> i64 {
  var i: i64 = 0
  while p[i] != (0 as u8) {
      if s[i] != p[i] { return 0 }
      i = i + 1
  }
  return 1
263}
264
265// the run_organ TRANSFORM sum_values (ALE-R5 RSI-loop: the capability BUILT to close the
266// data/sum-values-001 GAP the flywheel detected): sum the staged input's integer lines and emit a
267// SINGLE grading unit "unit|sum|<TOTAL>\n". PURE function of the staged bytes (no clock/rand): each
268// maximal digit-run terminated by newline/EOF is one integer; TOTAL = their sum. A distinct
269// arithmetic-aggregation skill. Returns the produced byte count.
270func ae_transform_sum(inb: *u8, n: i64, out: *u8) -> i64 {
  var total: i64 = 0
  var cur: i64 = 0
  var indig: i64 = 0
  var i: i64 = 0
  while i < n {
      let c: i64 = inb[i] as i64
      if c >= 48 { if c <= 57 { cur = cur * 10 + (c - 48); indig = 1 } }
      if c == 10 { if indig == 1 { total = total + cur } cur = 0; indig = 0 }
      i = i + 1
  }
  if indig == 1 { total = total + cur }
  var o: i64 = 0
  let pre: *u8 = "unit|sum|" as *u8
  var j: i64 = 0
  while pre[j] != (0 as u8) { out[o] = pre[j]; o = o + 1; j = j + 1 }
  var m: i64 = total
  let t: *u8 = sys_mmap(28)
  var k: i64 = 0
  if m == 0 { t[0] = 48 as u8; k = 1 }
  while m > 0 { t[k] = (48 + (m % 10)) as u8; m = m / 10; k = k + 1 }
  var p: i64 = 0
  while p < k { out[o] = t[k - 1 - p]; o = o + 1; p = p + 1 }
  out[o] = 10 as u8; o = o + 1
  return o
295}
296
297// parse helpers for the PARAMETERIZED reducer.
298func ae_rd_skipword(s: *u8, i: i64) -> i64 { var p: i64 = i; var g: i64 = 1; while g == 1 { if s[p] == (0 as u8) { g = 0 } else { if s[p] == (32 as u8) { g = 0 } else { p = p + 1 } } } return p }
299func ae_rd_skipsp(s: *u8, i: i64) -> i64 { var p: i64 = i; while s[p] == (32 as u8) { p = p + 1 } return p }
300func ae_rd_atoi(s: *u8, i: i64) -> i64 { var p: i64 = i; var neg: i64 = 0; if s[p] == (45 as u8) { neg = 1; p = p + 1 } var v: i64 = 0; var g: i64 = 1; while g == 1 { if s[p] >= (48 as u8) { if s[p] <= (57 as u8) { v = v * 10 + ((s[p] as i64) - 48); p = p + 1 } else { g = 0 } } else { g = 0 } } if neg == 1 { return 0 - v } return v }
301
302// the run_organ TRANSFORM reduce_op (PARAMETERIZED -- the evolutionary member's GENE TARGET): the
303// instruction "reduce_op <op> <init>" carries the genes (op in {add,mul,max,min}, init an integer).
304// acc=init; for each staged integer line v: add->acc+v mul->acc*v max->max min->min. Emits
305// "unit|reduced|<acc>". A GENERAL reducer: sum is (add,0), PRODUCT is (mul,1) -- genes nx_evolve
306// DISCOVERS (tier-1 search can't supply parameters; tier-2 evolution searches them). license_tier: ORIGINAL
307func ae_transform_reduce(inb: *u8, n: i64, out: *u8, args: *u8) -> i64 {
  var p: i64 = ae_rd_skipword(args, 0)
  p = ae_rd_skipsp(args, p)
  let op_at: i64 = p
  p = ae_rd_skipword(args, p)
  var op: i64 = 0
  if args[op_at] == (109 as u8) {
      if args[op_at+1] == (117 as u8) { op = 1 }
      if args[op_at+1] == (97 as u8) { op = 2 }
      if args[op_at+1] == (105 as u8) { op = 3 }
  }
  p = ae_rd_skipsp(args, p)
  let init: i64 = ae_rd_atoi(args, p)
  var acc: i64 = init
  var i: i64 = 0
  var cur: i64 = 0
  var indig: i64 = 0
  while i < n {
      let c: i64 = inb[i] as i64
      if c >= 48 { if c <= 57 { cur = cur * 10 + (c - 48); indig = 1 } }
      if c == 10 { if indig == 1 { if op == 0 { acc = acc + cur } if op == 1 { acc = acc * cur } if op == 2 { if cur > acc { acc = cur } } if op == 3 { if cur < acc { acc = cur } } } cur = 0; indig = 0 }
      i = i + 1
  }
  if indig == 1 { if op == 0 { acc = acc + cur } if op == 1 { acc = acc * cur } if op == 2 { if cur > acc { acc = cur } } if op == 3 { if cur < acc { acc = cur } } }
  var o: i64 = 0
  let pre: *u8 = "unit|reduced|" as *u8
  var j: i64 = 0
  while pre[j] != (0 as u8) { out[o] = pre[j]; o = o + 1; j = j + 1 }
  var m: i64 = acc
  if m < 0 { out[o] = 45 as u8; o = o + 1; m = 0 - m }
  let t: *u8 = sys_mmap(28)
  var k: i64 = 0
  if m == 0 { t[0] = 48 as u8; k = 1 }
  while m > 0 { t[k] = (48 + (m % 10)) as u8; m = m / 10; k = k + 1 }
  var q: i64 = 0
  while q < k { out[o] = t[k - 1 - q]; o = o + 1; q = q + 1 }
  out[o] = 10 as u8; o = o + 1
  return o
345}
346
347// ---- ALE-R3a: the run_organ TRANSFORM VOCABULARY as a DATA TABLE ----
348// The dispatch is data-driven: a parallel-array table of (token, transform-id) rows. Adding a
349// transform means adding ONE token-row here + one ae_transform_* fn -- the dispatch loop never
350// grows a per-transform if-chain. transform-id values are abstract handles (1,2,...); the run_organ
351// branch invokes the selected fn by id. Mirrors ale_exec.spec's `transform|<token>|...` rows.
352// ae_vocab_build fills caller arrays toks[] (token *u8) + ids[] (transform-id i64) and returns the
353// row count. cap bounds the row count.
354func ae_vocab_build(toks: *i64, ids: *i64, cap: i64) -> i64 {
  var c: i64 = 0
  if c < cap { toks[c] = "extract_kv_to_units" as *u8 as i64; ids[c] = 1; c = c + 1 }
  if c < cap { toks[c] = "copy_verbatim" as *u8 as i64; ids[c] = 2; c = c + 1 }
  if c < cap { toks[c] = "count_lines" as *u8 as i64; ids[c] = 3; c = c + 1 }
  if c < cap { toks[c] = "sum_values" as *u8 as i64; ids[c] = 4; c = c + 1 }
  if c < cap { toks[c] = "reduce_op" as *u8 as i64; ids[c] = 5; c = c + 1 }
  return c
362}
363
364// data-driven dispatch: return the transform-id whose token is a PREFIX of instruction s, or 0 if
365// no vocabulary token matches (unknown token -> the caller REFUSES). Walks the table in order.
366func ae_vocab_lookup(s: *u8, toks: *i64, ids: *i64, cnt: i64) -> i64 {
  var i: i64 = 0
  while i < cnt {
      let tk: *u8 = toks[i] as *u8
      if ae_starts(s, tk) == 1 { return ids[i] }
      i = i + 1
  }
  return 0
374}
375
376func main(argc: i64, argv: *i64) -> i64 {
  if argc < 4 { sys_exit(2); return 2 }
  let planp: *u8 = argv[1] as *u8
  let taskp: *u8 = argv[2] as *u8
  let sandbox: *u8 = argv[3] as *u8
381
  let pbuf: *u8 = sys_mmap(K_MAGIC_262144)
  let tbuf: *u8 = sys_mmap(K_MAGIC_262144)
  let pn: i64 = ae_read(planp, pbuf, K_MAGIC_262144)
  let tn: i64 = ae_read(taskp, tbuf, K_MAGIC_262144)
  if pn <= 0 { sys_exit(3); return 3 }
  if tn <= 0 { sys_exit(3); return 3 }
388
  // REQUIRED task fields; -1 => absent => REFUSE.
  let v_mat: *u8 = sys_mmap(K_MAGIC_8192)
  let v_in: *u8 = sys_mmap(K_MAGIC_8192)
  let v_art: *u8 = sys_mmap(K_MAGIC_8192)
  let lm: i64 = ae_field_val(tbuf, tn, "task|materials_dir|" as *u8, v_mat, K_MAGIC_8192)
  let lin: i64 = ae_field_val(tbuf, tn, "task|input_stage|" as *u8, v_in, K_MAGIC_8192)
  let lar: i64 = ae_field_val(tbuf, tn, "task|artifact_path|" as *u8, v_art, K_MAGIC_8192)
  var bad: i64 = 0
  if lm < 0 { bad = 1 }
  if lin < 0 { bad = 1 }
  if lar < 0 { bad = 1 }
  if bad == 1 { sys_exit(1); return 1 }
401
  // The plan MUST contain a write_artifact step or we refuse (no terminal deliverable).
  let has_wa: i64 = ae_plan_find(pbuf, pn, "step|3|write_artifact|" as *u8, 22)
  if has_wa < 0 { sys_exit(4); return 4 }
405
  // 3-state machine over plan steps 1,2,3 -- consumed STRICTLY in order.
  let vb: *u8 = sys_mmap(K_MAGIC_8192)
  let ab: *u8 = sys_mmap(K_MAGIC_8192)
  let content: *u8 = sys_mmap(K_MAGIC_262144)
  var contn: i64 = 0
  var staged: i64 = 0
  var transformed: i64 = 0
  var written: i64 = 0
  var step: i64 = 1
  var run: i64 = 1
416
  // ALE-R3a: build the run_organ transform-vocabulary table ONCE (token -> transform-id). The
  // run_organ branch dispatches DATA-DRIVEN off this table; no per-transform if-chain.
  let vtoks: *i64 = sys_mmap(256) as *i64
  let vids: *i64 = sys_mmap(256) as *i64
  let vcnt: i64 = ae_vocab_build(vtoks, vids, 16)
  while run == 1 {
      let found: i64 = ae_plan_step(pbuf, pn, step, vb, ab, K_MAGIC_8192)
      if found == 0 { run = 0 } else {
          // dispatch the verb of THIS step. order law: stage_input before run_organ before write_artifact.
          if ae_streq(vb, "stage_input" as *u8) == 1 {
              if step != 1 { sys_exit(5); return 5 }
              // copy materials_dir/input_stage -> sandbox/input_stage (verbatim bytes)
              let srcp: *u8 = sys_mmap(K_MAGIC_16384)
              ae_join(v_mat, v_in, srcp)
              let dstp: *u8 = sys_mmap(K_MAGIC_16384)
              ae_join(sandbox, v_in, dstp)
              let mbuf: *u8 = sys_mmap(K_MAGIC_262144)
              let mn: i64 = ae_read(srcp, mbuf, K_MAGIC_262144)
              if mn <= 0 { sys_exit(6); return 6 }
              let okw: i64 = ae_write_file(dstp, mbuf, mn)
              if okw == 0 { sys_exit(7); return 7 }
              staged = 1
          } else {
              if ae_streq(vb, "run_organ" as *u8) == 1 {
                  if staged != 1 { sys_exit(8); return 8 }
                  if step != 2 { sys_exit(8); return 8 }
                  // DATA-DRIVEN dispatch: look the instruction's leading token up in the vocabulary
                  // table (ab = plan step-2 arg) -> abstract transform-id. id 0 = unknown -> REFUSE.
                  let tid: i64 = ae_vocab_lookup(ab, vtoks, vids, vcnt)
                  if tid == 0 { sys_exit(10); return 10 }
                  // read the STAGED file (not the source) once; the selected transform consumes it.
                  let stagedp: *u8 = sys_mmap(K_MAGIC_16384)
                  ae_join(sandbox, v_in, stagedp)
                  let sbuf: *u8 = sys_mmap(K_MAGIC_262144)
                  let sn: i64 = ae_read(stagedp, sbuf, K_MAGIC_262144)
                  if sn <= 0 { sys_exit(9); return 9 }
                  // invoke the transform by its abstract id (composition dispatch, not a token if-chain).
                  if tid == 1 { contn = ae_transform_kv(sbuf, sn, content) }
                  if tid == 2 { contn = ae_transform_copy(sbuf, sn, content) }
                  if tid == 3 { contn = ae_transform_count(sbuf, sn, content) }
                  if tid == 4 { contn = ae_transform_sum(sbuf, sn, content) }
                  if tid == 5 { contn = ae_transform_reduce(sbuf, sn, content, ab) }
                  transformed = 1
              } else {
                  if ae_streq(vb, "write_artifact" as *u8) == 1 {
                      if transformed != 1 { sys_exit(11); return 11 }
                      if step != 3 { sys_exit(11); return 11 }
                      let artp: *u8 = sys_mmap(K_MAGIC_16384)
                      ae_join(sandbox, v_art, artp)
                      if contn <= 0 { sys_exit(12); return 12 }
                      let okw2: i64 = ae_write_file(artp, content, contn)
                      if okw2 == 0 { sys_exit(13); return 13 }
                      written = 1
                  } else {
                      // unknown verb -> REFUSE
                      sys_exit(14); return 14
                  }
              }
          }
          step = step + 1
      }
  }
479
  if written != 1 { sys_exit(15); return 15 }
  sys_exit(0)
  return 0
483}
nx_ale_exec.nx source

`nx_ale_exec.nx` source
