nomen-lang 0.6.1 → 0.6.2

package/core/System/List.nm

@@ -61,6 +61,18 @@ pub struct List<T>: Viewable {
 		self.items.replace(i, value)
 	}
 
+	// Bounds-checked write that traps when i is outside [0, self.length) —
+	// for indices that can't be proven at compile time (cross-module calls
+	// can never discharge `set`'s parameter constraint) and out-of-range is
+	// a bug, not a case.
+	pub func set_or_panic = (ref self, int i, move T value) {
+		if i >= 0 && i < self.length {
+			self.set(i, value)
+			return
+		}
+		panic("index out of range")
+	}
+
 	// A deep copy: a fresh List<T> with an independent copy of every element.
 	// For owning element types (strings, owning value structs) each slot in the
 	// copy owns its own heap data (Buffer deep-copies on store), so the source

package/core/System/StringBuilder.nm

@@ -16,7 +16,9 @@ pub struct StringBuilder {
 	// Ensure capacity for at least `needed` bytes. Grows geometrically.
 	// Plain Nomen + the memory externs — no pointer arithmetic needed, so
 	// this doesn't even require an unsafe context.
-	func ensure = (ref self, int needed) {
+	// `internal`: capacity plumbing for the builder's own appenders; not
+	// part of the user surface.
+	internal func ensure = (ref self, int needed) {
 		if self.cap >= needed {
 			return
 		}
@@ -84,7 +86,10 @@ pub struct StringBuilder {
 	// Append a null-terminated string. `unsafe` Nomen single-sourced for
 	// both backends: the fat pair's pointer half feeds memcpy directly, and
 	// the tracked length replaces the strlen the old C body paid.
-	func append_string = (ref self, string s) {
+	// `internal`: a library-implementation append — user code appends with
+	// `append_char` / `append_string_view`; the library's own structs (Json,
+	// Regex) are on the trusted side of the boundary.
+	internal func append_string = (ref self, string s) {
 		unsafe {
 			var int sl = s.length
 			self.ensure(self.len + sl + 1)
@@ -175,7 +180,7 @@ pub struct StringBuilder {
 	// to [0, len]; the returned string is always an independent allocation.
 	// (`move out string` — the raw body mallocs the result, so the caller
 	// owns it by signature, like `Console.read_line`.)
-	func take_since = (ref self, int mark, move out string) {
+	pub func take_since = (ref self, int mark, move out string) {
 		```
 		#arch: c
 		int start = mark;
@@ -237,7 +242,10 @@ pub struct StringBuilder {
 
 	// Finalize: null-terminate, return the byte buffer as a string, and
 	// release ownership (sets `data` to 0 so the destructor won't free it).
-	func to_string = (ref self, out string) {
+	// Explicitly `pub`: struct members default to pub, but this is the
+	// builder's primary read-back — the contract should not depend on the
+	// default.
+	pub func to_string = (ref self, out string) {
 		```
 		#arch: c
 		int idx = self->len;

package/core/System/Text/Regex.nm

@@ -255,12 +255,13 @@ func fold_pattern = (string pattern, move out string) {
 	while i < n; i += 1 {
 		var char c = pattern.at(i)
 		if (c as int) == 92 {
-			// Escaped char: shorthands and backrefs keep their backslash;
-			// other escaped letters become both-case classes; escaped
-			// punctuation is copied literally.
+			// Escaped char: shorthands, backrefs, and control escapes
+			// (\n \r \t) keep their backslash; other escaped letters
+			// become both-case classes; escaped punctuation is copied
+			// literally.
 			if i + 1 < n {
 				var char e = pattern.at(i + 1)
-				if is_shorthand(e) || is_backref_digit(e) {
+				if is_shorthand(e) || is_backref_digit(e) || is_control_escape(e) {
 					sb.append_char(c)
 					sb.append_char(e)
 				} else {
@@ -317,9 +318,10 @@ func fold_class = (string pattern, int cs, int ce, ref StringBuilder dst) {
 			if i + 1 < content_end {
 				var char e = pattern.at(i + 1)
 				dst.append_char(e)
-				// A shorthand keeps its backslash; other escaped letters
-				// gain their case counterpart.
-				if is_alpha_byte(e) && !is_shorthand(e) {
+				// A shorthand or control escape (\n \r \t) keeps its
+				// backslash; other escaped letters gain their case
+				// counterpart.
+				if is_alpha_byte(e) && !is_shorthand(e) && !is_control_escape(e) {
 					dst.append_char(swap_case_byte(e))
 				}
 				i += 1
@@ -478,9 +480,11 @@ func alt_first_bytes = (string pattern, int start, int end, ref StringBuilder sb
 	while i < end {
 		var char c = pattern.at(i)
 		if (c as int) == 92 {
-			// escaped literal: first byte is the escaped char — unless it's
-			// a backreference (depends on a capture) or a complement
-			// shorthand (not an inclusion set), which disable the prefilter.
+			// escaped literal: first byte is the byte the escape names
+			// (\n is LF, \r is CR, \t is TAB; any other escaped character
+			// is its own literal byte) — unless it's a backreference
+			// (depends on a capture) or a complement shorthand (not an
+			// inclusion set), which disable the prefilter.
 			if i + 1 < end {
 				var char e = pattern.at(i + 1)
 				if is_backref_digit(e) {
@@ -491,7 +495,7 @@ func alt_first_bytes = (string pattern, int start, int end, ref StringBuilder sb
 						return -1
 					}
 				} else {
-					sb.append_char(e)
+					sb.append_char(escaped_byte_value(e) as char)
 				}
 				// A '?'/'*' quantifier makes the atom nullable — the first
 				// byte can also come from whatever follows it.
@@ -597,22 +601,34 @@ func add_class_chars = (string pattern, int start, int end, ref StringBuilder sb
 	}
 	var int i = cs
 	while i < end {
-		if i + 2 < end {
-			if pattern.at(i + 1) == '-' {
-				var int lo = pattern.at(i) as int
-				var int hi = pattern.at(i + 2) as int
-				while lo <= hi {
-					sb.append_char(lo as char)
-					lo += 1
+		var char c = pattern.at(i)
+		if (c as int) == 92 {
+			// Escaped byte: contribute the byte the escape names (\n is
+			// LF, \r is CR, \t is TAB; any other escaped character is its
+			// own literal byte) so the prefilter stays a superset of the
+			// matcher's first bytes.
+			if i + 1 < end {
+				sb.append_char(escaped_byte_value(pattern.at(i + 1)) as char)
+			}
+			i += 2
+		} else {
+			if i + 2 < end {
+				if pattern.at(i + 1) == '-' {
+					var int lo = pattern.at(i) as int
+					var int hi = pattern.at(i + 2) as int
+					while lo <= hi {
+						sb.append_char(lo as char)
+						lo += 1
+					}
+					i += 3
+				} else {
+					sb.append_char(c)
+					i += 1
 				}
-				i += 3
 			} else {
-				sb.append_char(pattern.at(i))
+				sb.append_char(c)
 				i += 1
 			}
-		} else {
-			sb.append_char(pattern.at(i))
-			i += 1
 		}
 	}
 }
@@ -760,7 +776,23 @@ func match_here = (
 		}
 	}
 
-	// No quantifier: match the atom once, then the rest of the pattern.
+	// No quantifier: match the atom once, then the rest of the pattern. A
+	// GROUP atom goes through the continuation-aware path: its inner
+	// alternatives retry when the rest fails on an earlier one (JS-style
+	// backtracking — `(head|header)(\s|$|>)` must still match "header>").
+	if pc == '(' {
+		return match_group_then_rest(
+			pattern,
+			pat_pos,
+			a_end,
+			a_end,
+			pat_end,
+			input,
+			in_pos,
+			in_len,
+			ref caps,
+		)
+	}
 	var int next = match_single_atom(pattern, pat_pos, a_end, input, in_pos, in_len, ref caps)
 	if next < 0 {
 		return -1
@@ -768,6 +800,97 @@ func match_here = (
 	return match_here(pattern, a_end, pat_end, input, next, in_len, ref caps)
 }
 
+// The position of the first top-level '|' in [start, end), or -1. Escapes,
+// character classes, and nested groups are skipped so only depth-0
+// alternation operators count (same scanning discipline as match_here).
+func next_top_level_alt = (string pattern, int start, int end, out int) {
+	var depth = 0
+	var int i = start
+	while i < end {
+		var char c = pattern.at(i)
+		if (c as int) == 92 {
+			i += 2
+		} else {
+			if c == '[' {
+				i = atom_end_pos(pattern, i, end)
+			} else {
+				if c == '(' {
+					depth += 1
+				}
+				if c == ')' {
+					if depth > 0 {
+						depth -= 1
+					}
+				}
+				if (c as int) == 124 {
+					if depth == 0 {
+						return i
+					}
+				}
+				i += 1
+			}
+		}
+	}
+	return -1
+}
+
+// Match the group atom spanning [atom_start, atom_end) ('(' at atom_start)
+// and then the continuation [rest, pat_end), retrying the group's LATER
+// alternatives whenever the continuation fails on an earlier one. Without
+// this, a group commits to the first alternative that matches the group
+// ALONE and a failing continuation aborts the whole match — the engine had
+// no backtracking into a group's alternatives (PORT.md: `(head|header)`
+// never reached `header` when `(\s|$|>)` rejected what `head` left behind).
+// A group without a top-level '|' behaves exactly like the old
+// match-atom-then-continue path, and a failed trial restores the group's
+// previous capture span before the next attempt.
+func match_group_then_rest = (
+	string pattern,
+	int atom_start,
+	int atom_end,
+	int rest,
+	int pat_end,
+	string input,
+	int in_pos,
+	int in_len,
+	ref List<int> caps,
+	out int
+) {
+	var int g = group_index_at(pattern, atom_start)
+	var int at = last_capture_index(caps, g)
+	var int old_start = -1
+	var int old_end = -1
+	if at >= 0 {
+		old_start = caps.at(at + 1)
+		old_end = caps.at(at + 2)
+	}
+	var int inner_start = atom_start + 1
+	var int inner_end = atom_end - 1
+	var int s = inner_start
+	while s <= inner_end {
+		var int bar = next_top_level_alt(pattern, s, inner_end)
+		var int e = inner_end
+		if bar >= 0 {
+			e = bar
+		}
+		var int next = match_here(pattern, s, e, input, in_pos, in_len, ref caps)
+		if next >= 0 {
+			record_capture(ref caps, g, in_pos, next)
+			var int r = match_here(pattern, rest, pat_end, input, next, in_len, ref caps)
+			if r >= 0 {
+				return r
+			}
+		}
+		record_capture(ref caps, g, old_start, old_end)
+		if bar >= 0 {
+			s = bar + 1
+		} else {
+			s = inner_end + 1
+		}
+	}
+	return -1
+}
+
 // Return the position just past the atom that starts at pat_pos. Handles
 // character classes [...], groups (...), and escaped characters (\x).
 func atom_end_pos = (string pattern, int pat_pos, int pat_end, out int) {
@@ -888,7 +1011,7 @@ func match_single_atom = (
 				return -1
 			}
 			if in_pos < in_len {
-				if input.at(in_pos) == ec {
+				if (input.at(in_pos) as int) == escaped_byte_value(ec) {
 					return in_pos + 1
 				}
 			}
@@ -936,7 +1059,7 @@ func char_matches_atom = (
 			if is_shorthand(ec) {
 				return matches_shorthand(ec, ic)
 			}
-			return ic == ec
+			return (ic as int) == escaped_byte_value(ec)
 		}
 		return false
 	}
@@ -1046,29 +1169,99 @@ func match_star_group = (
 ) {
 	if lazy > 0 {
 		// Lazy: stop repeating first (minimum met), then try one more
-		// iteration before giving up.
+		// iteration before giving up. The iteration retries the group's
+		// top-level alternatives (see match_group_iteration).
 		if min_count <= 0 {
 			var int stop = match_here(pattern, rest, pat_end, input, in_pos, in_len, ref caps)
 			if stop >= 0 {
 				return stop
 			}
 		}
-		var int next = match_single_atom(
+		return match_group_iteration(
 			pattern,
 			atom_start,
 			atom_end,
+			rest,
+			pat_end,
 			input,
 			in_pos,
+			min_count,
+			lazy,
 			in_len,
 			ref caps,
 		)
+	}
+	// Try matching the group one more time (greedy) — each top-level
+	// alternative in turn — before stopping.
+	var int r = match_group_iteration(
+		pattern,
+		atom_start,
+		atom_end,
+		rest,
+		pat_end,
+		input,
+		in_pos,
+		min_count,
+		lazy,
+		in_len,
+		ref caps,
+	)
+	if r >= 0 {
+		return r
+	}
+	// Stop repeating and try the rest of the pattern, if the minimum is met.
+	if min_count <= 0 {
+		return match_here(pattern, rest, pat_end, input, in_pos, in_len, ref caps)
+	}
+	return -1
+}
+
+// Try ONE further iteration of a quantified group at in_pos, retrying the
+// group's top-level alternatives while the remaining star recursion fails.
+// Returns the recursion's result, or -1 when no alternative leads to a
+// match. An alternative that matches the empty string is not recursed into
+// (an empty iteration cannot make progress; the caller's stop path covers
+// it), and every failed trial restores the group's previous capture span.
+func match_group_iteration = (
+	string pattern,
+	int atom_start,
+	int atom_end,
+	int rest,
+	int pat_end,
+	string input,
+	int in_pos,
+	int min_count,
+	int lazy,
+	int in_len,
+	ref List<int> caps,
+	out int
+) {
+	var int g = group_index_at(pattern, atom_start)
+	var int at = last_capture_index(caps, g)
+	var int old_start = -1
+	var int old_end = -1
+	if at >= 0 {
+		old_start = caps.at(at + 1)
+		old_end = caps.at(at + 2)
+	}
+	var int inner_start = atom_start + 1
+	var int inner_end = atom_end - 1
+	var int s = inner_start
+	while s <= inner_end {
+		var int bar = next_top_level_alt(pattern, s, inner_end)
+		var int e = inner_end
+		if bar >= 0 {
+			e = bar
+		}
+		var int next = match_here(pattern, s, e, input, in_pos, in_len, ref caps)
 		if next >= 0 {
+			record_capture(ref caps, g, in_pos, next)
 			if next != in_pos {
 				var new_min = 0
 				if min_count > 0 {
 					new_min = min_count - 1
 				}
-				return match_star_group(
+				var int r = match_star_group(
 					pattern,
 					atom_start,
 					atom_end,
@@ -1081,40 +1274,18 @@ func match_star_group = (
 					in_len,
 					ref caps,
 				)
+				if r >= 0 {
+					return r
+				}
 			}
 		}
-		return -1
-	}
-	// Try matching the group one more time (greedy).
-	var int next = match_single_atom(pattern, atom_start, atom_end, input, in_pos, in_len, ref caps)
-	if next >= 0 {
-		if next != in_pos {
-			var new_min = 0
-			if min_count > 0 {
-				new_min = min_count - 1
-			}
-			var int r = match_star_group(
-				pattern,
-				atom_start,
-				atom_end,
-				rest,
-				pat_end,
-				input,
-				next,
-				new_min,
-				lazy,
-				in_len,
-				ref caps,
-			)
-			if r >= 0 {
-				return r
-			}
+		record_capture(ref caps, g, old_start, old_end)
+		if bar >= 0 {
+			s = bar + 1
+		} else {
+			s = inner_end + 1
 		}
 	}
-	// Stop repeating and try the rest of the pattern, if the minimum is met.
-	if min_count <= 0 {
-		return match_here(pattern, rest, pat_end, input, in_pos, in_len, ref caps)
-	}
 	return -1
 }
 
@@ -1138,6 +1309,21 @@ func match_optional = (
 		if skip >= 0 {
 			return skip
 		}
+		// A group atom includes continuation-aware alternative retries (see
+		// match_group_then_rest) in both moods.
+		if pattern.at(atom_start) == '(' {
+			return match_group_then_rest(
+				pattern,
+				atom_start,
+				atom_end,
+				rest,
+				pat_end,
+				input,
+				in_pos,
+				in_len,
+				ref caps,
+			)
+		}
 		var int next = match_single_atom(
 			pattern,
 			atom_start,
@@ -1152,11 +1338,28 @@ func match_optional = (
 		}
 		return -1
 	}
-	var int next = match_single_atom(pattern, atom_start, atom_end, input, in_pos, in_len, ref caps)
-	if next >= 0 {
-		var int r = match_here(pattern, rest, pat_end, input, next, in_len, ref caps)
-		if r >= 0 {
-			return r
+	if pattern.at(atom_start) == '(' {
+		var int grouped = match_group_then_rest(
+			pattern,
+			atom_start,
+			atom_end,
+			rest,
+			pat_end,
+			input,
+			in_pos,
+			in_len,
+			ref caps,
+		)
+		if grouped >= 0 {
+			return grouped
+		}
+	} else {
+		var int next = match_single_atom(pattern, atom_start, atom_end, input, in_pos, in_len, ref caps)
+		if next >= 0 {
+			var int r = match_here(pattern, rest, pat_end, input, next, in_len, ref caps)
+			if r >= 0 {
+				return r
+			}
 		}
 	}
 	return match_here(pattern, rest, pat_end, input, in_pos, in_len, ref caps)
@@ -1201,7 +1404,7 @@ func char_in_class = (
 						found = true
 					}
 				} else {
-					if ic == e {
+					if (ic as int) == escaped_byte_value(e) {
 						found = true
 					}
 				}
@@ -1456,6 +1659,29 @@ func is_shorthand = (char c, out bool) {
 	return code == 100 || code == 68 || code == 119 || code == 87 || code == 115 || code == 83
 }
 
+// Whether the escaped character c names a control-character shorthand
+// (\n \r \t) that the engine maps to its real control byte.
+func is_control_escape = (char c, out bool) {
+	var int code = c as int
+	return code == 110 || code == 114 || code == 116
+}
+
+// The byte an escaped atom names: \n is LF (10), \r is CR (13), \t is TAB
+// (9); every other escaped character is the literal byte of that character.
+func escaped_byte_value = (char c, out int) {
+	var int code = c as int
+	if code == 110 {
+		return 10
+	}
+	if code == 114 {
+		return 13
+	}
+	if code == 116 {
+		return 9
+	}
+	return code
+}
+
 // Whether byte b belongs to the shorthand class named by c. Uppercase names
 // are the complements (S/D/W match anything the lowercase set excludes).
 func matches_shorthand = (char c, char b, out bool) {

package/dist/index.mjs

@@ -21421,6 +21421,67 @@ function call_in_set(set, call) {
 	return set.has(call.name.replace(/#/g, ""));
 }
 //#endregion
+//#region ../src/build_common/fold_string_const.ts
+/**
+* Fold a top-level `const`'s string `+` chain into a single string literal.
+*
+* Module-level `const` declarations are inlined at every use site (see
+* `top_level_consts` in both backends' BuildStatus): the build replays the
+* const's initializer expression wherever the name appears. For a composed
+* pattern like `pub const HTML_TAG_REGEX = "^(" + TAG_NAME + "|…)"` that
+* replay lowers to a malloc/copy/free `string_add` chain PER USE — the
+* allmark port's inline-token loop rebuilt its ~1 KB pattern on every
+* attempt, and the chain's calls were also the trigger for the aarch64
+* ref-argument clobber (PORT.md).
+*
+* When the initializer is a pure `+` chain of plain string literals and
+* references to other foldable consts, this returns one merged literal
+* ValueNode — semantically the string the source spells — that the use site
+* emits as rodata instead. Anything else (a runtime operand, a struct ctor,
+* an operator overload) returns null and the tree builds as before.
+*
+* Raw token merging is byte-preserving: escape sequences are self-contained
+* within a part's content (a content ending in a lone `\` would have
+* escaped that part's closing quote, so it cannot occur), and both
+* emitters' `\x`-as-octal re-encoding plus the 2/3-digit caps keep merged
+* escapes from absorbing a following part's text.
+*/
+const fold_cache = /* @__PURE__ */ new WeakMap();
+function fold_string_const(decl, consts) {
+	if (fold_cache.has(decl)) return fold_cache.get(decl);
+	const folded = fold_value(decl.value, consts, /* @__PURE__ */ new Set());
+	fold_cache.set(decl, folded);
+	return folded;
+}
+function fold_value(node, consts, active) {
+	if (!node) return null;
+	if (node.node_type === "value") {
+		const raw = node.value;
+		if (typeof raw !== "string") return null;
+		if (raw.startsWith("\"")) return literal(raw, node.start);
+		if (active.has(raw)) return null;
+		const ref = consts.get(raw);
+		if (!ref) return null;
+		active.add(raw);
+		const folded = fold_value(ref.value, consts, active);
+		active.delete(raw);
+		return folded;
+	}
+	if (node.node_type === "op") {
+		const op = node;
+		if (!(op.op === "+" && (!op.operator_func || op.operator_func.struct_name === "string"))) return null;
+		const left = fold_value(op.left_value, consts, active);
+		if (!left) return null;
+		const right = fold_value(op.right_value, consts, active);
+		if (!right) return null;
+		return literal(left.value.slice(0, -1) + right.value.slice(1), node.start);
+	}
+	return null;
+}
+function literal(raw, start) {
+	return new ValueNode(start, raw, new Type("string", true));
+}
+//#endregion
 //#region ../src/build_common/string_escapes.ts
 /**
 * Source string-literal escape handling shared by both backends.
@@ -21455,8 +21516,8 @@ function reencode_hex_escapes(raw) {
 			let j = i + 2;
 			let value = 0;
 			let digits = 0;
-			while (j < raw.length && digits < 2 && is_hex_digit(raw[j])) {
-				value = value * 16 + hex_value(raw[j]);
+			while (j < raw.length && digits < 2 && is_hex_digit$1(raw[j])) {
+				value = value * 16 + hex_value$1(raw[j]);
 				j += 1;
 				digits += 1;
 			}
@@ -21471,10 +21532,10 @@ function reencode_hex_escapes(raw) {
 	}
 	return out;
 }
-function is_hex_digit(c) {
+function is_hex_digit$1(c) {
 	return c >= "0" && c <= "9" || c >= "a" && c <= "f" || c >= "A" && c <= "F";
 }
-function hex_value(c) {
+function hex_value$1(c) {
 	if (c <= "9") return c.charCodeAt(0) - 48;
 	if (c <= "F") return c.charCodeAt(0) - 55;
 	return c.charCodeAt(0) - 87;
@@ -21504,7 +21565,7 @@ function scan_string_escapes(raw) {
 		if (next === "x") {
 			let j = i + 2;
 			let digits = 0;
-			while (j < end && digits < 2 && is_hex_digit(raw[j])) {
+			while (j < end && digits < 2 && is_hex_digit$1(raw[j])) {
 				j += 1;
 				digits += 1;
 			}
@@ -21539,6 +21600,16 @@ function scan_string_escapes(raw) {
 	}
 	return issues;
 }
+/** Escape one raw string-literal token (quotes included) for a GAS
+*  `.asciz` directive: source `\xHH` hex escapes re-encode as 3-digit octal
+*  (GAS consumes `\x` greedily — see reencode_hex_escapes) and raw newlines
+*  (multi-line strings) become `\n` so the directive stays one line. */
+function escape_asciz(value) {
+	const reencoded = reencode_hex_escapes(value);
+	if (!reencoded.includes("\n")) return reencoded;
+	const quote = reencoded[0];
+	return quote + reencoded.slice(1, reencoded.endsWith(quote) ? -1 : void 0).replace(/\n/g, "\\n") + (reencoded.endsWith(quote) ? quote : "");
+}
 //#endregion
 //#region ../src/build_aarch64/build_range_node.ts
 function build_range_node$1(node, status) {
@@ -21752,12 +21823,6 @@ function is_value_struct_type_node(node, status) {
 	const t = type_from_value_node$1(node);
 	return !!t?.name && !!status.structs.find((s) => s.name === t.name && !s.is_simple_type && !s.is_class);
 }
-function escape_asciz(value) {
-	const reencoded = reencode_hex_escapes(value);
-	if (!reencoded.includes("\n")) return reencoded;
-	const quote = reencoded[0];
-	return quote + reencoded.slice(1, reencoded.endsWith(quote) ? -1 : void 0).replace(/\n/g, "\\n") + (reencoded.endsWith(quote) ? quote : "");
-}
 /** Allocate an array on the stack with an 8-byte length prefix.
 *  Writes the length at the start and returns the offset of the first element. */
 function alloc_array_with_prefix(status, length, element_size) {
@@ -22227,6 +22292,93 @@ function resolve_string_op(op, status) {
 	}
 	return null;
 }
+const FLOAT_LITERAL_RE = /^(\+|-)?\d+\.\d+([eE](\+|-)?\d+)?$/;
+/**
+* Fold a module-level primitive `const`/`var` initializer to a literal string
+* when it is a compile-time constant: literal operands, references to other
+* foldable module-level consts, and arithmetic/bitwise operators over them.
+* Returns null when the value can only be computed at runtime (a call, a
+* field read, …), which a file-scope `.quad` initializer cannot express.
+*
+* Without this, `pub const N = 3 + 4` at module scope reserved
+* `N: .space 8` and emitted its store as dead code between functions, so
+* every read observed 0 (FOLLOWUP.md). Integer math is exact via BigInt so
+* 64-bit constants are not rounded through JS doubles; float arithmetic
+* falls back to JS doubles (which match Nomen's `float`).
+*/
+function fold_const_scalar(node, status, seen) {
+	if (!node) return null;
+	if (node.node_type === "grouped") return fold_const_scalar(node.value, status, seen);
+	if (node.node_type === "value") {
+		const raw = get_raw_value$1(node, status);
+		if (is_int_literal(raw)) return to_decimal_string(raw);
+		if (FLOAT_LITERAL_RE.test(raw)) return raw;
+		if (/^[A-Za-z_][A-Za-z0-9_]*$/.test(raw) && !seen.has(raw)) {
+			const decl = find_global_const(raw, status);
+			if (decl?.value) {
+				seen.add(raw);
+				const folded = fold_const_scalar(decl.value, status, seen);
+				seen.delete(raw);
+				return folded;
+			}
+		}
+		return null;
+	}
+	if (node.node_type === "op") {
+		const op = node;
+		if (op.operator_func) return null;
+		const left = fold_const_scalar(op.left_value, status, seen);
+		if (left === null) return null;
+		const right = fold_const_scalar(op.right_value, status, seen);
+		if (right === null) return null;
+		return apply_const_op(op.op, left, right);
+	}
+	return null;
+}
+/** Apply one arithmetic/bitwise operator to two folded literal strings.
+*  Float operands use JS doubles; integral operands stay exact via BigInt. */
+function apply_const_op(op, left, right) {
+	if (FLOAT_LITERAL_RE.test(left) || FLOAT_LITERAL_RE.test(right)) {
+		const a = Number(left);
+		const b = Number(right);
+		if (!isFinite(a) || !isFinite(b)) return null;
+		switch (op) {
+			case "+": return String(a + b);
+			case "-": return String(a - b);
+			case "*": return String(a * b);
+			case "/": return b === 0 ? null : String(a / b);
+			default: return null;
+		}
+	}
+	let a;
+	let b;
+	try {
+		a = BigInt(left);
+		b = BigInt(right);
+	} catch {
+		return null;
+	}
+	switch (op) {
+		case "+": return (a + b).toString();
+		case "-": return (a - b).toString();
+		case "*": return (a * b).toString();
+		case "/": return b === 0n ? null : (a / b).toString();
+		case "%": return b === 0n ? null : (a % b).toString();
+		case "<<": return (a << b).toString();
+		case ">>": return (a >> b).toString();
+		case "&": return (a & b).toString();
+		case "|": return (a | b).toString();
+		case "^": return (a ^ b).toString();
+		default: return null;
+	}
+}
+/** The root-scope `const` declaration named `name` (used to fold a const
+*  reference through to its initializer). Mutable `var`s are deliberately
+*  excluded: their value is established by module init, so baking in the
+*  declaration's initializer could differ from the runtime value. */
+function find_global_const(name, status) {
+	return (status.root.statements ?? []).find((s) => s.node_type === "declare" && s.declaration === "const" && s.name === name);
+}
 /**
 * Emit a declaration INITIALIZER expression. Under NIR-driven emission the
 * lowered `NirExpr` rides in and descends through `emit_expr_from_nir` (the
@@ -22258,7 +22410,7 @@ function build_declaration_node$1(node, status, nir_init, nir_swap) {
 	const prev_heap = status.last_result_is_heap;
 	if (node.value?.node_type === "value") {
 		const inlined = status.top_level_consts?.get(node.value.value);
-		if (inlined?.value) node.value = inlined.value;
+		if (inlined?.value) node.value = fold_string_const(inlined, status.top_level_consts) ?? inlined.value;
 	}
 	function check_heap() {
 		if (status.last_result_is_heap) {
@@ -23200,7 +23352,15 @@ function build_declaration_node$1(node, status, nir_init, nir_swap) {
 			if (status.function_return_label) {
 				const offset = declare_slot_offset(status, node.name, size);
 				status.stack_offsets.set(node.name, offset);
-			} else emit_data(status, `${node.name}: .space ${size}\n`);
+			} else {
+				const folded = fold_const_scalar(node.value, status, /* @__PURE__ */ new Set());
+				if (folded !== null) {
+					emit_data(status, `${node.name}: ${directive} ${folded}\n`);
+					if (size % 4 !== 0) emit_data(status, `.p2align 2\n`);
+					return;
+				}
+				emit_data(status, `${node.name}: .space ${size}\n`);
+			}
 			if (node.type.name === "string" && !node.type.is_view && is_view_value(node.value, status)) {
 				emit_view_string_arg(node.value, status);
 				emit_view_materialize_owned(status);
@@ -36796,7 +36956,7 @@ function build_value_node$1(node, status) {
 	}
 	const inlined = status.top_level_consts?.get(value);
 	if (inlined?.value) {
-		build_node$1(inlined.value, status);
+		build_node$1(fold_string_const(inlined, status.top_level_consts) ?? inlined.value, status);
 		return;
 	}
 	if (node.is_enum_shorthand) {
@@ -37737,7 +37897,7 @@ function build_value_node(node, status) {
 	}
 	const inlined = status.top_level_consts?.get(original_value);
 	if (inlined?.value) {
-		build_node(inlined.value, status);
+		build_node(fold_string_const(inlined, status.top_level_consts) ?? inlined.value, status);
 		return;
 	}
 	if (node.is_enum_shorthand) {
@@ -42980,8 +43140,6 @@ function build_access_method(node, access_func, status) {
 		return true;
 	};
 	const overflow_count = Math.max(0, total_arg_slots - (8 - start_reg));
-	let overflow_base = 0;
-	if (overflow_count > 0) overflow_base = allocate_stack_space(status, overflow_count * 8, 16);
 	const lambda_arg_indices = /* @__PURE__ */ new Set();
 	for (let i = 0; i < access_func.params.length; i++) {
 		const p = access_func.params[i];
@@ -42992,21 +43150,17 @@ function build_access_method(node, access_func, status) {
 		lambda_arg_indices.add(i);
 	}
 	const lambda_arg_slots = [];
-	const has_pair_args = view_arg_set.size > 0 || string_arg_set.size > 0;
-	let view_spill_base = 0;
-	if (has_pair_args) view_spill_base = allocate_stack_space(status, total_arg_slots * 8, 16);
-	const view_half_store = (j, half) => {
-		const half_slot = start_reg + arg_slot[j] + half;
-		return half_slot >= 8 ? overflow_base + (half_slot - 8) * 8 : view_spill_base + (arg_slot[j] + half) * 8;
+	const arg_builds_in_loop = (i) => {
+		if (view_arg_set.has(i) || string_arg_set.has(i)) return true;
+		if ((access_func.ref_param_indices ?? []).includes(i)) return true;
+		const param_type = access_func.params[i].type?.name || "";
+		if (is_struct_type(param_type, status) || is_enum_with_data_type(param_type, status)) return true;
+		return !arg_deferrable(i);
 	};
-	const param0 = access_func.params[0];
-	const param0_is_pair = view_arg_set.has(0) || string_arg_set.has(0);
-	const param0_is_ref = (access_func.ref_param_indices ?? []).includes(0);
-	const param0_type_name = param0?.type?.name || "";
-	const param0_builds_in_loop = access_func.params.length > 0 && (param0_is_ref || is_struct_type(param0_type_name, status) || is_enum_with_data_type(param0_type_name, status) || !arg_deferrable(0));
-	const static_arg0_needs_spill = start_reg === 0 && access_func.params.length > 0 && !param0_is_pair && param0_builds_in_loop;
-	let static_arg0_spill = 0;
-	if (static_arg0_needs_spill) static_arg0_spill = allocate_stack_space(status, 8, 8);
+	const any_in_loop_arg = access_func.params.some((_, i) => arg_builds_in_loop(i));
+	let arg_spill_base = 0;
+	if (any_in_loop_arg) arg_spill_base = allocate_stack_space(status, total_arg_slots * 8, 16);
+	const view_half_store = (j, half) => arg_spill_base + (arg_slot[j] + half) * 8;
 	const ref_class_param_reload = [];
 	const ref_class_sync_names = [];
 	for (let i = access_func.params.length - 1; i >= 0; i--) {
@@ -43076,31 +43230,20 @@ function build_access_method(node, access_func, status) {
 				lambda_arg_slots.push(dispose_slot);
 			}
 		}
-		const slot = start_reg + arg_slot[i];
 		ensure_newline(status);
-		if (slot >= 8) emit_asm(status, `str x0, [x29, #${overflow_base + (slot - 8) * 8}]\n`);
-		else {
-			const reg = `x${slot}`;
-			if (reg !== "x0") emit_asm(status, `mov ${reg}, x0\n`);
-			else if (static_arg0_needs_spill) emit_asm(status, `str x0, [x29, #${static_arg0_spill}]\n`);
-		}
+		emit_asm(status, `str x0, [x29, #${arg_spill_base + arg_slot[i] * 8}]\n`);
 	}
 	deferred_args.sort((a, b) => b.slot - a.slot);
 	for (const d of deferred_args) {
 		build_operand(d.param, `x${start_reg + d.slot}`, status);
 		ensure_newline(status);
 	}
-	if (has_pair_args) for (let j = 0; j < access_func.params.length; j++) {
-		if (!view_arg_set.has(j) && !string_arg_set.has(j)) continue;
-		for (const half of [0, 1]) {
-			const half_slot = start_reg + arg_slot[j] + half;
-			if (half_slot >= 8) continue;
-			emit_asm(status, `ldr x${half_slot}, [x29, #${view_spill_base + (arg_slot[j] + half) * 8}]\n`);
-		}
-	}
-	if (static_arg0_needs_spill) {
-		ensure_newline(status);
-		emit_asm(status, `ldr x0, [x29, #${static_arg0_spill}]\n`);
+	const deferred_slots = new Set(deferred_args.map((d) => start_reg + d.slot));
+	for (let s = 0; s < total_arg_slots; s++) {
+		const slot = start_reg + s;
+		if (slot >= 8) continue;
+		if (deferred_slots.has(slot)) continue;
+		emit_asm(status, `ldr x${slot}, [x29, #${arg_spill_base + s * 8}]\n`);
 	}
 	ensure_newline(status);
 	if (receiver_is_string) emit_asm(status, frees_string_receiver ? `ldp x0, x1, [sp]\n` : `ldp x0, x1, [sp], #16\n`);
@@ -43110,8 +43253,9 @@ function build_access_method(node, access_func, status) {
 	if (overflow_count > 0) {
 		outgoing_size = Math.ceil(overflow_count * 8 / 16) * 16;
 		emit_asm(status, `sub sp, sp, #${outgoing_size}\n`);
+		const overflow_first = 8 - start_reg;
 		for (let k = 0; k < overflow_count; k++) {
-			emit_asm(status, `ldr x9, [x29, #${overflow_base + k * 8}]\n`);
+			emit_asm(status, `ldr x9, [x29, #${arg_spill_base + (overflow_first + k) * 8}]\n`);
 			emit_asm(status, `str x9, [sp, #${k * 8}]\n`);
 		}
 	}
@@ -44190,10 +44334,7 @@ function build(root, options = {}) {
 		}
 		if (status.strings && status.strings.size > 0) {
 			status.code += "\n";
-			for (const [label, value] of status.strings) {
-				const escaped = value.replace(/\n/g, "\\n");
-				status.code += `${label}: .asciz ${escaped}\n`;
-			}
+			for (const [label, value] of status.strings) status.code += `${label}: .asciz ${escape_asciz(value)}\n`;
 		}
 		if (status.float_literals && status.float_literals.size > 0) {
 			status.code += "\n.p2align 2\n";
@@ -50018,16 +50159,22 @@ function must_use_type_display_name(en, type) {
 */
 function gather_top_level_consts(block, status) {
 	const seen = /* @__PURE__ */ new Set();
+	const candidates = [];
 	for (const child of block.statements) {
 		if (child.node_type !== "declare") continue;
 		const decl = child;
 		if (decl.declaration !== "const") continue;
-		if (!decl.name || !decl.type?.name) continue;
-		if (decl.type.is_array) continue;
+		if (!decl.name) continue;
 		if (seen.has(decl.name)) continue;
 		seen.add(decl.name);
+		candidates.push(decl);
+	}
+	infer_const_decl_types(candidates, status);
+	for (const decl of candidates) {
+		if (!decl.type?.name) continue;
+		if (decl.type.is_array) continue;
 		status.values.push({
-			declaration: decl.declaration,
+			declaration: "const",
 			name: decl.name,
 			type: decl.type,
 			is_set: !!decl.value,
@@ -50037,6 +50184,60 @@ function gather_top_level_consts(block, status) {
 	}
 }
 /**
+* Give every root-level `const` a declared type BEFORE the statement walk,
+* so a const declared BELOW its first use resolves like a free function
+* (which hoists across the whole file). Parse can only infer the type when
+* the initializer is a bare literal; a composed chain (`const TAG = "<" +
+* TAG_NAME + ">"`, the allmark htmlPatterns shape) stayed typeless and its
+* use-above-declaration failed with "Unknown value".
+*
+* The inference iterates until nothing new is derivable, so a chain may
+* reference consts declared BELOW itself too. Recognized initializers:
+* literals, references to other (typed) consts, and arithmetic/concat
+* operations (the result type is the left operand's, mirroring
+* check_operation_node). Anything else (constructor calls, function calls)
+* keeps today's behavior: annotate the type or declare before use.
+*/
+function infer_const_decl_types(decls, status) {
+	const known = /* @__PURE__ */ new Map();
+	for (const decl of decls) if (decl.type?.name) known.set(decl.name, decl.type);
+	let progress = true;
+	while (progress) {
+		progress = false;
+		for (const decl of decls) {
+			if (decl.type?.name) continue;
+			const inferred = infer_const_expr_type(decl.value, known, status);
+			if (!inferred) continue;
+			decl.type = inferred;
+			known.set(decl.name, inferred);
+			progress = true;
+		}
+	}
+}
+function infer_const_expr_type(node, known, status) {
+	if (!node) return void 0;
+	if (node.node_type === "grouped") return infer_const_expr_type(node.value, known, status);
+	if (node.node_type === "value") {
+		const raw = node.value;
+		if (typeof raw !== "string") return void 0;
+		if (raw.startsWith("\"")) return new Type("string", true);
+		if (raw === "true" || raw === "false") return new Type("bool", true);
+		if (raw.startsWith("'") && raw.endsWith("'")) return new Type("char", true);
+		if (is_int_literal(raw)) return new Type("int", true);
+		if (/^(\+|-)*\d+.\d+([eE](\+|-)?\d+)?$/.test(raw)) return new Type("float", true);
+		const declared = known.get(raw);
+		if (declared) return declared;
+		return;
+	}
+	if (node.node_type === "op") return infer_const_expr_type(node.left_value, known, status);
+	if (node.node_type === "func_call") {
+		const call = node;
+		const target = status.structs.find((s) => s.name === call.name && !s.is_simple_type);
+		if (target && target.type_params.length === 0) return new Type(target.name);
+		return;
+	}
+}
+/**
 * A bare statement that constructs (or obtains) a class instance without
 * binding it to a variable would leak: classes are heap-allocated and freed
 * by the owning variable's scope-exit cleanup, so an unbound instance is
@@ -50374,6 +50575,7 @@ function clone_status(status) {
 		var_name_counter: status.var_name_counter,
 		type_params: status.type_params,
 		errors: status.errors,
+		warnings: status.warnings,
 		buffer_caps: status.buffer_caps,
 		equal_lengths: status.equal_lengths?.slice(),
 		mutated_local_names: status.mutated_local_names,
@@ -52474,6 +52676,143 @@ function is_visible(declaring_scope, visibility, access_scope, stack, declaring_
 	return access_scope === declaring_scope;
 }
 //#endregion
+//#region ../src/check/utils/regex_pattern_lint.ts
+/**
+* Compile-time lint for Regex pattern literals (FOLLOWUP "Regex pattern
+* escapes").
+*
+* The Regex engine (core/System/Text/Regex.nm) recognizes only the
+* shorthands (`\d \D \w \W \s \S`), backreferences (`\1`-`\9`), the control
+* escapes (`\n \r \t`), and escaped metacharacters. Any OTHER engine escape
+— most notably a typo like `\z` — silently matches a literal letter. When a
+* Regex entry point's pattern argument is a static string literal, the check
+* can flag those as probable typos; dynamic runtime patterns can't be
+* validated this way.
+*
+* The literal arrives RAW (quotes included, Nomen escapes unresolved), so it
+* must first be decoded to the engine-visible bytes: a Nomen `"\n"` is a real
+* LF byte the engine treats as a literal, while `"\n"` reaches the engine as
+* a backslash + 'n' escape. Only the second spelling can carry a typo.
+*/
+/** Decode a raw string-literal token (quotes included) to its engine-visible
+* bytes, resolving Nomen's own string escapes. Mirrors the pair-counting of
+* string_literal_length and the decode rules of decode_char_literal. */
+function decode_string_literal_bytes(raw) {
+	const bytes = [];
+	let i = 1;
+	const end = raw.endsWith("\"") ? raw.length - 1 : raw.length;
+	while (i < end) {
+		if (raw[i] !== "\\") {
+			const cp = raw.codePointAt(i) ?? 0;
+			if (cp < 128) {
+				bytes.push(cp);
+				i += 1;
+			} else if (cp < 2048) {
+				bytes.push(192 | cp >> 6, 128 | cp & 63);
+				i += 1;
+			} else if (cp < 65536) {
+				bytes.push(224 | cp >> 12, 128 | cp >> 6 & 63, 128 | cp & 63);
+				i += 1;
+			} else {
+				bytes.push(240 | cp >> 18, 128 | cp >> 12 & 63, 128 | cp >> 6 & 63, 128 | cp & 63);
+				i += 2;
+			}
+			continue;
+		}
+		const next = raw[i + 1];
+		if (next === void 0) break;
+		if (next === "x") {
+			let j = i + 2;
+			let value = 0;
+			let digits = 0;
+			while (j < end && digits < 2 && is_hex_digit(raw[j])) {
+				value = value * 16 + hex_value(raw[j]);
+				j += 1;
+				digits += 1;
+			}
+			if (digits > 0) {
+				bytes.push(value & 255);
+				i = j;
+				continue;
+			}
+			i += 2;
+			continue;
+		}
+		if (next >= "0" && next <= "7") {
+			let j = i + 1;
+			let value = 0;
+			let digits = 0;
+			while (j < end && digits < 3 && raw[j] >= "0" && raw[j] <= "7") {
+				value = value * 8 + (raw[j].charCodeAt(0) - 48);
+				j += 1;
+				digits += 1;
+			}
+			bytes.push(value & 255);
+			i = j;
+			continue;
+		}
+		switch (next) {
+			case "\\":
+				bytes.push(92);
+				break;
+			case "n":
+				bytes.push(10);
+				break;
+			case "t":
+				bytes.push(9);
+				break;
+			case "r":
+				bytes.push(13);
+				break;
+			case "0":
+				bytes.push(0);
+				break;
+			case "\"":
+				bytes.push(34);
+				break;
+			case "'":
+				bytes.push(39);
+				break;
+			default: bytes.push(next.charCodeAt(0));
+		}
+		i += 2;
+	}
+	return bytes;
+}
+function is_hex_digit(c) {
+	return c >= "0" && c <= "9" || c >= "a" && c <= "f" || c >= "A" && c <= "F";
+}
+function hex_value(c) {
+	if (c <= "9") return c.charCodeAt(0) - 48;
+	if (c <= "F") return c.charCodeAt(0) - 55;
+	return c.charCodeAt(0) - 87;
+}
+function is_ascii_letter(code) {
+	return code >= 65 && code <= 90 || code >= 97 && code <= 122;
+}
+/** Scan the decoded pattern bytes for escapes outside the engine's known set
+* (`\d \D \w \W \s \S`, `\1`-`\9`, `\n \r \t`, escaped punctuation) and
+* return one warning message per probable typo. */
+function lint_regex_pattern(raw) {
+	const bytes = decode_string_literal_bytes(raw);
+	const messages = [];
+	let i = 0;
+	while (i < bytes.length) {
+		if (bytes[i] !== 92) {
+			i += 1;
+			continue;
+		}
+		const escaped = bytes[i + 1];
+		if (escaped === void 0) break;
+		if (!(escaped === 100 || escaped === 68 || escaped === 119 || escaped === 87 || escaped === 115 || escaped === 83 || escaped === 110 || escaped === 114 || escaped === 116 || escaped >= 49 && escaped <= 57) && is_ascii_letter(escaped)) {
+			const letter = String.fromCharCode(escaped);
+			messages.push(`Regex pattern: unsupported escape '\\${letter}' matches a literal '${letter}' — supported escapes are \\d \\D \\w \\W \\s \\S \\1-\\9 \\n \\r \\t and escaped punctuation`);
+		}
+		i += 2;
+	}
+	return messages;
+}
+//#endregion
 //#region ../src/check/utils/string_mutation_scan.ts
 /**
 * Interprocedural no-mutation scan for borrow-position `to_string()` elision
@@ -52867,6 +53206,7 @@ function is_inside_core_method(status) {
 }
 function check_function_call(node, status, func, target_type, self_value, self_path) {
 	set_resolved_function(node, func);
+	lint_regex_entry_pattern(node, func, status);
 	const access_scope = status.stack.at(-1);
 	if (func.name === "#init") {
 		const struct_name = target_type?.name || func.return_type.name;
@@ -53378,6 +53718,59 @@ function receiver_is_const(target_type, self_value, status) {
 	const binding = status.values.findLast((v) => v.name === self_value);
 	return !!binding && binding.declaration === "const" && !binding.type.is_ref;
 }
+/**
+* Regex entry points whose FIRST parameter is the pattern. When that argument
+* is a static string literal, flag engine escapes outside the known set as
+* probable typos (see regex_pattern_lint.ts) — a dynamic runtime pattern
+* can't be validated this way.
+*/
+const REGEX_PATTERN_ENTRY_POINTS = /* @__PURE__ */ new Set([
+	"test",
+	"match",
+	"count",
+	"find",
+	"replace_all",
+	"captures",
+	"test_ci",
+	"match_ci",
+	"find_ci",
+	"captures_ci",
+	"replace_all_ci"
+]);
+/**
+* Lint a static string-literal pattern passed to a Regex entry point. Only
+* the library's own `Regex` struct qualifies (a user struct of the same name
+* with a same-named method is left alone), and only when the first argument
+* is a literal — anything else is a runtime value.
+*/
+function lint_regex_entry_pattern(node, func, status) {
+	if (!is_library_regex_func(func, status)) return;
+	if (!REGEX_PATTERN_ENTRY_POINTS.has(func.name)) return;
+	const pattern = node.params[0];
+	if (!pattern || pattern.node_type !== "value") return;
+	const raw = pattern.value;
+	if (!raw.startsWith("\"")) return;
+	if (!status.warnings) status.warnings = [];
+	for (const message of lint_regex_pattern(raw)) status.warnings.push({
+		message,
+		start: pattern.start,
+		line: 0,
+		column: 0
+	});
+}
+/**
+* Whether `func` is a method of the library's `Regex` struct. Two paths: the
+* method's enclosing struct is stamped on it for calls checked after the
+* struct gather (library bodies, later files), and for user call sites —
+* which are checked BEFORE the gather stamps `func.scope` — the callee is
+* matched against the gathered library struct's own methods.
+*/
+function is_library_regex_func(func, status) {
+	const scope = func.scope;
+	if (scope && scope.node_type === "struct" && scope.is_library && scope.name === "Regex") return true;
+	const regex_struct = status.structs.find((s) => s.is_library && s.name === "Regex");
+	return !!regex_struct && regex_struct.functions.includes(func);
+}
 //#endregion
 //#region ../src/check/check_access_node.ts
 function check_access_node(node, status) {
@@ -59352,6 +59745,7 @@ function run_test_file(entry_path, lib_path, arch, audit = false, audit_runtime)
 	const parsed = parse(input + "\n" + harness, library, resolved);
 	if (parsed.errors.length) {
 		result.ok = false;
+		result.phase = "parse";
 		result.crashed = parsed.errors.map((e) => `${e.message} (${e.line ?? "?"}:${e.column ?? "?"})`).join("\n");
 		result.ms = performance.now() - start;
 		return result;
@@ -59362,6 +59756,7 @@ function run_test_file(entry_path, lib_path, arch, audit = false, audit_runtime)
 	});
 	if (buildResult.errors && buildResult.errors.length) {
 		result.ok = false;
+		result.phase = "build";
 		result.crashed = buildResult.errors.map((e) => `${e.message} (${e.line ?? "?"}:${e.column ?? "?"})`).join("\n");
 		result.ms = performance.now() - start;
 		return result;
@@ -59373,6 +59768,7 @@ function run_test_file(entry_path, lib_path, arch, audit = false, audit_runtime)
 		const runtime_src = audit_runtime ? path.resolve(audit_runtime) : find_audit_runtime(path.dirname(resolved));
 		if (!runtime_src || !fs.existsSync(runtime_src)) {
 			result.ok = false;
+			result.phase = "setup";
 			result.crashed = "Audit enabled but audit_runtime.c was not found. Pass --audit-runtime <path>.";
 			result.ms = performance.now() - start;
 			return result;
@@ -59410,6 +59806,7 @@ function run_test_file(entry_path, lib_path, arch, audit = false, audit_runtime)
 	} catch (err) {
 		const stderr = err.stderr ? err.stderr.toString() : err.message ?? "";
 		result.ok = false;
+		result.phase = "link";
 		result.crashed = `link failed: ${stderr.trim() || "clang error"}`;
 		result.ms = performance.now() - start;
 		return result;
@@ -59438,6 +59835,7 @@ function run_test_file(entry_path, lib_path, arch, audit = false, audit_runtime)
 	result.benches = records.benches;
 	result.other = records.other;
 	result.crashed = crashed;
+	if (crashed) result.phase = "run";
 	result.ok = !(result.fails.length > 0 || result.tests.some((t) => t.failed > 0)) && crashed === void 0;
 	result.ms = performance.now() - start;
 	return result;
@@ -59465,7 +59863,8 @@ const C = {
 function report_file(result) {
 	const rel = path.relative(process.cwd(), result.file);
 	if (result.crashed && result.tests.length === 0 && result.fails.length === 0) {
-		console.log(` ${C.red("✗")} ${rel} ${C.red("(failed to build)")}`);
+		const label = result.phase === "run" ? "(crashed before records)" : result.phase === "link" ? "(link failed)" : result.phase === "setup" ? "(setup failed)" : "(failed to build)";
+		console.log(` ${C.red("✗")} ${rel} ${C.red(label)}`);
 		console.log(C.red(result.crashed));
 		return;
 	}

package/package.json

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

package/src/test.ts

@@ -40,6 +40,12 @@ export interface TestFileResult {
 	// Set when the compiled binary crashed before finishing (e.g. a segfault
 	// in a test). We still surface whatever records it managed to emit.
 	crashed?: string;
+	/**
+	 * The pipeline stage that produced `crashed`, so the report can name it
+	 * accurately — a binary that BUILT fine and then segfaulted before
+	 * emitting any record is not a build failure (see report_file).
+	 */
+	phase?: "parse" | "build" | "setup" | "link" | "run";
 	ms: number;
 }
 
@@ -289,6 +295,7 @@ export function run_test_file(
 	const parsed = parse(source, library, resolved);
 	if (parsed.errors.length) {
 		result.ok = false;
+		result.phase = "parse";
 		result.crashed = parsed.errors
 			.map((e) => `${e.message} (${e.line ?? "?"}:${e.column ?? "?"})`)
 			.join("\n");
@@ -302,6 +309,7 @@ export function run_test_file(
 	});
 	if (buildResult.errors && buildResult.errors.length) {
 		result.ok = false;
+		result.phase = "build";
 		result.crashed = buildResult.errors
 			.map((e) => `${e.message} (${e.line ?? "?"}:${e.column ?? "?"})`)
 			.join("\n");
@@ -321,6 +329,7 @@ export function run_test_file(
 			: find_audit_runtime(path.dirname(resolved));
 		if (!runtime_src || !fs.existsSync(runtime_src)) {
 			result.ok = false;
+			result.phase = "setup";
 			result.crashed =
 				"Audit enabled but audit_runtime.c was not found. Pass --audit-runtime <path>.";
 			result.ms = performance.now() - start;
@@ -367,6 +376,7 @@ export function run_test_file(
 	} catch (err: any) {
 		const stderr = err.stderr ? err.stderr.toString() : (err.message ?? "");
 		result.ok = false;
+		result.phase = "link";
 		result.crashed = `link failed: ${stderr.trim() || "clang error"}`;
 		result.ms = performance.now() - start;
 		return result;
@@ -399,6 +409,7 @@ export function run_test_file(
 	result.benches = records.benches;
 	result.other = records.other;
 	result.crashed = crashed;
+	if (crashed) result.phase = "run";
 	// A file "passes" when it reported no failed asserts and didn't crash.
 	const failed = result.fails.length > 0 || result.tests.some((t) => t.failed > 0);
 	result.ok = !failed && crashed === undefined;
@@ -435,7 +446,18 @@ const C = {
 export function report_file(result: TestFileResult): void {
 	const rel = path.relative(process.cwd(), result.file);
 	if (result.crashed && result.tests.length === 0 && result.fails.length === 0) {
-		console.log(` ${C.red("✗")} ${rel} ${C.red("(failed to build)")}`);
+		// Name the stage that actually failed. A binary that linked fine and
+		// then died before emitting any record (e.g. SIGSEGV) is NOT a build
+		// failure — conflating the two sent debugging to the wrong layer.
+		const label =
+			result.phase === "run"
+				? "(crashed before records)"
+				: result.phase === "link"
+					? "(link failed)"
+					: result.phase === "setup"
+						? "(setup failed)"
+						: "(failed to build)";
+		console.log(` ${C.red("✗")} ${rel} ${C.red(label)}`);
 		console.log(C.red(result.crashed));
 		return;
 	}