nomen-lang 0.6.11 → 0.6.13

package/core/System/Buffer.nm

@@ -93,6 +93,35 @@ pub struct Buffer<T> {
 		```
 	}
 
+	// Byte-width primitives (uint8 elements): the width-matched family the
+	// NEON planner's `.16b` descriptor keys on — one 16-byte group carries
+	// 16 lanes. `ldrb`/`strb` zero-extend/clobber exactly one byte.
+	internal inline func load_u8 = (self, int i: i >= 0 && i < self.cap, out uint8) {
+		```
+		#arch: c
+		return ((unsigned char*)(unsigned long long)self->data)[i];
+		```
+		```
+		#arch: aarch64
+		ldr x0, [x19, #8]
+		add x0, x0, x1
+		ldrb w0, [x0]
+		```
+	}
+
+	internal inline func store_u8 = (ref self, int i: i >= 0 && i < self.cap, uint8 val) {
+		```
+		#arch: c
+		((unsigned char*)(unsigned long long)self->data)[i] = val;
+		```
+		```
+		#arch: aarch64
+		ldr x0, [x19, #8]
+		add x0, x0, x1
+		strb w2, [x0]
+		```
+	}
+
 	internal func alloc_int = (ref self, int size, out int: out >= size) {
 		self.cap = size
 		self.data = calloc(size, 8)

package/dist/index.mjs

@@ -4815,6 +4815,7 @@ function instr_defs(instr) {
 	}
 	return defs;
 }
+let store_store_kill_on = process.env.NOMEN_SS_KILL !== "0";
 function optimize_frame_slots(code) {
 	const lines = code.split("\n");
 	const out = [];
@@ -4839,14 +4840,26 @@ function optimize_frame_slots(code) {
 	};
 	/** A register is REDEFINED: pends sourced from it must reach memory now
 	*  (deferring would store the new value); availability held in it dies.
-	*  Width siblings share fate (w/x and s/d views of one register). */
-	const clobber = (reg) => {
+	*  Width siblings share fate (w/x and s/d views of one register).
+	*  EXCEPTION (the store-store kill): when the block's NEXT access to
+	*  the pending slot is another STORE of the same family (no read, no
+	*  label/branch/call between), the orphaned store is unobservable —
+	*  the later store overwrites it before anything could read — and
+	*  drops instead of materializing. mul_to's carry-flag residue
+	*  (`str x0, [x29, #144]` twice per iteration of the hottest pidigits
+	*  loop, the value living in registers between) is exactly this
+	*  shape. */
+	const clobber = (reg, at_idx = -1) => {
 		if (!reg) return;
 		const sib = sibling_reg$1(reg);
 		zextW.delete(reg.startsWith("w") ? `x${reg.slice(1)}` : reg);
 		if (sib && sib.startsWith("x")) zextW.delete(sib);
 		for (const [off, s] of [...slots.entries()].sort((a, b) => a[0] - b[0])) {
 			if (s.pendText !== void 0 && s.pendReg && (s.pendReg === reg || sib !== null && s.pendReg === sib)) {
+				if (store_store_kill_on && at_idx >= 0 && s.pendIdx !== void 0 && no_slot_read_between(off, s.pendIdx + 1, at_idx) && next_slot_access_is_store(off, at_idx + 1)) {
+					slots.delete(off);
+					continue;
+				}
 				out.push(s.pendText);
 				slots.delete(off);
 				continue;
@@ -4857,7 +4870,44 @@ function optimize_frame_slots(code) {
 			}
 		}
 	};
-	function process_frame_access(instr, off) {
+	/** Whether any instruction in [from, to) READS slot `off` (or touches
+	*  it in a way the store-store reasoning cannot see through). */
+	const no_slot_read_between = (off, from, to) => {
+		for (let j = from; j < to && j < lines.length; j++) {
+			const t = (lines[j] ?? "").replace(/\/\/.*$/, "").trim();
+			if (!t) continue;
+			const m = t.match(/^(str|stur|ldr|ldur|strb|ldrb|strh|ldrh)\s+\S+,\s*\[x29,\s*#(\d+)\]$/);
+			if (m && parseInt(m[2], 10) === off && m[1].startsWith("ld")) return false;
+			if (/^(ldp|stp)\b/.test(t) && t.includes(`#${off}`)) return false;
+			if (/^add\b[^,]*,\s*x29\b/.test(t)) return false;
+			if (/^(bl|blr|br|svc|ret)\b/.test(t)) return false;
+			if (/^[A-Za-z_.$][\w.$]*:/.test(t)) return false;
+		}
+		return true;
+	};
+	const X29_SLOT_ANY = /\[x29,\s*#(\d+)\]/;
+	/** Whether the next access to `off` in the current block (from
+	*  `from` to the next label/branch/call boundary) is a STORE. Loads,
+	*  block boundaries, escape-prone address builds, and anything
+	*  unparseable answer false (the conservative materialize). */
+	const next_slot_access_is_store = (off, from) => {
+		for (let j = from; j < lines.length; j++) {
+			const t = (lines[j] ?? "").replace(/\/\/.*$/, "").trim();
+			if (!t) continue;
+			if (/^[A-Za-z_.$][\w.$]*:/.test(t)) return false;
+			if (/^b/.test(t)) return false;
+			if (/^(blr|br|svc|ret)\b/.test(t)) return false;
+			if (/^add\b[^,]*,\s*x29\b/.test(t)) return false;
+			if (/^(ldp|stp)\b/.test(t)) {
+				const pm = t.match(X29_SLOT_ANY);
+				return pm ? parseInt(pm[1], 10) === off && t.startsWith("stp") : false;
+			}
+			const m = t.match(/^(str|stur|ldr|ldur|strb|ldrb|strh|ldrh)\s+\S+,\s*\[x29,\s*#(\d+)\]$/);
+			if (m) return parseInt(m[2], 10) === off && m[1].startsWith("str");
+		}
+		return false;
+	};
+	function process_frame_access(instr, off, i) {
 		const data_reg = instr.operands[0];
 		if (data_reg.kind !== "reg") {
 			out.push(instr.text);
@@ -4880,7 +4930,7 @@ function optimize_frame_slots(code) {
 				slots.set(off, fresh);
 				return;
 			}
-			clobber(data_reg.name);
+			clobber(data_reg.name, i);
 		}
 		let s = slots.get(off);
 		if (!s) {
@@ -4892,7 +4942,8 @@ function optimize_frame_slots(code) {
 			slots.set(off, {
 				pendKey: key,
 				pendText: instr.text,
-				pendReg: data_reg.name
+				pendReg: data_reg.name,
+				pendIdx: i
 			});
 			return;
 		}
@@ -4952,7 +5003,7 @@ function optimize_frame_slots(code) {
 			const off = Number(instr.operands[2].value);
 			const next = parse_asm_instruction(lines[i + 1] ?? "", i + 2);
 			if (next && (next.op === "ldr" || next.op === "str") && next.operands.length === 2 && next.operands[1].kind === "mem" && next.operands[1].base === scratch && !next.operands[1].offset && !next.operands[1].scale && !next.operands[1].writeback) {
-				clobber(scratch);
+				clobber(scratch, i);
 				out.push(text);
 				const new_text = next.text.replace(/\[[^\]]*\]/, `[x29, #${off}]`);
 				process_frame_access({
@@ -4966,11 +5017,11 @@ function optimize_frame_slots(code) {
 							value: BigInt(off)
 						}
 					}]
-				}, off);
+				}, off, i);
 				i++;
 				continue;
 			}
-			clobber(scratch);
+			clobber(scratch, i);
 			flush_all();
 			clear_all();
 			out.push(text);
@@ -4991,7 +5042,7 @@ function optimize_frame_slots(code) {
 			continue;
 		}
 		if (mem && mem.kind === "mem" && mem.base === "x29" && mem.offset?.kind === "imm" && !mem.writeback) {
-			process_frame_access(instr, Number(mem.offset.value));
+			process_frame_access(instr, Number(mem.offset.value), i);
 			continue;
 		}
 		if (mem && mem.kind === "mem" && (mem.base === "x29" || mem.base === "fp") && (!mem.offset || mem.offset.kind === "reg" || mem.writeback)) {
@@ -5001,7 +5052,7 @@ function optimize_frame_slots(code) {
 			continue;
 		}
 		if (op === "bl" || op === "blr" || op === "br" || op === "svc") {
-			for (const r of CALLER_SAVED) clobber(r);
+			for (const r of CALLER_SAVED) clobber(r, i);
 			out.push(text);
 			continue;
 		}
@@ -5010,7 +5061,7 @@ function optimize_frame_slots(code) {
 			out.push(text);
 			continue;
 		}
-		for (const d of instr_defs(instr)) clobber(d);
+		for (const d of instr_defs(instr)) clobber(d, i);
 		const load_dst = instr.operands[0];
 		if ((op === "ldrb" || op === "ldrh" || op === "ldr") && load_dst.kind === "reg" && /^w\d+$/.test(load_dst.name)) zextW.set(`x${load_dst.name.slice(1)}`, op === "ldrb" ? 8 : op === "ldrh" ? 16 : 32);
 		out.push(text);
@@ -20884,10 +20935,12 @@ function build_function_node$1(node, status) {
 	if (moved_param_save_slots.size > 0 && node.name !== "main") {
 		const need_guard = return_is_class;
 		const need_save = !!node.return_type?.name;
+		const returns_fat_pair = node.return_type?.name === "string" && !node.return_type.is_array;
 		let return_save;
 		if (need_guard || need_save) {
-			return_save = allocate_stack_space(status, 8);
-			emit_asm(status, `str x0, [x29, #${return_save}]\n`);
+			return_save = allocate_stack_space(status, returns_fat_pair ? 16 : 8);
+			if (returns_fat_pair) emit_asm(status, `stp x0, x1, [x29, #${return_save}]\n`);
+			else emit_asm(status, `str x0, [x29, #${return_save}]\n`);
 		}
 		for (const [name, info] of moved_param_save_slots) {
 			if (moved_set?.has(name)) continue;
@@ -20913,7 +20966,10 @@ function build_function_node$1(node, status) {
 			emit_free(status);
 			if (need_guard) emit_asm(status, `${keep_prefix}_${name}:\n`);
 		}
-		if (need_guard || need_save) emit_asm(status, `ldr x0, [x29, #${return_save}]\n`);
+		if (need_guard || need_save) {
+			if (returns_fat_pair) emit_asm(status, `ldp x0, x1, [x29, #${return_save}]\n`);
+			else emit_asm(status, `ldr x0, [x29, #${return_save}]\n`);
+		}
 	}
 	const total_stack = Math.ceil((status.stack_size || 0) / 16) * 16;
 	status.code = status.code.replace(`sub sp, sp, #${stack_placeholder}`, total_stack > 0 ? `sub sp, sp, #${total_stack}` : `// no stack needed`);
@@ -22306,11 +22362,13 @@ function build_struct_functions$1(node, status) {
 		if (moved_param_save_slots.size > 0) {
 			const ret_is_class = !!func.return_type?.name && !!status.structs.find((s) => s.name === func.return_type.name && s.is_class);
 			const need_save = !!func.return_type?.name;
+			const returns_fat_pair = func.return_type?.name === "string" && !func.return_type.is_array;
 			const keep_prefix = `.Lkeep_mparam_${func_label.replace(/[^\w]/g, "_")}`;
 			let return_save;
 			if (ret_is_class || need_save) {
-				return_save = allocate_stack_space(status, 8);
-				emit_asm(status, `str x0, [x29, #${return_save}]\n`);
+				return_save = allocate_stack_space(status, returns_fat_pair ? 16 : 8);
+				if (returns_fat_pair) emit_asm(status, `stp x0, x1, [x29, #${return_save}]\n`);
+				else emit_asm(status, `str x0, [x29, #${return_save}]\n`);
 			}
 			for (const [name, info] of moved_param_save_slots) {
 				if (status.moved?.has(name) && !moved_before.has(name)) continue;
@@ -22336,7 +22394,10 @@ function build_struct_functions$1(node, status) {
 				emit_free(status);
 				if (ret_is_class) emit_asm(status, `${keep_prefix}_${name}:\n`);
 			}
-			if (ret_is_class || need_save) emit_asm(status, `ldr x0, [x29, #${return_save}]\n`);
+			if (ret_is_class || need_save) {
+				if (returns_fat_pair) emit_asm(status, `ldp x0, x1, [x29, #${return_save}]\n`);
+				else emit_asm(status, `ldr x0, [x29, #${return_save}]\n`);
+			}
 		}
 		const total_stack = Math.ceil((status.stack_size || 0) / 16) * 16;
 		status.code = status.code.replace(`sub sp, sp, #${stack_placeholder}`, total_stack > 0 ? `sub sp, sp, #${total_stack}` : `// no stack needed`);
@@ -25241,11 +25302,15 @@ function lane_reg_of(name, plan) {
 	const idx = temps.indexOf(name);
 	return TEMP_REGS[idx] ?? "v4";
 }
-function emit_lane_expr(e, status, plan, buffer_regs, idx, depth) {
+function emit_lane_expr(e, status, plan, buffer_regs, shifted_regs, idx, depth) {
 	switch (e.k) {
-		case "load":
-			emit_asm(status, `ldr q0, [${buffer_regs.get(e.buffer) ?? "x11"}, ${idx}, lsl #4]\n`);
+		case "load": {
+			const key = `${e.buffer} ${e.shift}`;
+			const shifted = shifted_regs.get(key);
+			if (shifted) emit_asm(status, `ldr q0, [${shifted}, ${idx}, lsl #4]\n`);
+			else emit_asm(status, `ldr q0, [${buffer_regs.get(e.buffer) ?? "x11"}, ${idx}, lsl #4]\n`);
 			return;
+		}
 		case "lit":
 		case "scalar":
 			if (plan.elem.float) {
@@ -25254,7 +25319,7 @@ function emit_lane_expr(e, status, plan, buffer_regs, idx, depth) {
 			} else {
 				build_node(e.node, status);
 				ensure_newline(status);
-				emit_asm(status, `dup v0.${plan.elem.arr}, ${plan.elem.arr === "4s" ? "w0" : "x0"}\n`);
+				emit_asm(status, `dup v0.${plan.elem.arr}, ${plan.elem.arr === "2d" ? "x0" : "w0"}\n`);
 			}
 			return;
 		case "temp":
@@ -25267,11 +25332,11 @@ function emit_lane_expr(e, status, plan, buffer_regs, idx, depth) {
 				const right_mul = left_mul ? null : mul_of(e.right);
 				const mul = left_mul ?? right_mul;
 				if (mul && (e.op === "+" || !left_mul)) {
-					emit_lane_expr(left_mul ? e.right : e.left, status, plan, buffer_regs, idx, depth + 1);
+					emit_lane_expr(left_mul ? e.right : e.left, status, plan, buffer_regs, shifted_regs, idx, depth + 1);
 					emit_asm(status, `mov v8.16b, v0.16b\n`);
-					emit_lane_expr(mul.left, status, plan, buffer_regs, idx, depth + 1);
+					emit_lane_expr(mul.left, status, plan, buffer_regs, shifted_regs, idx, depth + 1);
 					emit_asm(status, `mov ${spill_reg(depth + 1)}.16b, v0.16b\n`);
-					emit_lane_expr(mul.right, status, plan, buffer_regs, idx, depth + 1);
+					emit_lane_expr(mul.right, status, plan, buffer_regs, shifted_regs, idx, depth + 1);
 					emit_asm(status, `mov v1.16b, v0.16b\n`);
 					emit_asm(status, `mov v0.16b, ${spill_reg(depth + 1)}.16b\n`);
 					emit_asm(status, `${e.op === "+" ? "fmla" : "fmls"} v8.2d, v0.2d, v1.2d\n`);
@@ -25279,9 +25344,9 @@ function emit_lane_expr(e, status, plan, buffer_regs, idx, depth) {
 					return;
 				}
 			}
-			emit_lane_expr(e.left, status, plan, buffer_regs, idx, depth + 1);
+			emit_lane_expr(e.left, status, plan, buffer_regs, shifted_regs, idx, depth + 1);
 			emit_asm(status, `mov ${spill_reg(depth)}.16b, v0.16b\n`);
-			emit_lane_expr(e.right, status, plan, buffer_regs, idx, depth + 1);
+			emit_lane_expr(e.right, status, plan, buffer_regs, shifted_regs, idx, depth + 1);
 			emit_asm(status, `mov v1.16b, v0.16b\n`);
 			emit_asm(status, `mov v0.16b, ${spill_reg(depth)}.16b\n`);
 			const { mnemonic, arr } = lane_op(e.op, plan.elem);
@@ -25336,19 +25401,19 @@ function lane_op(op, elem) {
 		};
 	}
 }
-function emit_lane_stmt(lane, status, plan, buffer_regs, idx, acc_regs) {
+function emit_lane_stmt(lane, status, plan, buffer_regs, shifted_regs, idx, acc_regs) {
 	if (lane.kind === "temp_def") {
-		emit_lane_expr(lane.value, status, plan, buffer_regs, idx, 0);
+		emit_lane_expr(lane.value, status, plan, buffer_regs, shifted_regs, idx, 0);
 		emit_asm(status, `mov ${lane_reg_of(lane.name, plan)}.16b, v0.16b\n`);
 		return;
 	}
 	if (lane.kind === "reduction") {
-		emit_lane_expr(lane.operand, status, plan, buffer_regs, idx, 0);
+		emit_lane_expr(lane.operand, status, plan, buffer_regs, shifted_regs, idx, 0);
 		const acc = acc_regs.get(lane.name) ?? "v2";
 		emit_asm(status, `${lane.op === "+" ? plan.elem.float ? "fadd" : "add" : "fmul"} ${acc}.${plan.elem.arr}, ${acc}.${plan.elem.arr}, v0.${plan.elem.arr}\n`);
 		return;
 	}
-	emit_lane_expr(lane.value, status, plan, buffer_regs, idx, 0);
+	emit_lane_expr(lane.value, status, plan, buffer_regs, shifted_regs, idx, 0);
 	emit_asm(status, `str q0, [${buffer_regs.get(lane.buffer) ?? "x11"}, ${idx}, lsl #4]\n`);
 }
 /**
@@ -25381,6 +25446,37 @@ function emit_neon_vector_loop(plan, status) {
 		emit_asm(status, `ldr ${reg}, [x9, #8]\n`);
 		buffer_regs.set(b.name, reg);
 	});
+	const SHIFT_PTR_REGS = [
+		"x15",
+		"x16",
+		"x17"
+	];
+	const shifted_regs = /* @__PURE__ */ new Map();
+	{
+		const elem_size = 16 / plan.elem.group_elems;
+		let spi = 0;
+		const seen = /* @__PURE__ */ new Set();
+		const visit = (e) => {
+			if (!e) return;
+			if (e.k === "load" && e.shift > 0) {
+				const key = `${e.buffer} ${e.shift}`;
+				if (!seen.has(key)) {
+					seen.add(key);
+					if (spi >= SHIFT_PTR_REGS.length) return;
+					const base = buffer_regs.get(e.buffer) ?? "x11";
+					const reg = SHIFT_PTR_REGS[spi++];
+					emit_asm(status, `add ${reg}, ${base}, #${e.shift * elem_size}\n`);
+					shifted_regs.set(key, reg);
+				}
+			} else if (e.k === "op") {
+				visit(e.left);
+				visit(e.right);
+			}
+		};
+		for (const lane of plan.lanes) if (lane.kind === "store") visit(lane.value);
+		else if (lane.kind === "temp_def") visit(lane.value);
+		else if (lane.kind === "reduction") visit(lane.operand);
+	}
 	const acc_regs = /* @__PURE__ */ new Map();
 	plan.reductions.forEach((r, i) => {
 		const reg = REDUCTION_REGS[i] ?? "v2";
@@ -25390,12 +25486,13 @@ function emit_neon_vector_loop(plan, status) {
 		} else {
 			build_node(r.init_node, status);
 			ensure_newline(status);
-			emit_asm(status, `dup ${reg}.${plan.elem.arr}, ${plan.elem.arr === "4s" ? "w0" : "x0"}\n`);
+			emit_asm(status, `dup ${reg}.${plan.elem.arr}, ${plan.elem.arr === "2d" ? "x0" : "w0"}\n`);
 		}
 		acc_regs.set(r.name, reg);
 	});
 	build_node(plan.bound_node, status);
 	ensure_newline(status);
+	if (plan.max_shift > 0) emit_asm(status, `sub x0, x0, #${plan.max_shift}\n`);
 	emit_asm(status, `mov x9, x0\n`);
 	emit_asm(status, `asr x9, x9, #${shift}\n`);
 	emit_asm(status, `bic x9, x9, #1\n`);
@@ -25404,9 +25501,9 @@ function emit_neon_vector_loop(plan, status) {
 	emit_asm(status, `${label}:\n`);
 	emit_asm(status, `cmp x10, x9\n`);
 	emit_asm(status, `b.hs ${label}_end\n`);
-	for (const lane of plan.lanes) emit_lane_stmt(lane, status, plan, buffer_regs, "x10", acc_regs);
+	for (const lane of plan.lanes) emit_lane_stmt(lane, status, plan, buffer_regs, shifted_regs, "x10", acc_regs);
 	emit_asm(status, `add x14, x10, #1\n`);
-	for (const lane of plan.lanes) emit_lane_stmt(lane, status, plan, buffer_regs, "x14", acc_regs);
+	for (const lane of plan.lanes) emit_lane_stmt(lane, status, plan, buffer_regs, shifted_regs, "x14", acc_regs);
 	emit_asm(status, `add x10, x10, #2\n`);
 	emit_asm(status, `b ${label}\n`);
 	emit_asm(status, `${label}_end:\n`);
@@ -27213,8 +27310,9 @@ function flag_form_enabled() {
 *
 * Element kinds (tranche 2): the method pair determines the descriptor —
 * `load_float`/`store_float` (f64, `.2d`), `load_int`/`store_int` (8-byte
-* int, `.2d`), `load`/`store` (4-byte int, `.4s`). All accesses in one
-* loop must agree on the descriptor; lanes per group follow the width.
+* int, `.2d`), `load_u32`/`store_u32` (4-byte int, `.4s`),
+* `load_u8`/`store_u8` (byte, `.16b` — 16 lanes per group). All accesses in
+* one loop must agree on the descriptor; lanes per group follow the width.
 *
 * Soundness model (why this is legal):
 *
@@ -27223,12 +27321,24 @@ function flag_form_enabled() {
 *   a vector iteration touches the same element set the scalar iterations
 *   it replaces would. Lane k reads element base+k before lane k writes
 *   element base+k; no lane reads an element another lane writes, whatever
-*   buffers alias. This is why shifted indices (`load_float(i + 1)`) are
-*   rejected outright.
+*   buffers alias.
+* - SHIFTED READS (per-element event-order rule): `load_T(i + c)` with a
+*   LITERAL c >= 1 is admitted. Scalar iteration k reads base+k+c, which
+*   (c > 0) is written — if at all — at iteration k+c, AFTER the read; the
+*   vector group loads every lane before any lane stores, so the group
+*   sees exactly the scalar pre-group values (reads of elements the group
+*   itself writes land on their pre-group contents, matching scalar
+*   order). c <= 0 reads elements an EARLIER same-group lane wrote — the
+*   scalar loop would see the fresh value, the vector lanes would not —
+*   refused. STORES stay exact-induction. The trip limit shrinks by the
+*   max shift (max lane read = base+group-1+max_shift stays < bound);
+*   the scalar tail runs the original loop verbatim, so its own guard
+*   still covers the remainder.
 * - TRIP SEMANTICS: the vector loop runs whole 16-byte groups (unrolled to
-*   two groups per iteration); the limit is floor(N / group) rounded down
-*   to a multiple of the unroll — floor semantics keep every lane index
-*   < N for ANY signed bound (negative → loop skipped). The ORIGINAL
+*   two groups per iteration); the limit is floor((N - max_shift) / group)
+*   rounded down to a multiple of the unroll — floor semantics keep every
+*   lane index (+ its read shift) < N for ANY signed bound (negative →
+*   loop skipped). The ORIGINAL
 *   scalar loop is emitted unchanged afterwards as the tail (the induction
 *   is synced to the vector loop's exit counter first), covering the
 *   remainder — including the sub-unroll and negative-N cases where the
@@ -27262,6 +27372,9 @@ function flag_form_enabled() {
 /** Max distinct Buffers per plan — the preheader pins each data pointer in
 *  a dedicated scratch register (x11..x13). */
 const MAX_BUFFERS = 3;
+/** Adjusted read-pointer registers the emitter can materialize (one per
+*  distinct (buffer, shift > 0) pair -- x15/x16/x17, call-free bodies). */
+const MAX_SHIFTED_PTRS = 3;
 /** Max per-lane temps (v4..v7). */
 const MAX_TEMPS = 4;
 /** Max binary-op nesting depth in lane expressions (spill regs v14→v11). */
@@ -27295,10 +27408,18 @@ const ELEM_DESCS = [
 		arr: "4s",
 		group_elems: 4,
 		shift: 2
+	},
+	{
+		load: "load_u8",
+		store: "store_u8",
+		float: false,
+		arr: "16b",
+		group_elems: 16,
+		shift: 4
 	}
 ];
 function class_of_elem(elem) {
-	return elem.float ? "float" : elem.group_elems === 2 ? "e8" : "e4";
+	return elem.float ? "float" : elem.group_elems === 2 ? "e8" : elem.group_elems === 4 ? "e4" : "e1";
 }
 function class_of_type_name(name) {
 	if (!name) return null;
@@ -27307,6 +27428,7 @@ function class_of_type_name(name) {
 		const size = aarch64_size(name);
 		if (size === 8) return "e8";
 		if (size === 4) return "e4";
+		if (size === 1) return "e1";
 	} catch {}
 	return null;
 }
@@ -27558,7 +27680,15 @@ function alloc_temps_of(s, walk) {
 		if (has_allocations(d.value)) return null;
 		const cls = class_of_type_name(d.type?.name);
 		if (!cls) return null;
-		if (walk.elem && cls !== class_of_elem(walk.elem)) return null;
+		if (walk.elem && cls !== class_of_elem(walk.elem)) {
+			const nir = ast_to_nir_shallow(d.value);
+			if (!nir || shifted_index_of(nir, walk.induction) === null) return null;
+			out.push({
+				name: d.name,
+				value: d.value
+			});
+			continue;
+		}
 		walk.temp_classes.set(d.name, cls);
 		out.push({
 			name: d.name,
@@ -27567,6 +27697,24 @@ function alloc_temps_of(s, walk) {
 	}
 	return out;
 }
+/** `i + c` with i the induction and c an int literal >= 1 -- the shifted
+*  read index (event-order rule: scalar iteration k reads base+k+c before
+*  iteration k+c writes it; the vector group loads all lanes before any
+*  stores, so the group sees exactly the scalar pre-group values). */
+function shifted_index_of(e, induction) {
+	if (e.kind !== "binary") return null;
+	if (e.node.op !== "+") return null;
+	const lit_of = (x) => {
+		if (x.kind !== "leaf" || x.name) return null;
+		const v = node_value(x);
+		if (v === null || !/^\d+$/.test(v)) return null;
+		return Number(v);
+	};
+	const base_of = (x) => x.kind === "leaf" && x.name === induction;
+	const c = base_of(e.left) ? lit_of(e.right) : base_of(e.right) ? lit_of(e.left) : null;
+	if (c === null || c < 1) return null;
+	return c;
+}
 function lane_expr(e, walk, induction, status, depth) {
 	if (depth > walk.max_depth) walk.max_depth = depth;
 	if (depth > MAX_OP_DEPTH) return null;
@@ -27577,13 +27725,34 @@ function lane_expr(e, walk, induction, status, depth) {
 			if (e.receiver.kind !== "leaf" || !e.receiver.name) return null;
 			if (e.facts.args.length !== 1) return null;
 			const idx = e.facts.args[0];
-			if (idx.kind !== "leaf" || idx.name !== induction) return null;
+			let shift = 0;
+			if (idx.kind === "leaf") {
+				if (idx.name !== induction) {
+					const aliased = walk.induction_alias.get(idx.name);
+					if (aliased === void 0) return null;
+					shift = aliased;
+				}
+			} else if (idx.kind === "binary") {
+				const c = shifted_index_of(idx, induction);
+				if (c === null) return null;
+				shift = c;
+			} else return null;
 			if (!is_buffer_type_name(type_from_value_node$1(e.receiver.node)?.name ?? "")) return null;
 			if (buffer_index_of(walk, e.receiver.name, e.receiver.node) === null) return null;
+			if (shift > 0) {
+				const key = `${e.receiver.name} ${shift}`;
+				if (!walk.shifted.has(key)) walk.shifted.set(key, {
+					buffer: e.receiver.name,
+					node: e.receiver.node,
+					shift
+				});
+				if (walk.shifted.size > MAX_SHIFTED_PTRS) return null;
+			}
 			return {
 				k: "load",
 				buffer: e.receiver.name,
-				node: e.receiver.node
+				node: e.receiver.node,
+				shift
 			};
 		}
 		case "leaf": {
@@ -27780,6 +27949,26 @@ function extract_bound$1(bound, induction) {
 			name: null
 		};
 	}
+	if (bound.kind === "binary") {
+		const op_node = bound.node;
+		if (op_node.op !== "+" && op_node.op !== "-") return null;
+		const lit_of = (x) => x.kind === "leaf" && !x.name && node_value(x) !== null && INT_LIT_RE.test(node_value(x));
+		const base_name_of = (x) => {
+			if (x.kind === "path") return x.receiver.kind === "leaf" && x.receiver.name ? x.receiver.name : null;
+			if (x.kind === "leaf") return x.name ?? null;
+			return null;
+		};
+		let base = null;
+		if (op_node.op === "+") {
+			if (lit_of(bound.left)) base = base_name_of(bound.right);
+			else if (lit_of(bound.right)) base = base_name_of(bound.left);
+		} else if (lit_of(bound.right)) base = base_name_of(bound.left);
+		if (base === null || base === induction) return null;
+		return {
+			node: bound.node,
+			name: base
+		};
+	}
 	if (bound.kind !== "path") return null;
 	const root = bound.receiver;
 	if (root.kind !== "leaf" || !root.name || root.name === induction) return null;
@@ -27834,6 +28023,9 @@ function plan_common(lanes_raw, bound_node, bound_name, induction, index, list,
 				lanes: [],
 				buffers: [],
 				buffer_index: /* @__PURE__ */ new Map(),
+				shifted: /* @__PURE__ */ new Map(),
+				induction_alias: /* @__PURE__ */ new Map(),
+				induction,
 				temps: [],
 				defs,
 				defed_so_far: /* @__PURE__ */ new Set(),
@@ -27849,9 +28041,13 @@ function plan_common(lanes_raw, bound_node, bound_name, induction, index, list,
 			}
 			continue;
 		}
+		if (process.env.NOMEN_DBG_NEON) console.error(`NEON: [${status.current_function_name}] refuse: stmt kind ${s.kind}`);
+		return null;
+	}
+	if (bound_name !== null && defs.has(bound_name)) {
+		if (process.env.NOMEN_DBG_NEON) console.error(`NEON: [${status.current_function_name}] refuse: bound ${bound_name} defined in loop`);
 		return null;
 	}
-	if (bound_name !== null && defs.has(bound_name)) return null;
 	const reduction_inits = /* @__PURE__ */ new Map();
 	for (const name of reduction_candidates.keys()) {
 		const scan = scan_init(list, index, name);
@@ -27862,6 +28058,9 @@ function plan_common(lanes_raw, bound_node, bound_name, induction, index, list,
 		lanes: [],
 		buffers: [],
 		buffer_index: /* @__PURE__ */ new Map(),
+		shifted: /* @__PURE__ */ new Map(),
+		induction_alias: /* @__PURE__ */ new Map(),
+		induction,
 		temps: [],
 		defs,
 		defed_so_far: /* @__PURE__ */ new Set(),
@@ -27941,8 +28140,27 @@ function plan_common(lanes_raw, bound_node, bound_name, induction, index, list,
 		for (const t of temps) {
 			const nir = ast_to_nir_shallow(t.value);
 			if (!nir) return null;
+			const add = shifted_index_of(nir, induction);
+			if (add !== null) {
+				walk.induction_alias.set(t.name, add);
+				continue;
+			}
 			const tvalue = lane_expr(nir, walk, induction, status, 0);
-			if (!tvalue) return null;
+			if (!tvalue) {
+				if (process.env.NOMEN_DBG_NEON) {
+					const dump = (x, d) => {
+						if (!x || d > 3) return "?";
+						const nt = x.node?.node_type ?? "?";
+						const op = x.node?.op ?? x.node?.operator ?? "";
+						const val = x.node?.node_type === "value" ? `=${x.node.value}` : "";
+						const name = x.name ? `@${x.name}` : "";
+						const kids = x.left || x.right ? `(${dump(x.left, d + 1)} ${dump(x.right, d + 1)})` : x.inner !== void 0 ? `(${dump(x.inner, d + 1)})` : x.facts ? `(${x.args?.map((a) => dump(a, d + 1)).join(",")})` : "";
+						return `<${x.kind} ${nt}${op ? ":" + op : ""}${val}${name}${kids}>`;
+					};
+					console.error(`NEON: temp refused t=${t.name} ${dump(nir, 0)}`);
+				}
+				return null;
+			}
 			walk.defed_so_far.add(t.name);
 			walk.temps.push(t.name);
 			walk.lanes.push({
@@ -27960,17 +28178,41 @@ function plan_common(lanes_raw, bound_node, bound_name, induction, index, list,
 			value
 		});
 	}
-	if (walk.temps.length > MAX_TEMPS) return null;
-	if (!walk.lanes.some((l) => l.kind === "store") && reductions.length === 0) return null;
+	if (walk.temps.length > MAX_TEMPS) {
+		if (process.env.NOMEN_DBG_NEON) console.error(`NEON: [${status.current_function_name}] refuse: too many temps`);
+		return null;
+	}
+	if (!walk.lanes.some((l) => l.kind === "store") && reductions.length === 0) {
+		if (process.env.NOMEN_DBG_NEON) console.error(`NEON: [${status.current_function_name}] refuse: no store lane`);
+		return null;
+	}
 	if (!walk.elem) return null;
 	const want = class_of_elem(walk.elem);
-	for (const cls of walk.temp_classes.values()) if (cls !== want) return null;
+	for (const cls of walk.temp_classes.values()) if (cls !== want) {
+		if (process.env.NOMEN_DBG_NEON) console.error(`NEON: [${status.current_function_name}] refuse: temp class ${cls} != ${want}`);
+		return null;
+	}
 	if (reductions.length > MAX_REDUCTIONS) return null;
 	if (walk.temps.length > 0) {
 		const after = /* @__PURE__ */ new Set();
 		for (let k = index + 1; k < list.length; k++) stmt_reads(list[k], after);
-		for (const t of walk.temps) if (after.has(t)) return null;
+		for (const t of walk.temps) if (after.has(t)) {
+			if (process.env.NOMEN_DBG_NEON) console.error(`NEON: [${status.current_function_name}] refuse: temp ${t} read after loop`);
+			return null;
+		}
 	}
+	let max_shift = 0;
+	const scan_shift = (e) => {
+		if (!e) return;
+		if (e.k === "load" && e.shift > max_shift) max_shift = e.shift;
+		if (e.k === "op") {
+			scan_shift(e.left);
+			scan_shift(e.right);
+		}
+	};
+	for (const lane of walk.lanes) if (lane.kind === "store") scan_shift(lane.value);
+	else if (lane.kind === "temp_def") scan_shift(lane.value);
+	else if (lane.kind === "reduction") scan_shift(lane.operand);
 	return {
 		induction,
 		bound_node,
@@ -27978,7 +28220,8 @@ function plan_common(lanes_raw, bound_node, bound_name, induction, index, list,
 		buffers: walk.buffers,
 		elem: walk.elem,
 		reductions,
-		fma_contract: allow_reductions
+		fma_contract: allow_reductions,
+		max_shift
 	};
 }
 /**
@@ -28006,6 +28249,7 @@ function plan_vector_loop(nstmt, index, list, status) {
 	}
 	const init = scan_init(list, index, induction);
 	if (!init.ok || !init.init_node || !is_zero_ast_node(init.init_node)) return null;
+	if (process.env.NOMEN_DBG_NEON) console.error(`NEON: [${status.current_function_name}] loop@${index} reaching plan_common`);
 	return plan_common(lanes_raw, bound.node, bound.name, induction, index, list, status, status.fast_math === true);
 }
 /**
@@ -29638,6 +29882,12 @@ const active_splices = /* @__PURE__ */ new Set();
 function inline_splice_active(struct_name, func_name) {
 	return active_splices.has(`${struct_name}.${func_name}`);
 }
+/** How many inline splices are currently open (build_access_node passes
+*  this to is_auto_inline_method as the admission depth, so the emit-time
+*  chain cap agrees with the plan-time recursion). */
+function inline_splice_depth() {
+	return active_splices.size;
+}
 function begin_inline_splice(struct_name, func_name) {
 	active_splices.add(`${struct_name}.${func_name}`);
 }
@@ -29741,6 +29991,11 @@ function build_inline_method(struct_node, func, status) {
 	const old_return_buffer_offset = status.return_buffer_stack_offset;
 	const old_function_return_type = status.function_return_type;
 	const old_register_allocations = status.register_allocations;
+	const old_nir_site_allocs = status.nir_site_allocs;
+	const old_int_dest_hint = status.int_dest_hint;
+	const old_float_dest_hint = status.float_dest_hint;
+	status.int_dest_hint = void 0;
+	status.float_dest_hint = void 0;
 	const old_buffer_data_cache = status.buffer_data_cache;
 	const old_buffer_fold_cache = status.buffer_fold_cache;
 	const old_array_ptr_cache = status.array_ptr_cache;
@@ -29890,6 +30145,9 @@ function build_inline_method(struct_node, func, status) {
 	status.return_buffer_stack_offset = old_return_buffer_offset;
 	status.function_return_type = old_function_return_type;
 	status.register_allocations = old_register_allocations;
+	status.nir_site_allocs = old_nir_site_allocs;
+	status.int_dest_hint = old_int_dest_hint;
+	status.float_dest_hint = old_float_dest_hint;
 	status.buffer_data_cache = old_buffer_data_cache;
 	status.buffer_fold_cache = old_buffer_fold_cache;
 	status.array_ptr_cache = old_array_ptr_cache;
@@ -29920,6 +30178,11 @@ function build_inline_function(func, status) {
 	const old_return_buffer_offset = status.return_buffer_stack_offset;
 	const old_function_return_type = status.function_return_type;
 	const old_register_allocations = status.register_allocations;
+	const old_nir_site_allocs = status.nir_site_allocs;
+	const old_int_dest_hint = status.int_dest_hint;
+	const old_float_dest_hint = status.float_dest_hint;
+	status.int_dest_hint = void 0;
+	status.float_dest_hint = void 0;
 	const old_buffer_data_cache = status.buffer_data_cache;
 	const old_buffer_fold_cache = status.buffer_fold_cache;
 	const old_array_ptr_cache = status.array_ptr_cache;
@@ -30050,6 +30313,9 @@ function build_inline_function(func, status) {
 	status.return_buffer_stack_offset = old_return_buffer_offset;
 	status.function_return_type = old_function_return_type;
 	status.register_allocations = old_register_allocations;
+	status.nir_site_allocs = old_nir_site_allocs;
+	status.int_dest_hint = old_int_dest_hint;
+	status.float_dest_hint = old_float_dest_hint;
 	status.buffer_data_cache = old_buffer_data_cache;
 	status.buffer_fold_cache = old_buffer_fold_cache;
 	status.array_ptr_cache = old_array_ptr_cache;
@@ -44257,6 +44523,8 @@ function load_nursery_struct_address(target, status) {
 const MAX_STATEMENTS = 15;
 const MAX_AUTO_METHOD_STATEMENTS = 3;
 const MAX_AUTO_METHOD_PARAMS = 3;
+const MAX_AUTO_CALLING_STATEMENTS = 10;
+const MAX_AUTO_SPLICE_DEPTH = 2;
 /**
 * ensure/grow/clear-shaped methods (ASM_PLAN_7 tranche 7): small real
 * bodies the method-inline path can splice WITHOUT the explicit `inline`
@@ -44268,11 +44536,19 @@ const MAX_AUTO_METHOD_PARAMS = 3;
 * scalar-or-void return. The standalone body is still emitted — trait
 * dispatch, method values, and overflow-arg call sites keep taking the
 * `bl`, so nothing here may skip emission.
+*
+* `depth` is the number of inline splices already open at the dispatch
+* site (build_access_node passes `active_splices.size`); the admission
+* recursion for a candidate's callees runs at `depth + 1`, so a chain
+* deeper than MAX_AUTO_SPLICE_DEPTH is refused everywhere — the plan-time
+* and emit-time verdicts then agree.
 */
-function is_auto_inline_method(func) {
+function is_auto_inline_method(func, depth = 0) {
 	if (!func.has_body) return false;
 	if (func.is_inline) return false;
-	if (func.statements.length === 0 || func.statements.length > MAX_AUTO_METHOD_STATEMENTS) return false;
+	const calls = body_calls(func.statements);
+	const max_statements = calls || depth > 0 ? MAX_AUTO_CALLING_STATEMENTS : MAX_AUTO_METHOD_STATEMENTS;
+	if (func.statements.length === 0 || func.statements.length > max_statements) return false;
 	if (func.returns_move) return false;
 	if (func.statements.some((s) => s.node_type === "raw")) return false;
 	if (func.params.length > MAX_AUTO_METHOD_PARAMS) return false;
@@ -44295,22 +44571,55 @@ function is_auto_inline_method(func) {
 	if (func.return_type?.is_array || func.return_type?.is_view) return false;
 	if (func.return_type?.is_nullable) return false;
 	if (func.return_type?.name && !SIMPLE_TYPES.includes(func.return_type.name)) return false;
-	if (body_has_call(func.statements)) return false;
-	return true;
+	if (!calls) return true;
+	if (depth >= MAX_AUTO_SPLICE_DEPTH) return false;
+	return body_calls_splice_through(func.statements, depth);
 }
-/** Whether the subtree contains any call (method or function). */
-function body_has_call(node) {
+function body_calls(node) {
 	if (!node) return false;
 	if (Array.isArray(node)) {
-		for (const item of node) if (body_has_call(item)) return true;
+		for (const item of node) if (body_calls(item)) return true;
 		return false;
 	}
 	if (typeof node !== "object") return false;
 	const nt = node.node_type;
 	if (nt === "access_func" || nt === "func_call") return true;
-	for (const child of child_nodes(node)) if (body_has_call(child)) return true;
+	for (const child of child_nodes(node)) if (body_calls(child)) return true;
 	return false;
 }
+/**
+* The call-bearing cost model: every call in the subtree must either be
+* an `extern` (a `bl` whether the host splices or not — the expansion
+* changes nothing about the call count) or splice through — the callee is
+* a user-`inline` method (the splice path already handles call-bearing
+* user bodies) or itself admitted as an auto candidate at `depth + 1`.
+* Anything else keeps the host on the real `bl` path: expanding a call
+* whose callee cannot splice replaces one `bl` with the same `bl` plus
+* parking, which is the shape the tranche-7 receipts measured as a loss.
+*
+* `resolved_function` is the checker's stamp — present on every call the
+* checker accepted, and clone_node preserves it. A call without one is
+* refused (conservative).
+*/
+function body_calls_splice_through(node, depth) {
+	if (!node) return true;
+	if (Array.isArray(node)) {
+		for (const item of node) if (!body_calls_splice_through(item, depth)) return false;
+		return true;
+	}
+	if (typeof node !== "object") return true;
+	const any_node = node;
+	const nt = any_node.node_type;
+	if (nt === "access_func" || nt === "func_call") {
+		const callee = any_node.resolved_function;
+		if (!callee) return false;
+		if (callee.is_extern) return true;
+		if (callee.is_inline) return true;
+		return is_auto_inline_method(callee, depth + 1);
+	}
+	for (const child of child_nodes(node)) if (!body_calls_splice_through(child, depth)) return false;
+	return true;
+}
 function scan_inline_candidates(root) {
 	const counts = /* @__PURE__ */ new Map();
 	const defs = /* @__PURE__ */ new Map();
@@ -46110,7 +46419,7 @@ function build_access_method(node, access_func, status) {
 		}
 	}
 	const target_struct = status.structs.find((s) => s.name === mono_struct_name);
-	const inline_func = target_struct?.functions.find((f) => (f.is_inline || is_auto_inline_method(f)) && f.name === access_func.name && (access_func.mangled_name ? mangled_label(f, mono_struct_name) === access_func.mangled_name : true));
+	const inline_func = target_struct?.functions.find((f) => (f.is_inline || is_auto_inline_method(f, inline_splice_depth())) && f.name === access_func.name && (access_func.mangled_name ? mangled_label(f, mono_struct_name) === access_func.mangled_name : true));
 	const trait_target = status.traits.find((t) => t.name === target_type.name);
 	const trait_func = trait_target?.functions.find((f) => f.name === access_func.name);
 	if (trait_target && trait_func) {
@@ -50438,6 +50747,17 @@ function expr_to_string(node, status) {
 			}
 		}
 	}
+	if (node.node_type === "op") {
+		const op = node;
+		if (op.op === "+" || op.op === "-") {
+			const l = op.left_value ? expr_to_string(op.left_value, status) : void 0;
+			const r = op.right_value ? expr_to_string(op.right_value, status) : void 0;
+			if (l && r && !/^[+-]?\d+$/.test(l)) {
+				if (/^[+-]?\d+$/.test(r)) return `${l} ${op.op} ${r}`;
+				if (/^[A-Za-z_]\w*(\.\w+)*$/.test(r)) return `${l} ${op.op} ${r}`;
+			}
+		}
+	}
 }
 /**
 * Rewrite a `<base>.<field>` path through the assumed parallel-length
@@ -50678,6 +50998,19 @@ function apply_bounds(condition, status, is_loop = false) {
 			var_decl.path_bounds.set(bound.var_name, path_entry);
 		}
 	}
+	const expr_mirror_target = /^\w+(\.\w+)+$/.test(bound.expr) ? bound.expr.split(".")[0] : void 0;
+	let mirror_entry;
+	if (expr_mirror_target && bound.expr !== bound.var_name) {
+		const expr_decl = status.values.findLast((v) => v.name === expr_mirror_target);
+		if (expr_decl) {
+			if (!expr_decl.path_bounds) expr_decl.path_bounds = /* @__PURE__ */ new Map();
+			mirror_entry = expr_decl.path_bounds.get(bound.expr);
+			if (!mirror_entry) {
+				mirror_entry = {};
+				expr_decl.path_bounds.set(bound.expr, mirror_entry);
+			}
+		}
+	}
 	const push_unique = (arr, expr) => {
 		const out = arr ?? [];
 		if (!out.includes(expr)) out.push(expr);
@@ -50690,9 +51023,11 @@ function apply_bounds(condition, status, is_loop = false) {
 		if (inclusive) {
 			var_decl.upper_bound_inclusive_exprs = push_unique(var_decl.upper_bound_inclusive_exprs, bound.expr);
 			if (path_entry) path_entry.upper_inclusive = push_unique(path_entry.upper_inclusive, bound.expr);
+			if (mirror_entry && bound.var_name) mirror_entry.lower_inclusive = push_unique(mirror_entry.lower_inclusive, bound.var_name);
 		} else {
 			var_decl.upper_bound_exprs = push_unique(var_decl.upper_bound_exprs, bound.expr);
 			if (path_entry) path_entry.upper = push_unique(path_entry.upper, bound.expr);
+			if (mirror_entry && bound.var_name) mirror_entry.lower = push_unique(mirror_entry.lower, bound.var_name);
 		}
 		var_decl.upper_bound_expr = bound.expr;
 		const num = numeric_interval(string_to_node(bound.expr), status);
@@ -50712,16 +51047,21 @@ function apply_bounds(condition, status, is_loop = false) {
 		if (inclusive) {
 			var_decl.lower_bound_inclusive_exprs = push_unique(var_decl.lower_bound_inclusive_exprs, bound.expr);
 			if (path_entry) path_entry.lower_inclusive = push_unique(path_entry.lower_inclusive, bound.expr);
+			if (mirror_entry && bound.var_name) mirror_entry.upper_inclusive = push_unique(mirror_entry.upper_inclusive, bound.var_name);
 		} else {
 			var_decl.lower_bound_exprs = push_unique(var_decl.lower_bound_exprs, bound.expr);
 			if (path_entry) path_entry.lower = push_unique(path_entry.lower, bound.expr);
+			if (mirror_entry && bound.var_name) mirror_entry.upper = push_unique(mirror_entry.upper, bound.var_name);
 		}
 		var_decl.lower_bound_expr = bound.expr;
 		const num = numeric_interval(string_to_node(bound.expr), status);
 		if (num) {
 			const lo = bound.op === ">=" ? num.lower : num.upper;
 			if (var_decl.range_lower === void 0 || lo > var_decl.range_lower) var_decl.range_lower = lo;
-			if (path_entry && (path_entry.range_lower === void 0 || lo > path_entry.range_lower)) path_entry.range_lower = lo;
+			if (path_entry) {
+				if (is_loop) path_entry.range_lower = lo;
+				else if (path_entry.range_lower === void 0 || lo > path_entry.range_lower) path_entry.range_lower = lo;
+			}
 		}
 	}
 	apply_inverse_numeric_bound(bound, var_decl, status);
@@ -50848,6 +51188,39 @@ function apply_shifted_bound(condition, status, is_loop = false) {
 	}
 }
 /**
+* Sweep every stored fact that REFERENCES `token` (any variable reassigned
+* or shadowed, or bound through a `ref` argument): offset facts are only as
+* fresh as their offset operand, and facts live on the BOUNDED variable's
+* entry — a mutation of the offset variable would otherwise leave a stale
+* `j < n - d` in place after `d` changed. Entries whose OWN name matches
+* are skipped (their facts die by entry shadowing on the reassignment
+* itself).
+*/
+function invalidate_token_facts(token, status) {
+	const re = new RegExp(`\\b${token}\\b`);
+	const scrub = (arr) => {
+		if (!arr) return arr;
+		const out = arr.filter((e) => !re.test(e));
+		return out.length === arr.length ? arr : out.length > 0 ? out : void 0;
+	};
+	for (const v of status.values) {
+		if (v.name === token) continue;
+		if (!(v.upper_bound_exprs && v.upper_bound_exprs.some((e) => re.test(e)) || v.lower_bound_exprs && v.lower_bound_exprs.some((e) => re.test(e)) || v.upper_bound_inclusive_exprs && v.upper_bound_inclusive_exprs.some((e) => re.test(e)) || v.lower_bound_inclusive_exprs && v.lower_bound_inclusive_exprs.some((e) => re.test(e)))) continue;
+		v.upper_bound_exprs = scrub(v.upper_bound_exprs);
+		v.lower_bound_exprs = scrub(v.lower_bound_exprs);
+		v.upper_bound_inclusive_exprs = scrub(v.upper_bound_inclusive_exprs);
+		v.lower_bound_inclusive_exprs = scrub(v.lower_bound_inclusive_exprs);
+		if (v.upper_bound_expr && re.test(v.upper_bound_expr)) v.upper_bound_expr = void 0;
+		if (v.lower_bound_expr && re.test(v.lower_bound_expr)) v.lower_bound_expr = void 0;
+		if (v.path_bounds) for (const pb of v.path_bounds.values()) {
+			pb.upper = scrub(pb.upper);
+			pb.upper_inclusive = scrub(pb.upper_inclusive);
+			pb.lower = scrub(pb.lower);
+			pb.lower_inclusive = scrub(pb.lower_inclusive);
+		}
+	}
+}
+/**
 * Substitute `out` and parameter names in a return-constraint expression with
 * caller-side expressions. Used to translate a function's `out TYPE: contract`
 * into bounds on the caller's LHS variable.
@@ -51445,8 +51818,13 @@ function evaluate_operation(op, status) {
 					if (left_decl.upper_bound_exprs.some((u) => upper_implies(u, target_str))) return true;
 					for (const u of left_decl.upper_bound_exprs) {
 						const v = parse_offset_expr(u);
-						if (v && v.offset === 0 && u !== target_str) {
+						if (v && v.offset <= 0 && u !== target_str) {
 							const vdecl = status.values.findLast((vv) => vv.name === v.base);
+							const vpath = v.base.includes(".") ? status.values.findLast((vv) => vv.name === v.base.split(".")[0])?.path_bounds?.get(v.base) : void 0;
+							if (vpath) {
+								if (vpath.upper?.includes(target_str)) return true;
+								if (vpath.upper_inclusive?.includes(target_str)) return true;
+							}
 							if (vdecl?.upper_bound_exprs?.includes(target_str)) return true;
 							if (vdecl?.upper_bound_inclusive_exprs?.includes(target_str) && op.op === "<=") return true;
 							if (op.op === "<" && vdecl?.upper_bound_inclusive_exprs?.includes(target_str)) return true;
@@ -51458,8 +51836,13 @@ function evaluate_operation(op, status) {
 					if (left_decl.upper_bound_inclusive_exprs.some((u) => upper_implies(u, target_str))) return true;
 					for (const u of left_decl.upper_bound_inclusive_exprs) {
 						const v = parse_offset_expr(u);
-						if (v && v.offset === 0 && u !== target_str) {
+						if (v && v.offset <= 0 && u !== target_str) {
 							const vdecl = status.values.findLast((vv) => vv.name === v.base);
+							const vpath = v.base.includes(".") ? status.values.findLast((vv) => vv.name === v.base.split(".")[0])?.path_bounds?.get(v.base) : void 0;
+							if (vpath) {
+								if (vpath.upper?.includes(target_str)) return true;
+								if (vpath.upper_inclusive?.includes(target_str)) return true;
+							}
 							if (vdecl?.upper_bound_exprs?.includes(target_str)) return true;
 							if (vdecl?.upper_bound_inclusive_exprs?.includes(target_str)) return true;
 						}
@@ -52331,6 +52714,7 @@ function check_declaration_node(decl, status) {
 		});
 		if (decl.value) {
 			move_closure_source(decl.value, status);
+			invalidate_token_facts(decl.name, status);
 			track_assignment_bounds(decl.name, decl.value, status);
 		}
 	} else {
@@ -52455,7 +52839,10 @@ function check_declaration_node(decl, status) {
 			is_global: !in_function(status),
 			trait_slot_conformer: trait_slot_conformer_of_decl(declaration, decl.type, decl.value, status)
 		});
-		if (decl.value) track_assignment_bounds(decl.name, decl.value, status);
+		if (decl.value) {
+			invalidate_token_facts(decl.name, status);
+			track_assignment_bounds(decl.name, decl.value, status);
+		}
 		if (status.pending_return_bounds) {
 			const pending = status.pending_return_bounds.get(decl.name);
 			if (pending) {
@@ -56679,6 +57066,7 @@ function check_function_call(node, status, func, target_type, self_value, self_p
 		const param_type = type_from_value_node(param, status);
 		const param_value = value_from_value_node(param);
 		const has_ref_keyword = node.ref_param_indices?.includes(i) ?? false;
+		if (has_ref_keyword && param.node_type === "value") invalidate_token_facts(param.value, status);
 		if (func && func_param && func.has_body && (!func.scope || func.scope.node_type !== "struct") && !func.params.some((p) => p.is_self_param) && !func.address_escaped && !func_param.is_self_param && !func_param.is_variadic && !func_param.type.is_ref && !func_param.type.is_nullable && func_param.type.name && !is_owning_struct_type_requiring_move(func_param.type, status)) {
 			const owned_struct = status.structs.find((st) => st.name === func_param.type.name && !st.is_simple_type && !st.is_class);
 			if (owned_struct && !(owned_struct.traits ?? []).length && direct_string_fields(owned_struct).length > 0 && !struct_needs_destroy(owned_struct, status)) {
@@ -56827,18 +57215,56 @@ function check_function_call(node, status, func, target_type, self_value, self_p
 						if (base_path) base_name = base_path.split(".")[0];
 					}
 				}
+				let offset_token;
+				let offset_token_sign = 1;
+				if (!base_name && !base_path) {
+					const tok = (n) => n.node_type === "value" && /^[A-Za-z_]\w*$/.test(n.value) ? n.value : void 0;
+					if (pop.left_value.node_type === "value" && tok(pop.right_value)) {
+						base_name = pop.left_value.value;
+						offset_token = tok(pop.right_value);
+						offset_token_sign = pop.op === "-" ? -1 : 1;
+					} else if (pop.right_value.node_type === "value" && tok(pop.left_value)) {
+						base_name = pop.right_value.value;
+						offset_token = tok(pop.left_value);
+						offset_token_sign = pop.op === "-" ? -1 : 1;
+					}
+				}
 				if (base_name) {
 					const decl = status.values.findLast((v) => v.name === base_name);
 					if (decl) {
 						const shift = (exprs) => exprs?.map((e) => shift_offset_expr(e, c));
 						range_lower = decl.range_lower !== void 0 ? decl.range_lower + c : void 0;
 						range_upper = decl.range_upper !== void 0 ? decl.range_upper + c : void 0;
-						upper_bound_exprs = shift(decl.upper_bound_exprs);
-						lower_bound_exprs = shift(decl.lower_bound_exprs);
-						upper_bound_inclusive_exprs = shift(decl.upper_bound_inclusive_exprs);
-						lower_bound_inclusive_exprs = shift(decl.lower_bound_inclusive_exprs);
-						upper_bound_expr = decl.upper_bound_expr ? shift_offset_expr(decl.upper_bound_expr, c) : void 0;
-						lower_bound_expr = decl.lower_bound_expr ? shift_offset_expr(decl.lower_bound_expr, c) : void 0;
+						if (offset_token) {
+							range_upper = void 0;
+							range_lower = void 0;
+							if (offset_token_sign > 0 && decl.range_lower !== void 0) {
+								const tok_decl = status.values.findLast((v) => v.name === offset_token);
+								if (tok_decl?.range_lower !== void 0 && tok_decl.range_lower >= 0) range_lower = decl.range_lower;
+							}
+							const cancel = (exprs) => {
+								if (!exprs) return void 0;
+								const out = [];
+								for (const e of exprs) {
+									const m = e.match(new RegExp(`^(\\w+(?:\\.\\w+)*)\\s*([+-])\\s*${offset_token}$`));
+									if (m && m[2] === (offset_token_sign > 0 ? "-" : "+")) out.push(m[1]);
+								}
+								return out.length > 0 ? out : void 0;
+							};
+							upper_bound_exprs = cancel(decl.upper_bound_exprs);
+							lower_bound_exprs = cancel(decl.lower_bound_exprs);
+							upper_bound_inclusive_exprs = cancel(decl.upper_bound_inclusive_exprs);
+							lower_bound_inclusive_exprs = cancel(decl.lower_bound_inclusive_exprs);
+							upper_bound_expr = void 0;
+							lower_bound_expr = void 0;
+						} else {
+							upper_bound_exprs = shift(decl.upper_bound_exprs);
+							lower_bound_exprs = shift(decl.lower_bound_exprs);
+							upper_bound_inclusive_exprs = shift(decl.upper_bound_inclusive_exprs);
+							lower_bound_inclusive_exprs = shift(decl.lower_bound_inclusive_exprs);
+							upper_bound_expr = decl.upper_bound_expr ? shift_offset_expr(decl.upper_bound_expr, c) : void 0;
+							lower_bound_expr = decl.lower_bound_expr ? shift_offset_expr(decl.lower_bound_expr, c) : void 0;
+						}
 						alias_of = decl.alias_of ? shift_offset_expr(decl.alias_of, c) : base_path !== void 0 ? shift_offset_expr(base_path, c) : void 0;
 					}
 				}
@@ -58241,6 +58667,7 @@ function check_assignment_node(assign, status) {
 		const self_snapshot = left_value_name === left_value.name && (!is_compound && is_self_shifted(assign.right_value, left_value.name) || is_trackable_compound) ? snapshot_bounds(left_value.name, status) : void 0;
 		left_value.range_lower = void 0;
 		left_value.range_upper = void 0;
+		invalidate_token_facts(left_value.name, status);
 		left_value.upper_bound_expr = void 0;
 		left_value.lower_bound_expr = void 0;
 		left_value.upper_bound_exprs = void 0;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nomen-lang",
-  "version": "0.6.11",
+  "version": "0.6.13",
   "description": "The CLI for the Nomen programming language.",
   "keywords": [],
   "license": "ISC",