nomen-lang 0.0.16 → 0.0.17

package/core/System/Buffer.nm

@@ -356,7 +356,11 @@ pub struct Buffer<T> {
 		```
 	}
 
-	func load_T = (self, int i: i >= 0 && i < self.cap, out T) {
+	// `inline` splices the (width-folded at monomorphization) raw body at
+	// call sites — the load/store pair behind every container `.at`/`set` is
+	// the hottest path in data-heavy code, and the naked-inline path keeps it
+	// to a handful of instructions with no call overhead.
+	inline func load_T = (self, int i: i >= 0 && i < self.cap, out T) {
 		```
 		#arch: c
 		return ((T*)(unsigned long long)self->data)[i];
@@ -399,7 +403,7 @@ pub struct Buffer<T> {
 		```
 	}
 
-	func store_T = (ref self, int i: i >= 0 && i < self.cap, T val) {
+	inline func store_T = (ref self, int i: i >= 0 && i < self.cap, T val) {
 		```
 		#arch: c
 		((T*)(unsigned long long)self->data)[i] = val;

package/core/System/LinkedList.nm

@@ -57,6 +57,22 @@ pub struct LinkedList<T>: Enumerable {
 		return self.values.load_T(idx)
 	}
 
+	// Bounds-checked access: `fallback` when idx is outside [0, self.count).
+	pub func at_or = (self, int idx, T fallback, out T) {
+		if idx >= 0 && idx < self.count {
+			return self.at(idx)
+		}
+		return fallback
+	}
+
+	// Bounds-checked access that traps when idx is outside [0, self.count).
+	pub func at_or_panic = (self, int idx, out T) {
+		if idx >= 0 && idx < self.count {
+			return self.at(idx)
+		}
+		panic("index out of range")
+	}
+
 	pub func length = (self, out int) {
 		return self.count
 	}

package/core/System/List.nm

@@ -31,6 +31,26 @@ pub struct List<T>: Viewable {
 		return self.items.load_T(i)
 	}
 
+	// Bounds-checked access: `fallback` when i is outside [0, self.length) —
+	// for indices that can't be proven at compile time and out-of-range is an
+	// expected case.
+	pub func at_or = (self, int i, T fallback, out T) {
+		if i >= 0 && i < self.length {
+			return self.at(i)
+		}
+		return fallback
+	}
+
+	// Bounds-checked access that traps when i is outside [0, self.length) —
+	// for indices that can't be proven at compile time and out-of-range is a
+	// bug, not a case.
+	pub func at_or_panic = (self, int i, out T) {
+		if i >= 0 && i < self.length {
+			return self.at(i)
+		}
+		panic("index out of range")
+	}
+
 	// A non-owning `view T` over [start, end). Delegates to the backing Buffer's
 	// #arch slice primitive — no #arch code here. Borrows from self.
 	pub func slice = (self, int start: start >= 0, int end: end >= start, out view T) {

package/core/System/Map.nm

@@ -1,7 +1,12 @@
 /**
- * An ordered key-value map with `set`/`get`/`has`/`remove`. Keys must be
+ * An ordered key-value map with `set`/`get`/`get_or`/`has`/`remove`. Keys must be
  * `Hashable` (hashed to a `uint` via `key.hash()`) and `Equatable` (compared
  * with `==`); values may be any type.
+ *
+ * The capacity is always a power of two (initial 8, doubling on rehash), so
+ * bucket indexing is a mask (`hash & (cap - 1)`) instead of a division — and
+ * it is correct for negative hashes too: two's-complement `&` already lands
+ * in `[0, cap)`, which is why no negative adjustment is needed.
  **/
 pub struct Map<TK: Hashable + Equatable, TV> {
 	var length = 0
@@ -53,6 +58,34 @@ pub struct Map<TK: Hashable + Equatable, TV> {
 		return self.values.load_T(idx)
 	}
 
+	// Fused lookup-with-fallback: one probe instead of the `has` + `get`
+	// pair (which probes twice) for the common "default when missing" shape.
+	pub func get_or = (self, TK key, TV fallback, out TV) {
+		var int cap = self.keys.cap
+		if cap == 0 {
+			return fallback
+		}
+		var int idx = self.find_slot(key, cap)
+		if self.used.load(idx) == 0 {
+			return fallback
+		}
+		return self.values.load_T(idx)
+	}
+
+	// Lookup that traps when the key is absent — for when a missing key is
+	// a bug, not a case (and `get`'s 0-for-missing would be ambiguous).
+	pub func get_or_panic = (self, TK key, out TV) {
+		var int cap = self.keys.cap
+		if cap == 0 {
+			panic("key not found")
+		}
+		var int idx = self.find_slot(key, cap)
+		if self.used.load(idx) == 0 {
+			panic("key not found")
+		}
+		return self.values.load_T(idx)
+	}
+
 	pub func has = (self, TK key, out bool) {
 		var int cap = self.keys.cap
 		if cap == 0 {
@@ -91,10 +124,7 @@ pub struct Map<TK: Hashable + Equatable, TV> {
 			if self.used.load(k) == 0 {
 				break
 			}
-			var int home = (self.keys.load_T(k).hash() as int) % cap
-			if home < 0 {
-				home = home + cap
-			}
+			var int home = (self.keys.load_T(k).hash() as int) & (cap - 1)
 			var int dgap = gap - home
 			if dgap < 0 {
 				dgap = dgap + cap
@@ -115,10 +145,9 @@ pub struct Map<TK: Hashable + Equatable, TV> {
 	}
 
 	func find_slot = (self, TK key, int cap, out int: out >= 0 && out < cap) {
-		var int idx = (key.hash() as int) % cap
-		if idx < 0 {
-			idx = idx + cap
-		}
+		// cap is a power of two, so this is `hash mod cap` via a mask —
+		// non-negative for any hash (two's complement), no adjustment.
+		var int idx = (key.hash() as int) & (cap - 1)
 		while self.used.load(idx) != 0 {
 			if self.keys.load_T(idx) == key {
 				return idx

package/core/System/Set.nm

@@ -2,6 +2,10 @@
  * An ordered set of unique values (`add`/`has`/`get`/`remove`). Elements must
  * be `Hashable` (hashed to a `uint` via `value.hash()`) and `Equatable`
  * (compared with `==`).
+ *
+ * The capacity is always a power of two (initial 8, doubling on rehash), so
+ * slot indexing is a mask (`hash & (cap - 1)`) — correct for negative hashes
+ * too (two's-complement `&` already lands in `[0, cap)`).
  **/
 pub struct Set<T: Hashable + Equatable> {
 	var length = 0
@@ -47,6 +51,33 @@ pub struct Set<T: Hashable + Equatable> {
 		return self.slots.load_T(idx)
 	}
 
+	// Membership lookup with a fallback value: `fallback` when the value is
+	// not in the set (one probe instead of the `has` + `get` pair).
+	pub func get_or = (self, T key, T fallback, out T) {
+		var int cap = self.slots.cap
+		if cap == 0 {
+			return fallback
+		}
+		var int idx = self.find_slot(key, cap)
+		if self.used.load(idx) == 0 {
+			return fallback
+		}
+		return self.slots.load_T(idx)
+	}
+
+	// Membership lookup that traps when the value is not in the set.
+	pub func get_or_panic = (self, T key, out T) {
+		var int cap = self.slots.cap
+		if cap == 0 {
+			panic("value not found in set")
+		}
+		var int idx = self.find_slot(key, cap)
+		if self.used.load(idx) == 0 {
+			panic("value not found in set")
+		}
+		return self.slots.load_T(idx)
+	}
+
 	pub func remove = (ref self, T value) {
 		var int cap = self.slots.cap
 		if cap == 0 {
@@ -76,10 +107,7 @@ pub struct Set<T: Hashable + Equatable> {
 			if self.used.load(k) == 0 {
 				break
 			}
-			var int home = (self.slots.load_T(k).hash() as int) % cap
-			if home < 0 {
-				home = home + cap
-			}
+			var int home = (self.slots.load_T(k).hash() as int) & (cap - 1)
 			var int dgap = gap - home
 			if dgap < 0 {
 				dgap = dgap + cap
@@ -99,10 +127,9 @@ pub struct Set<T: Hashable + Equatable> {
 	}
 
 	func find_slot = (self, T value, int cap, out int: out >= 0 && out < cap) {
-		var int idx = (value.hash() as int) % cap
-		if idx < 0 {
-			idx = idx + cap
-		}
+		// cap is a power of two: `hash mod cap` via a mask, non-negative
+		// for any hash — no adjustment needed.
+		var int idx = (value.hash() as int) & (cap - 1)
 		while self.used.load(idx) != 0 {
 			if self.slots.load_T(idx) == value {
 				return idx

package/core/System/String.nm

@@ -51,6 +51,24 @@ pub struct string: Stringable, Hashable, Equatable {
 		```
 	}
 
+	// Bounds-checked access: `fallback` when index is outside
+	// [0, self.length).
+	pub func at_or = (self, int index, char fallback, out char) {
+		if index >= 0 && index < self.length {
+			return self.at(index)
+		}
+		return fallback
+	}
+
+	// Bounds-checked access that traps when index is outside
+	// [0, self.length) — out-of-range is a bug, not a case.
+	pub func at_or_panic = (self, int index, out char) {
+		if index >= 0 && index < self.length {
+			return self.at(index)
+		}
+		panic("index out of range")
+	}
+
 	// A non-owning slice [start, end) into self's buffer. Returns a `view
 	// string` (ptr, len) that borrows from self: it may not outlive self's
 	// scope and is invalidated if self is reassigned. Use .to_string() to

package/dist/index.mjs

@@ -11779,7 +11779,7 @@ function extract_aarch64_asm(func, platform) {
 	return asm;
 }
 function count_x19_reads(asm) {
-	const matches = asm.match(/\bx19\b/g);
+	const matches = asm.split("\n").map((l) => l.replace(/\/\/.*$/, "")).join("\n").match(/\bx19\b/g);
 	return matches ? matches.length : 0;
 }
 function build_naked_inline(struct_node, func, status) {
@@ -11787,6 +11787,8 @@ function build_naked_inline(struct_node, func, status) {
 	const standalone_return_label = `.return_${struct_node.name}_${func.name.replace(/#/g, "")}`;
 	asm = asm.replaceAll(`b ${standalone_return_label}`, "");
 	if (count_x19_reads(asm) === 1) asm = asm.replace(/\bx19\b/g, "x0");
+	const site = inline_counter++;
+	asm = asm.replace(/(\.L[A-Za-z0-9_]+)/g, `$1_${site}`);
 	status.code += asm + "\n";
 }
 function build_inline_method(struct_node, func, status) {
@@ -11811,9 +11813,11 @@ function build_inline_method(struct_node, func, status) {
 	const old_buffer_data_cache = status.buffer_data_cache;
 	const old_heap_cleanup_stack = status.heap_cleanup_stack;
 	const old_moved = status.moved;
+	const old_outer_scope_declarations = status.outer_scope_declarations;
 	const return_label = `.inline_ret_${inline_counter++}`;
 	status.function_return_label = return_label;
 	status.scoped_declarations = [];
+	status.outer_scope_declarations = [];
 	status.function_return_type = void 0;
 	status.struct_return_buffer = void 0;
 	status.return_buffer_stack_offset = void 0;
@@ -11900,6 +11904,7 @@ function build_inline_method(struct_node, func, status) {
 	status.buffer_data_cache = old_buffer_data_cache;
 	status.heap_cleanup_stack = old_heap_cleanup_stack;
 	status.moved = old_moved;
+	status.outer_scope_declarations = old_outer_scope_declarations;
 }
 let inline_fn_depth = 0;
 const MAX_INLINE_DEPTH = 2;
@@ -11919,9 +11924,11 @@ function build_inline_function(func, status) {
 	const old_buffer_data_cache = status.buffer_data_cache;
 	const old_heap_cleanup_stack = status.heap_cleanup_stack;
 	const old_moved = status.moved;
+	const old_outer_scope_declarations = status.outer_scope_declarations;
 	const return_label = `.inline_fn_ret_${inline_counter++}`;
 	status.function_return_label = return_label;
 	status.scoped_declarations = [];
+	status.outer_scope_declarations = [];
 	status.function_return_type = void 0;
 	status.struct_return_buffer = void 0;
 	status.return_buffer_stack_offset = void 0;
@@ -11996,6 +12003,7 @@ function build_inline_function(func, status) {
 	status.buffer_data_cache = old_buffer_data_cache;
 	status.heap_cleanup_stack = old_heap_cleanup_stack;
 	status.moved = old_moved;
+	status.outer_scope_declarations = old_outer_scope_declarations;
 	inline_fn_depth--;
 	return true;
 }
@@ -18257,7 +18265,7 @@ function build_value_node(node, status) {
 	else value = c_function_name(value);
 	if (value.startsWith("\"")) value = escape_c_string(value);
 	if (value !== "self" && status.function_ref_params?.has(value) && !status.suppress_dereference) status.code += `*`;
-	if (value === "self" && status.function_ref_params?.has("self") && !status.suppress_dereference) status.code += `*`;
+	if (value === "self" && status.function_ref_params?.has("self") && !status.suppress_dereference && status.current_struct?.name !== "string") status.code += `*`;
 	if (value !== "self" && status.ref_class_params?.has(value) && !status.suppress_dereference) {
 		status.code += `(*${value})`;
 		return;
@@ -20386,6 +20394,7 @@ function clone_node(node) {
 			c.return_constraint = n.return_constraint ? clone_node(n.return_constraint) : void 0;
 			c.returns_mov = n.returns_mov;
 			c.is_library = n.is_library;
+			c.is_inline = n.is_inline;
 			return c;
 		}
 		case "param": {
@@ -20954,6 +20963,40 @@ function snapshot_bounds(name, status) {
 		lower_bound_inclusive_exprs: decl.lower_bound_inclusive_exprs?.slice()
 	};
 }
+function snapshot_all_bounds(status) {
+	const snap = /* @__PURE__ */ new Map();
+	for (const v of status.values) snap.set(v, {
+		range_lower: v.range_lower,
+		range_upper: v.range_upper,
+		upper_bound_exprs: v.upper_bound_exprs?.slice(),
+		lower_bound_exprs: v.lower_bound_exprs?.slice(),
+		upper_bound_inclusive_exprs: v.upper_bound_inclusive_exprs?.slice(),
+		lower_bound_inclusive_exprs: v.lower_bound_inclusive_exprs?.slice(),
+		upper_bound_expr: v.upper_bound_expr,
+		lower_bound_expr: v.lower_bound_expr,
+		alias_of: v.alias_of,
+		known_length: v.known_length,
+		path_bounds: v.path_bounds ? new Map(v.path_bounds) : void 0
+	});
+	return snap;
+}
+function restore_all_bounds(status, snap) {
+	for (const v of status.values) {
+		const s = snap.get(v);
+		if (!s) continue;
+		v.range_lower = s.range_lower;
+		v.range_upper = s.range_upper;
+		v.upper_bound_exprs = s.upper_bound_exprs;
+		v.lower_bound_exprs = s.lower_bound_exprs;
+		v.upper_bound_inclusive_exprs = s.upper_bound_inclusive_exprs;
+		v.lower_bound_inclusive_exprs = s.lower_bound_inclusive_exprs;
+		v.upper_bound_expr = s.upper_bound_expr;
+		v.lower_bound_expr = s.lower_bound_expr;
+		v.alias_of = s.alias_of;
+		v.known_length = s.known_length;
+		v.path_bounds = s.path_bounds;
+	}
+}
 /**
 * Serialize an AST expression to a canonical string for comparison.
 * E.g. `list.length` → "list.length", `self.length` → resolves alias to actual var.
@@ -20963,7 +21006,7 @@ function expr_to_string(node, status) {
 		const vn = node;
 		if (status) {
 			const decl = status.values.findLast((v) => v.name === vn.value);
-			if (decl?.alias_of) return decl.alias_of;
+			if (decl?.alias_of) return canonicalize_length_path(decl.alias_of, status);
 		}
 		return vn.value;
 	}
@@ -20972,7 +21015,10 @@ function expr_to_string(node, status) {
 		if (access.access.node_type === "access_field") {
 			const target = expr_to_string(access.target, status);
 			const field = access.access.name;
-			if (target) return `${target}.${field}`;
+			if (target) {
+				const path = `${target}.${field}`;
+				return status ? canonicalize_length_path(path, status) : path;
+			}
 		} else if (access.access.node_type === "access_func") {
 			const target = expr_to_string(access.target, status);
 			const method = access.access.name;
@@ -20981,9 +21027,88 @@ function expr_to_string(node, status) {
 				"size",
 				"count",
 				"cap"
-			].includes(method)) return `${target}.${method}`;
-		}
-	}
+			].includes(method)) {
+				const path = `${target}.${method}`;
+				return status ? canonicalize_length_path(path, status) : path;
+			}
+		}
+	}
+}
+/**
+* Rewrite a `<base>.<field>` path through the assumed parallel-length
+* equalities (`a.length == b.length` param contracts) to a canonical
+* representative, so a bound phrased against either container's length
+* (`i < xs.length`) verifies a constraint on the other (`hash.length`).
+* Each equation's `a` side is the representative; following `b → a` edges
+* to a fixed point makes the rewrite idempotent and confluent for chains
+* (a==b, b==c all canonicalize to the chain head). Only touches paths whose
+* field has a recorded equation.
+*/
+function canonicalize_length_path(path, status) {
+	const eqs = status.equal_lengths;
+	if (!eqs?.length) return path;
+	const m = /^(\w+)\.(length|count|size|cap)$/.exec(path);
+	if (!m) return path;
+	const field = m[2];
+	let base = m[1];
+	for (let step = 0; step < eqs.length; step++) {
+		const eq = eqs.find((e) => e.field === field && (e.a === base || e.b === base));
+		if (!eq || eq.a === base) break;
+		base = eq.a;
+	}
+	return `${base}.${field}`;
+}
+/**
+* Remove `X.<f> == Y.<f>` clauses (same container-size field on two params,
+* one of them `param_name`) from a parameter constraint, recording each as an
+* ASSUMED parallel-length equality on `status.equal_lengths`. Such a clause
+* relates two runtime lengths, which the verifier can never prove at a call
+* site — instead it is trusted there (stripped from the contract) and made
+* available to the body's bounds machinery via expr_to_string
+* canonicalization. Returns the rewritten constraint, or undefined when
+* everything was stripped. Nodes are only rebuilt when something changed.
+*/
+function strip_length_equalities(constraint, param_name, status) {
+	if (!constraint) return void 0;
+	if (constraint.node_type !== "op") return constraint;
+	const op = constraint;
+	if (op.op === "&&") {
+		const left = strip_length_equalities(op.left_value, param_name, status);
+		const right = strip_length_equalities(op.right_value, param_name, status);
+		if (left && right) {
+			if (left === op.left_value && right === op.right_value) return constraint;
+			return new OperationNode(op.start, "&&", left, right, op.type);
+		}
+		return left ?? right;
+	}
+	if (op.op !== "==") return constraint;
+	const extract = (side) => {
+		if (side.node_type !== "access") return void 0;
+		const access = side;
+		let field;
+		if (access.access.node_type === "access_field") field = access.access.name;
+		else if (access.access.node_type === "access_func") field = access.access.name;
+		if (!field || !NON_NEGATIVE_FIELDS$1.has(field)) return void 0;
+		if (access.target.node_type !== "value") return void 0;
+		const base = access.target.value;
+		if (base !== param_name && !status.values.some((v) => v.name === base)) return void 0;
+		return {
+			base,
+			field
+		};
+	};
+	const lhs = extract(op.left_value);
+	const rhs = extract(op.right_value);
+	if (!lhs || !rhs || lhs.field !== rhs.field) return constraint;
+	if (lhs.base === rhs.base) return constraint;
+	if (!status.equal_lengths) status.equal_lengths = [];
+	const other = lhs.base;
+	const paired = rhs.base;
+	if (!status.equal_lengths.some((e) => e.field === lhs.field && (e.a === other && e.b === paired || e.a === paired && e.b === other))) status.equal_lengths.push({
+		a: other,
+		b: paired,
+		field: lhs.field
+	});
 }
 /**
 * Extract flow-sensitive bounds from a comparison condition.
@@ -21079,32 +21204,59 @@ function apply_bounds(condition, status, is_loop = false) {
 		var_decl = status.values.findLast((v) => v.name === base);
 	}
 	if (!var_decl) return;
+	let path_entry;
+	if (bound.var_name.includes(".") && bound.var_name !== var_decl.name) {
+		if (!var_decl.path_bounds) var_decl.path_bounds = /* @__PURE__ */ new Map();
+		path_entry = var_decl.path_bounds.get(bound.var_name);
+		if (!path_entry) {
+			path_entry = {};
+			var_decl.path_bounds.set(bound.var_name, path_entry);
+		}
+	}
+	const push_unique = (arr, expr) => {
+		const out = arr ?? [];
+		if (!out.includes(expr)) out.push(expr);
+		return out;
+	};
 	if (bound.op === "<" || bound.op === "<=") {
 		const inclusive = bound.op === "<=";
 		if (!var_decl.upper_bound_exprs) var_decl.upper_bound_exprs = [];
 		if (!var_decl.upper_bound_inclusive_exprs) var_decl.upper_bound_inclusive_exprs = [];
 		if (inclusive) {
-			if (!var_decl.upper_bound_inclusive_exprs.includes(bound.expr)) var_decl.upper_bound_inclusive_exprs.push(bound.expr);
-		} else if (!var_decl.upper_bound_exprs.includes(bound.expr)) var_decl.upper_bound_exprs.push(bound.expr);
+			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);
+		} 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);
+		}
 		var_decl.upper_bound_expr = bound.expr;
 		const num = numeric_interval(string_to_node(bound.expr), status);
 		if (num) {
 			const hi = bound.op === "<=" ? num.upper : num.lower;
 			if (is_loop) var_decl.range_upper = hi;
 			else if (var_decl.range_upper === void 0 || hi < var_decl.range_upper) var_decl.range_upper = hi;
+			if (path_entry) {
+				if (is_loop) path_entry.range_upper = hi;
+				else if (path_entry.range_upper === void 0 || hi < path_entry.range_upper) path_entry.range_upper = hi;
+			}
 		}
 	} else if (bound.op === ">" || bound.op === ">=") {
 		const inclusive = bound.op === ">=";
 		if (!var_decl.lower_bound_exprs) var_decl.lower_bound_exprs = [];
 		if (!var_decl.lower_bound_inclusive_exprs) var_decl.lower_bound_inclusive_exprs = [];
 		if (inclusive) {
-			if (!var_decl.lower_bound_inclusive_exprs.includes(bound.expr)) var_decl.lower_bound_inclusive_exprs.push(bound.expr);
-		} else if (!var_decl.lower_bound_exprs.includes(bound.expr)) var_decl.lower_bound_exprs.push(bound.expr);
+			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);
+		} 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);
+		}
 		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;
 		}
 	}
 	apply_inverse_numeric_bound(bound, var_decl, status);
@@ -21259,6 +21411,31 @@ function substitute_constraint(node, lhs_name, param_to_arg, visited = /* @__PUR
 	}
 	return node;
 }
+/** Extract `return_bounds` from a value node that is a call (or wraps one). */
+function call_return_bounds(value) {
+	if (!value) return void 0;
+	if (value.node_type === "func_call" || value.node_type === "access_func") return value.return_bounds;
+	if (value.node_type === "access" && value.access.node_type === "access_func") return value.access.return_bounds;
+}
+/**
+* Transfer a call's return-contract bounds onto the variable the call result
+* is bound to (`const int m = mid(xs)` / `m = mid(xs)`). Without this, only
+* the nested form `xs.at(mid(xs))` carried the contract (via the call node's
+* `return_bounds` decoration); binding to a variable dropped it and forced
+* unreadable nesting. Uses the same funneled semantics as the nested path
+* (collect_return_bounds: `<=` lands in the strict `upper` array), so both
+* forms verify identically.
+*/
+function apply_return_bounds_to_var(name, rb, status) {
+	if (!rb) return;
+	const decl = status.values.findLast((v) => v.name === name);
+	if (!decl) return;
+	const push = (arr, add) => arr ? (arr.push(...add.filter((e) => !arr.includes(e))), arr) : add.slice();
+	if (rb.upper.length) decl.upper_bound_exprs = push(decl.upper_bound_exprs, rb.upper);
+	if (rb.lower.length) decl.lower_bound_exprs = push(decl.lower_bound_exprs, rb.lower);
+	if (rb.upper_inclusive.length) decl.upper_bound_inclusive_exprs = push(decl.upper_bound_inclusive_exprs, rb.upper_inclusive);
+	if (rb.lower_inclusive.length) decl.lower_bound_inclusive_exprs = push(decl.lower_bound_inclusive_exprs, rb.lower_inclusive);
+}
 /**
 * Build an expression node tree from a dotted path string (e.g. "list",
 * "self.items") for use in return-contract substitution. Used to map `self`
@@ -22474,6 +22651,18 @@ function check_function_call(node, status, func, target_type, self_value, self_p
 			if (access.access.node_type === "access_field") field_name = access.access.name;
 			else if (access.access.node_type === "access_func") field_name = access.access.name;
 			if (field_name && NON_NEGATIVE_FIELDS.has(field_name)) alias_of = expr_to_string(param, status);
+			const access_path = expr_to_string(param, status);
+			if (access_path && access_path.includes(".")) {
+				const path_bounds = status.values.findLast((v) => v.name === access_path.split(".")[0])?.path_bounds?.get(access_path);
+				if (path_bounds) {
+					upper_bound_exprs = path_bounds.upper?.slice();
+					lower_bound_exprs = path_bounds.lower?.slice();
+					upper_bound_inclusive_exprs = path_bounds.upper_inclusive?.slice();
+					lower_bound_inclusive_exprs = path_bounds.lower_inclusive?.slice();
+					range_lower = path_bounds.range_lower;
+					range_upper = path_bounds.range_upper;
+				}
+			}
 		}
 		let nested_rb;
 		if (param.node_type === "func_call" || param.node_type === "access_func") nested_rb = param.return_bounds;
@@ -22692,6 +22881,222 @@ function receiver_is_const(target_type, self_value, status) {
 	return !!binding && binding.declaration === "const" && !binding.type.is_ref;
 }
 //#endregion
+//#region ../src/build_common/fold_asm_constants.ts
+/**
+* A tiny constant-propagation peephole over monomorphized raw aarch64
+* assembly (`#arch: aarch64` blocks after T → concrete-type substitution).
+*
+* Raw library code is written generically: `mov x3, #T_SIZE` followed by a
+* runtime width dispatch (`cmp x3, #8 / b.gt … / cmp x3, #1 / b.eq …`).
+* After substitution T_SIZE is a literal, so every dispatched branch has a
+* compile-time outcome — but as TEXT, so nothing folds it. This pass tracks
+* `mov <reg>, #<imm>` definitions per basic block and:
+*
+*   - folds `cmp <reg>, #<imm>` + following `b.<cond> <label>` when the
+*     comparison's outcome is known: never-taken branches are dropped,
+*     always-taken ones become unconditional `b <label>`,
+*   - rewrites `madd <d>, <n>, <m>, xzr` / `mul <d>, <n>, <m>` as
+*     `lsl <d>, <n>, #<log2>` when `<m>` is a known power-of-two constant
+*     (the element-stride multiply in every load_T/store_T body).
+*
+* Soundness: a register's definition is only tracked from its immediate
+* `mov` to its next write; the map is cleared at labels (jump targets may
+* arrive with different values), at unconditional branches, at calls
+* (`bl`/`blr` clobber the caller-saved set), and at any instruction form we
+* do not model. Dead code left behind dropped branches (e.g. the
+* width-matched tails and the memcpy copy path) stays in place — it is
+* unreachable, and removing it would require a full reachability pass.
+* Comments (`// …`) are ignored.
+*/
+const REG = /^[wx][0-9]+$/;
+const COND_OPS = /* @__PURE__ */ new Set([
+	"eq",
+	"ne",
+	"gt",
+	"ge",
+	"lt",
+	"le",
+	"hi",
+	"hs",
+	"lo",
+	"ls",
+	"al"
+]);
+function split_comment(line) {
+	return line.replace(/\/\/.*$/, "");
+}
+/** Does `a <cond> b` hold? (signed semantics; immediates here are small.) */
+function cond_holds(cond, a, b) {
+	switch (cond) {
+		case "eq": return a === b;
+		case "ne": return a !== b;
+		case "gt": return a > b;
+		case "ge": return a >= b;
+		case "lt": return a < b;
+		case "le": return a <= b;
+		case "hi": return a > b;
+		case "hs": return a >= b;
+		case "lo": return a < b;
+		case "ls": return a <= b;
+		case "al": return true;
+		default: return false;
+	}
+}
+function is_pow2(n) {
+	if (n > 0 && (n & n - 1) === 0) return Math.log2(n);
+}
+function fold_asm_constants(asm) {
+	const lines = asm.split("\n");
+	const out = [];
+	const defs = /* @__PURE__ */ new Map();
+	const clear = () => defs.clear();
+	/** Invalidate the destination register of a general instruction. */
+	const invalidate_dest = (ops) => {
+		const first = ops.split(",")[0]?.trim();
+		if (first && REG.test(first)) defs.delete(first);
+	};
+	let i = 0;
+	while (i < lines.length) {
+		const raw_line = lines[i];
+		const line = split_comment(raw_line).trim();
+		if (!line) {
+			out.push(raw_line);
+			i++;
+			continue;
+		}
+		if (/^\.[\w$]+:$/.test(line) || line.startsWith(".")) {
+			clear();
+			out.push(raw_line);
+			i++;
+			continue;
+		}
+		const m = /^(\w+)\s*(.*)$/.exec(line);
+		if (!m) {
+			clear();
+			out.push(raw_line);
+			i++;
+			continue;
+		}
+		const mn = m[1];
+		const ops = m[2].trim();
+		if (mn === "bl" || mn === "blr" || mn === "b" || mn === "br" || mn === "ret") {
+			clear();
+			out.push(raw_line);
+			i++;
+			continue;
+		}
+		if (mn === "mov") {
+			const mm = /^([wx][0-9]+)\s*,\s*#(-?\d+)$/.exec(ops);
+			if (mm) {
+				defs.set(mm[1], parseInt(mm[2], 10));
+				out.push(raw_line);
+				i++;
+				continue;
+			}
+			invalidate_dest(ops);
+			out.push(raw_line);
+			i++;
+			continue;
+		}
+		if (mn === "cmp") {
+			const cm = /^([wx][0-9]+)\s*,\s*#(-?\d+)$/.exec(ops);
+			if (cm && defs.has(cm[1])) {
+				const a = defs.get(cm[1]);
+				const b = parseInt(cm[2], 10);
+				const run = [];
+				let j = i + 1;
+				while (j < lines.length) {
+					const t = split_comment(lines[j]).trim();
+					if (!t) {
+						j++;
+						continue;
+					}
+					const bm = /^b\.(\w+)\s+(\S+)$/.exec(t);
+					if (bm && COND_OPS.has(bm[1])) {
+						run.push({
+							cond: bm[1],
+							label: bm[2],
+							line_idx: j
+						});
+						j++;
+						continue;
+					}
+					break;
+				}
+				if (run.length > 0) {
+					let follower = "";
+					for (let k = run[run.length - 1].line_idx + 1; k < lines.length; k++) {
+						const t = split_comment(lines[k]).trim();
+						if (!t) continue;
+						follower = t;
+						break;
+					}
+					const follower_mn = /^(\S+)/.exec(follower)?.[1] ?? "";
+					if (follower === "" || follower.startsWith(".") || [
+						"cmp",
+						"tst",
+						"cmn",
+						"b",
+						"bl",
+						"ret",
+						"cbz",
+						"cbnz"
+					].includes(follower_mn)) {
+						for (const r of run) if (cond_holds(r.cond, a, b)) {
+							out.push(`b ${r.label}`);
+							break;
+						}
+						i = run[run.length - 1].line_idx + 1;
+						continue;
+					}
+				}
+			}
+			out.push(raw_line);
+			i++;
+			continue;
+		}
+		if (mn === "madd" || mn === "mul") {
+			const parts = ops.split(",").map((p) => p.trim());
+			if (parts.length === (mn === "madd" ? 4 : 3)) {
+				const dest = parts[0];
+				const srcs = [parts[1], parts[2]];
+				const addend = mn === "madd" ? parts[3] : void 0;
+				const addend_zero = mn === "madd" ? /^(x|w)zr$/.test(addend ?? "") : true;
+				let folded = false;
+				if (addend_zero && REG.test(dest)) for (const [n_reg, m_reg] of [[srcs[0], srcs[1]], [srcs[1], srcs[0]]]) {
+					const c = m_reg !== void 0 && REG.test(m_reg) ? defs.get(m_reg) : void 0;
+					const shift = c !== void 0 ? is_pow2(c) : void 0;
+					if (shift !== void 0 && REG.test(n_reg) && !defs.has(n_reg)) {
+						out.push(`lsl ${dest}, ${n_reg}, #${shift}`);
+						defs.delete(dest);
+						i++;
+						folded = true;
+						break;
+					}
+				}
+				if (folded) continue;
+			}
+			invalidate_dest(ops);
+			out.push(raw_line);
+			i++;
+			continue;
+		}
+		if (![
+			"str",
+			"stp",
+			"cmp",
+			"tst",
+			"cbz",
+			"cbnz",
+			"tbz",
+			"tbnz"
+		].includes(mn)) invalidate_dest(ops);
+		out.push(raw_line);
+		i++;
+	}
+	return out.join("\n");
+}
+//#endregion
 //#region ../src/nodes/ExtendNode.ts
 /**
 * An `extend struct Name { ... }` / `extend class Name { ... }` declaration.
@@ -23089,6 +23494,7 @@ function check_declaration_node(decl, status) {
 				status.pending_return_bounds.delete(decl.name);
 			}
 		}
+		if (decl.value) apply_return_bounds_to_var(decl.name, call_return_bounds(decl.value), status);
 	}
 }
 /**
@@ -23822,6 +24228,11 @@ function check_function_parameter_node(param, status) {
 		is_null: param.type.is_nullable ? true : void 0
 	});
 	if (param.constraint) {
+		const stripped = strip_length_equalities(param.constraint, param.name, status);
+		if (stripped !== param.constraint) {
+			param.constraint = stripped;
+			if (!param.constraint) return;
+		}
 		check_node(param.constraint, status);
 		const constraint_type = type_from_value_node(param.constraint, status);
 		if (constraint_type.name && constraint_type.name !== "bool") add_error(status, `Constraint must be a boolean expression, got ${constraint_type.name}`, param.constraint.start);
@@ -23844,7 +24255,15 @@ function clone_status(status) {
 			upper_bound_exprs: v.upper_bound_exprs?.slice(),
 			lower_bound_exprs: v.lower_bound_exprs?.slice(),
 			upper_bound_inclusive_exprs: v.upper_bound_inclusive_exprs?.slice(),
-			lower_bound_inclusive_exprs: v.lower_bound_inclusive_exprs?.slice()
+			lower_bound_inclusive_exprs: v.lower_bound_inclusive_exprs?.slice(),
+			path_bounds: v.path_bounds ? new Map([...v.path_bounds].map(([k, b]) => [k, {
+				upper: b.upper?.slice(),
+				lower: b.lower?.slice(),
+				upper_inclusive: b.upper_inclusive?.slice(),
+				lower_inclusive: b.lower_inclusive?.slice(),
+				range_lower: b.range_lower,
+				range_upper: b.range_upper
+			}])) : void 0
 		})),
 		function_value_base: status.function_value_base,
 		structs: status.structs.slice(),
@@ -23857,6 +24276,7 @@ function clone_status(status) {
 		type_params: status.type_params,
 		errors: status.errors,
 		buffer_caps: status.buffer_caps,
+		equal_lengths: status.equal_lengths?.slice(),
 		mutated_local_names: status.mutated_local_names
 	};
 }
@@ -23875,6 +24295,7 @@ function check_function_node(func, status) {
 	}
 	let function_status = clone_status(status);
 	function_status.function_value_base = function_status.values.length;
+	function_status.equal_lengths = [];
 	const structs_before = function_status.structs.length;
 	const enums_before = function_status.enums.length;
 	const types_before = function_status.types.length;
@@ -24812,6 +25233,7 @@ function substitute_raw_in_node(node, substitution, structs, deref_params = /* @
 			value = value.replace(new RegExp(`\\b${param}_NEEDS_STRDUP\\b`, "g"), type === "string" ? "1" : "0");
 		}
 		for (const pname of deref_params) value = value.replace(new RegExp(`(?<![&*.>\\w])\\b${pname}\\b(?![\\w])`, "g"), `(*${pname})`);
+		if (raw_block_is_pure_asm(value)) value = fold_asm_constants(value);
 		raw.value = value;
 		return;
 	}
@@ -26037,13 +26459,17 @@ function check_assignment_node(assign, status) {
 		left_value.lower_bound_exprs = void 0;
 		left_value.upper_bound_inclusive_exprs = void 0;
 		left_value.lower_bound_inclusive_exprs = void 0;
+		left_value.path_bounds = void 0;
 		left_value.alias_of = void 0;
 		left_value.class_alias_of = void 0;
 		left_value.type.length = void 0;
 		if (assign.left_value.node_type === "value") invalidate_view_borrows_of(status, left_value.name);
 		let synthetic_rhs;
 		if (is_trackable_compound) synthetic_rhs = new OperationNode(assign.right_value.start, compound_op, assign.left_value, assign.right_value, left_value.type);
-		if ((!is_compound || synthetic_rhs) && left_value_name === left_value.name) track_assignment_bounds(left_value.name, synthetic_rhs ?? assign.right_value, status, self_snapshot);
+		if ((!is_compound || synthetic_rhs) && left_value_name === left_value.name) {
+			track_assignment_bounds(left_value.name, synthetic_rhs ?? assign.right_value, status, self_snapshot);
+			if (!is_compound) apply_return_bounds_to_var(left_value.name, call_return_bounds(assign.right_value), status);
+		}
 		if (!is_compound && left_value.type.name === "string" && assign.right_value.node_type === "value" && assign.right_value.value.startsWith("\"") && assign.right_value.value.endsWith("\"")) {
 			const len = assign.right_value.value.length - 2;
 			left_value.type.length = new ValueNode(assign.right_value.start, len.toString(), new Type("int"));
@@ -26701,7 +27127,11 @@ function check_operation_node(op, status) {
 				var_obj.is_null = false;
 			}
 		}
-		if (!check_node(op.right_value, status)) return false;
+		const saved_bounds = snapshot_all_bounds(status);
+		apply_bounds(op.left_value, status);
+		const right_ok = check_node(op.right_value, status);
+		restore_all_bounds(status, saved_bounds);
+		if (!right_ok) return false;
 		if (saved_null !== void 0 && left_check) {
 			const var_obj = status.values.findLast((v) => v.name === left_check.name);
 			if (var_obj) var_obj.is_null = saved_null;
@@ -26709,6 +27139,16 @@ function check_operation_node(op, status) {
 		op.type = new Type("bool");
 		return true;
 	}
+	if (op.op === "||") {
+		if (!check_node(op.left_value, status)) return false;
+		const saved_bounds = snapshot_all_bounds(status);
+		apply_negated_bounds(op.left_value, status);
+		const right_ok = check_node(op.right_value, status);
+		restore_all_bounds(status, saved_bounds);
+		if (!right_ok) return false;
+		op.type = new Type("bool");
+		return true;
+	}
 	const is_equality = op.op === "==" || op.op === "!=";
 	const is_null_coalesce = op.op === "??";
 	const old_allow_null = status.allow_null_value;
@@ -26786,7 +27226,6 @@ function check_operation_node(op, status) {
 		case ">=":
 		case "<":
 		case "<=":
-		case "||":
 			op.type = new Type("bool");
 			break;
 		case "??": {
@@ -29168,7 +29607,8 @@ function parse_visibility(visibility, status) {
 			break;
 		case "inline":
 			consume(status);
-			if (peek_next(status) === "func") parse_function(visibility, status, void 0, true);
+			if (peek_current(status) === "inline") consume(status);
+			if (peek_current(status) === "func") parse_function(visibility, status, void 0, true);
 			else add_error(status, "Expected func after inline", get_index(status));
 			break;
 		case "#": {

package/package.json

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