nomen-lang 0.6.0 → 0.6.2

package/dist/index.mjs

@@ -19242,6 +19242,7 @@ function build_function_node$1(node, status) {
 	const old_struct_param_slots = status.function_struct_param_slots;
 	const old_function_param_types = status.function_param_types;
 	const old_function_local_types = status.function_local_types;
+	const old_variable_types = status.variable_types;
 	status.function_param_regs = /* @__PURE__ */ new Map();
 	status.function_param_vars = /* @__PURE__ */ new Set();
 	status.function_array_params = /* @__PURE__ */ new Set();
@@ -19250,6 +19251,7 @@ function build_function_node$1(node, status) {
 	status.function_struct_param_slots = /* @__PURE__ */ new Set();
 	status.function_param_types = /* @__PURE__ */ new Map();
 	status.function_local_types = /* @__PURE__ */ new Map();
+	status.variable_types = /* @__PURE__ */ new Map();
 	const old_variadic_params_aarch64 = status.function_variadic_params;
 	const old_view_params = status.function_view_params;
 	status.function_variadic_params = /* @__PURE__ */ new Set();
@@ -19658,6 +19660,7 @@ function build_function_node$1(node, status) {
 	status.function_struct_param_slots = old_struct_param_slots;
 	status.function_param_types = old_function_param_types;
 	status.function_local_types = old_function_local_types;
+	status.variable_types = old_variable_types;
 	status.function_variadic_params = old_variadic_params_aarch64;
 	status.function_view_params = old_view_params;
 	status.function_return_label = old_return_label;
@@ -21418,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.
@@ -21452,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;
 			}
@@ -21468,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;
@@ -21501,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;
 			}
@@ -21536,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) {
@@ -21749,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) {
@@ -22224,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
@@ -22255,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) {
@@ -23197,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);
@@ -35126,6 +35289,8 @@ function build_function_node(node, status) {
 	status.function_view_params = /* @__PURE__ */ new Set();
 	const old_return_type = status.function_return_type;
 	status.function_return_type = node.return_type;
+	const old_variable_types = status.variable_types;
+	status.variable_types = /* @__PURE__ */ new Map();
 	const old_nullable_ret_has = status.nullable_ret_has_param;
 	if (is_nullable_struct_type(node.return_type, status)) status.nullable_ret_has_param = "_ret_has";
 	else status.nullable_ret_has_param = void 0;
@@ -35181,6 +35346,7 @@ function build_function_node(node, status) {
 	status.function_variadic_params = old_variadic_params;
 	status.function_view_params = old_view_params;
 	status.function_return_type = old_return_type;
+	status.variable_types = old_variable_types;
 	status.nullable_ret_has_param = old_nullable_ret_has;
 	status.current_function_name = old_function_name;
 	status.current_function = old_current_function;
@@ -36790,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) {
@@ -37731,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) {
@@ -42974,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];
@@ -42986,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--) {
@@ -43070,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`);
@@ -43104,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`);
 		}
 	}
@@ -43171,7 +43321,7 @@ function build_access_method(node, access_func, status) {
 		emit_asm(status, `str x0, [sp, #-16]!\n`);
 		emit_asm(status, `str x1, [sp, #-16]!\n`);
 		emit_asm(status, `mov x0, x9\n`);
-		emit_asm(status, `bl _nomen_free_wrap\n`);
+		emit_free(status);
 		emit_asm(status, `ldr x1, [sp], #16\n`);
 		emit_asm(status, `ldr x0, [sp], #16\n`);
 		emit_asm(status, `add sp, sp, #16\n`);
@@ -44184,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";
@@ -50012,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,
@@ -50031,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
@@ -50368,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,
@@ -52468,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
@@ -52861,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;
@@ -53372,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) {
@@ -55547,7 +55946,13 @@ function check_return_node(ret, status) {
 		} else if (!func.is_arrow_body) {
 			add_error(status, `Function returns a value but has no 'out' return type`, ret.start);
 			func.return_type = ret.type;
-		} else func.return_type = ret.type;
+		} else {
+			func.return_type = ret.type;
+			if (!ret.type?.name) {
+				func.return_type = new Type("void");
+				ret.type = new Type("void");
+			}
+		}
 	}
 }
 //#endregion
@@ -58515,7 +58920,24 @@ function resolve_linked_types(source, library, file_path) {
 	}
 	const user_declared_funcs = /* @__PURE__ */ new Set();
 	for (let i = 0; i < tokens.length - 1; i++) if (tokens[i].value === "func" && /^\w+$/.test(tokens[i + 1].value)) user_declared_funcs.add(tokens[i + 1].value);
-	for (const token of tokens) {
+	const import_tokens = /* @__PURE__ */ new Set();
+	for (let i = 0; i < tokens.length; i++) {
+		if (tokens[i].value !== "import") continue;
+		import_tokens.add(i);
+		let j = i + 1;
+		if (j < tokens.length && /^\w+$/.test(tokens[j].value)) {
+			import_tokens.add(j);
+			j += 1;
+			while (j + 1 < tokens.length && tokens[j].value === "::" && /^\w+$/.test(tokens[j + 1].value)) {
+				import_tokens.add(j);
+				import_tokens.add(j + 1);
+				j += 2;
+			}
+		}
+	}
+	for (let i = 0; i < tokens.length; i++) {
+		if (import_tokens.has(i)) continue;
+		const token = tokens[i];
 		if (user_defined.has(token.value)) continue;
 		if (library.types.has(token.value) && !BASE_TYPES.includes(token.value)) needed.add(token.value);
 		else if (library.functions.has(token.value) && !user_declared_funcs.has(token.value)) needed.add(token.value);
@@ -59323,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;
@@ -59333,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;
@@ -59344,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;
@@ -59356,7 +59781,8 @@ function run_test_file(entry_path, lib_path, arch, audit = false, audit_runtime)
 			audit_obj
 		]);
 	}
-	const ext = arch === "aarch64" ? ".s" : ".c";
+	const platform = default_platform();
+	const ext = arch === "aarch64" ? ".s" : platform === "macos" || platform === "ios" ? ".m" : ".c";
 	const codefile = path.join(buildDir, path.basename(entry_path, ".nm") + ext);
 	const outfile = path.join(buildDir, path.basename(entry_path, ".nm"));
 	fs.writeFileSync(path.join(buildDir, "main.h"), buildResult.headers ?? "");
@@ -59367,6 +59793,7 @@ function run_test_file(entry_path, lib_path, arch, audit = false, audit_runtime)
 		codefile
 	];
 	if (audit_obj) link_args.push(audit_obj);
+	if (platform === "macos" || platform === "ios") link_args.push("-framework", "CoreGraphics", "-framework", "Foundation", "-framework", "AppKit", "-lobjc");
 	try {
 		execFileSync("clang", link_args, {
 			encoding: "utf8",
@@ -59379,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;
@@ -59407,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;
@@ -59434,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;
 	}