nomen-lang 0.6.10 → 0.6.12

package/core/System/Console.nm

@@ -43,6 +43,32 @@ pub struct Console {
 		```
 	}
 
+	// Disable stdout buffering: every write goes straight to the file
+	// descriptor. The `nomen test` harness calls this at startup so a
+	// crashing binary still leaves every record it printed before the
+	// crash — a buffered stdout loses its pending bytes on an abnormal
+	// exit, which used to turn a mid-suite abort into "no records at all".
+	pub func unbuffered = () {
+		```
+		#arch: c
+		setbuf(stdout, NULL);
+		```
+		```
+		#arch: aarch64
+		// setbuf(stdout, NULL): Apple's stdio names the FILE* global
+		// __stdoutp (stdout itself is a macro), so the Mach-O symbol is
+		// ___stdoutp — and it must load through the GOT (@GOTPAGE), the
+		// only relocation the linker accepts for it. The aarch64 backend
+		// always emits Mach-O symbol names (see `bl _printf` above), so
+		// this is unconditional like every other core raw body.
+		adrp x0, ___stdoutp@GOTPAGE
+		ldr x0, [x0, ___stdoutp@GOTPAGEOFF]
+		ldr x0, [x0]
+		mov x1, #0
+		bl _setbuf
+		```
+	}
+
 	// Read one line from stdin (newline stripped). The raw body mallocs the
 	// buffer — `move out string` transfers ownership to the caller.
 	pub func read_line = (move out string) {

package/dist/index.mjs

@@ -1,5 +1,5 @@
 #! /usr/bin/env node
-import { execFile, execFileSync, execSync } from "node:child_process";
+import { execFile, execFileSync, execSync, spawn } from "node:child_process";
 import fs, { stat, unwatchFile, watch, watchFile } from "node:fs";
 import * as sp from "node:path";
 import path, { join, resolve, sep } from "node:path";
@@ -2306,6 +2306,13 @@ function parse_mem_inner(inner) {
 			if (tail_shift) mem.scale = 1 << parseInt(tail_shift[1], 10);
 			continue;
 		}
+		if (/^[A-Za-z_.$][\w.$]*@[A-Za-z0-9_]+$/.test(comp)) {
+			mem.offset = {
+				kind: "reg",
+				name: comp
+			};
+			continue;
+		}
 		return null;
 	}
 	return mem;
@@ -7529,6 +7536,13 @@ var DeclarationNode = class extends BaseNode {
 	*  a heap shell for the argument (pass-by-value): the callee frees the
 	*  shell itself at scope exit (`free(p)`) after freeing the fields. */
 	owned_heap_shell;
+	/** True for a `move` param of an owning VALUE-struct type: the caller
+	*  passed its storage by address, so the callee owns the CONTENTS but not
+	*  the storage. free_scoped_declarations destroys the fields' owned
+	*  resources at `(*param)` at scope exit — never a free. Set at build
+	*  time by the C function/method builders; consumed by
+	*  free_scoped_declarations. */
+	moved_value_struct_param;
 	constructor(start, visibility, declaration, name, type, value) {
 		super("declare", start);
 		this.visibility = visibility;
@@ -20764,16 +20778,19 @@ function build_function_node$1(node, status) {
 		if (param.is_moved) {
 			const is_class = !!status.structs.find((s) => s.name === param.type.name && s.is_class);
 			const is_trait = !!status.traits.find((t) => t.name === param.type.name);
-			if (is_class || is_trait) {
+			const vstruct = !is_class && !is_trait ? resolve_struct_type(param.type, status) : void 0;
+			const is_owning_value_struct = !!vstruct && !vstruct.is_class && !param.type.is_nullable && struct_needs_destroy(vstruct, status);
+			if (is_class || is_trait || is_owning_value_struct) {
 				const reg = callee_map.get(param.name) ?? param_regs[pidx];
-				status.moved_class_params.set(param.name, reg);
+				if (is_class || is_trait) status.moved_class_params.set(param.name, reg);
 				const save_offset = allocate_stack_space(status, 8);
 				emit_asm(status, `str ${reg}, [x29, #${save_offset}]\n`);
 				moved_param_save_slots.set(param.name, {
 					offset: save_offset,
 					type_name: param.type.name,
 					type_args: param.type.type_args,
-					is_nullable: param.type.is_nullable
+					is_nullable: param.type.is_nullable,
+					value_struct_destroy_name: is_owning_value_struct ? vstruct.name : void 0
 				});
 			}
 		}
@@ -20867,10 +20884,12 @@ function build_function_node$1(node, status) {
 	if (moved_param_save_slots.size > 0 && node.name !== "main") {
 		const need_guard = return_is_class;
 		const need_save = !!node.return_type?.name;
+		const returns_fat_pair = node.return_type?.name === "string" && !node.return_type.is_array;
 		let return_save;
 		if (need_guard || need_save) {
-			return_save = allocate_stack_space(status, 8);
-			emit_asm(status, `str x0, [x29, #${return_save}]\n`);
+			return_save = allocate_stack_space(status, returns_fat_pair ? 16 : 8);
+			if (returns_fat_pair) emit_asm(status, `stp x0, x1, [x29, #${return_save}]\n`);
+			else emit_asm(status, `str x0, [x29, #${return_save}]\n`);
 		}
 		for (const [name, info] of moved_param_save_slots) {
 			if (moved_set?.has(name)) continue;
@@ -20881,12 +20900,25 @@ function build_function_node$1(node, status) {
 				emit_asm(status, `cmp x0, x1\n`);
 				emit_asm(status, `beq ${keep_prefix}_${name}\n`);
 			}
+			if (info.value_struct_destroy_name) {
+				const vstruct = status.structs.find((s) => s.name === info.value_struct_destroy_name);
+				release_heap_string_fields(status, name, info.value_struct_destroy_name);
+				if (vstruct && has_destroy(vstruct)) {
+					emit_asm(status, `ldr x0, [x29, #${info.offset}]\n`);
+					emit_asm(status, `bl ${info.value_struct_destroy_name}_destroy\n`);
+				} else if (vstruct) emit_field_destroys(status, vstruct, name, void 0, void 0, false);
+				if (need_guard) emit_asm(status, `${keep_prefix}_${name}:\n`);
+				continue;
+			}
 			emit_destroy_for_anchor_slot(status, info.offset, info.type_name, info.type_args, info.is_nullable);
 			emit_asm(status, `ldr x0, [x29, #${info.offset}]\n`);
 			emit_free(status);
 			if (need_guard) emit_asm(status, `${keep_prefix}_${name}:\n`);
 		}
-		if (need_guard || need_save) emit_asm(status, `ldr x0, [x29, #${return_save}]\n`);
+		if (need_guard || need_save) {
+			if (returns_fat_pair) emit_asm(status, `ldp x0, x1, [x29, #${return_save}]\n`);
+			else emit_asm(status, `ldr x0, [x29, #${return_save}]\n`);
+		}
 	}
 	const total_stack = Math.ceil((status.stack_size || 0) / 16) * 16;
 	status.code = status.code.replace(`sub sp, sp, #${stack_placeholder}`, total_stack > 0 ? `sub sp, sp, #${total_stack}` : `// no stack needed`);
@@ -21091,6 +21123,7 @@ function init_nullable_field_default(node, field, base_reg, status) {
 * sites record it (record_ctor_heap_default_fields) so scope exit frees it.
 */
 function init_expr_field_default(node, field, offset, base_reg, status) {
+	status.last_result_is_heap = false;
 	build_node(field.value, status);
 	ensure_newline(status);
 	const t = field.type;
@@ -22216,7 +22249,10 @@ function build_struct_functions$1(node, status) {
 		const moved_param_save_slots = /* @__PURE__ */ new Map();
 		for (const param of func.params) {
 			if (!param.is_moved || param.is_self_param) continue;
-			if (!status.structs.find((s) => s.name === param.type.name && s.is_class)) continue;
+			const is_class = !!status.structs.find((s) => s.name === param.type.name && s.is_class);
+			const vstruct = !is_class ? resolve_struct_type(param.type, status) : void 0;
+			const is_owning_value_struct = !!vstruct && !vstruct.is_class && !param.type.is_nullable && struct_needs_destroy(vstruct, status);
+			if (!is_class && !is_owning_value_struct) continue;
 			const reg = status.function_param_regs.get(param.name);
 			if (reg) {
 				const save_offset = allocate_stack_space(status, 8);
@@ -22225,7 +22261,8 @@ function build_struct_functions$1(node, status) {
 					offset: save_offset,
 					type_name: param.type.name,
 					type_args: param.type.type_args,
-					is_nullable: param.type.is_nullable
+					is_nullable: param.type.is_nullable,
+					value_struct_destroy_name: is_owning_value_struct ? vstruct.name : void 0
 				});
 			} else {
 				const offset = status.stack_offsets.get(param.name);
@@ -22233,7 +22270,8 @@ function build_struct_functions$1(node, status) {
 					offset,
 					type_name: param.type.name,
 					type_args: param.type.type_args,
-					is_nullable: param.type.is_nullable
+					is_nullable: param.type.is_nullable,
+					value_struct_destroy_name: is_owning_value_struct ? vstruct.name : void 0
 				});
 			}
 		}
@@ -22273,11 +22311,13 @@ function build_struct_functions$1(node, status) {
 		if (moved_param_save_slots.size > 0) {
 			const ret_is_class = !!func.return_type?.name && !!status.structs.find((s) => s.name === func.return_type.name && s.is_class);
 			const need_save = !!func.return_type?.name;
+			const returns_fat_pair = func.return_type?.name === "string" && !func.return_type.is_array;
 			const keep_prefix = `.Lkeep_mparam_${func_label.replace(/[^\w]/g, "_")}`;
 			let return_save;
 			if (ret_is_class || need_save) {
-				return_save = allocate_stack_space(status, 8);
-				emit_asm(status, `str x0, [x29, #${return_save}]\n`);
+				return_save = allocate_stack_space(status, returns_fat_pair ? 16 : 8);
+				if (returns_fat_pair) emit_asm(status, `stp x0, x1, [x29, #${return_save}]\n`);
+				else emit_asm(status, `str x0, [x29, #${return_save}]\n`);
 			}
 			for (const [name, info] of moved_param_save_slots) {
 				if (status.moved?.has(name) && !moved_before.has(name)) continue;
@@ -22288,12 +22328,25 @@ function build_struct_functions$1(node, status) {
 					emit_asm(status, `cmp x0, x1\n`);
 					emit_asm(status, `beq ${keep_prefix}_${name}\n`);
 				}
+				if (info.value_struct_destroy_name) {
+					const vstruct = status.structs.find((s) => s.name === info.value_struct_destroy_name);
+					release_heap_string_fields(status, name, info.value_struct_destroy_name);
+					if (vstruct && has_destroy(vstruct)) {
+						emit_asm(status, `ldr x0, [x29, #${info.offset}]\n`);
+						emit_asm(status, `bl ${info.value_struct_destroy_name}_destroy\n`);
+					} else if (vstruct) emit_field_destroys(status, vstruct, name, void 0, void 0, false);
+					if (ret_is_class) emit_asm(status, `${keep_prefix}_${name}:\n`);
+					continue;
+				}
 				emit_destroy_for_anchor_slot(status, info.offset, info.type_name, info.type_args, info.is_nullable);
 				emit_asm(status, `ldr x0, [x29, #${info.offset}]\n`);
 				emit_free(status);
 				if (ret_is_class) emit_asm(status, `${keep_prefix}_${name}:\n`);
 			}
-			if (ret_is_class || need_save) emit_asm(status, `ldr x0, [x29, #${return_save}]\n`);
+			if (ret_is_class || need_save) {
+				if (returns_fat_pair) emit_asm(status, `ldp x0, x1, [x29, #${return_save}]\n`);
+				else emit_asm(status, `ldr x0, [x29, #${return_save}]\n`);
+			}
 		}
 		const total_stack = Math.ceil((status.stack_size || 0) / 16) * 16;
 		status.code = status.code.replace(`sub sp, sp, #${stack_placeholder}`, total_stack > 0 ? `sub sp, sp, #${total_stack}` : `// no stack needed`);
@@ -22733,6 +22786,7 @@ function build_block_node$1(node, status) {
 		const prologue = status.module_init_statements;
 		status.module_init_statements = void 0;
 		for (const stmt of prologue) {
+			status.last_result_is_heap = false;
 			emit_allocations$1(stmt, status);
 			emit_stmt_from_nir$1(stmt, prologue.indexOf(stmt), prologue, status);
 		}
@@ -22742,6 +22796,7 @@ function build_block_node$1(node, status) {
 		if (module_init_set.has(child)) continue;
 		if (!is_trait_node(child) && !is_struct_node(child) && !is_function_node(child) && child.node_type !== "enum" && child.node_type !== "bitset" && !(child.node_type === "declare" && inlined_const_names.has(child.name))) {
 			if (child.node_type !== "while") emit_allocations$1(child, status);
+			status.last_result_is_heap = false;
 			const prev_forwarded = status.forwarded_param_inits;
 			const consumed = emit_stmt_from_nir$1(child, index, node.statements, status);
 			index += consumed - 1;
@@ -23918,7 +23973,6 @@ function build_declaration_node$1(node, status, nir_init, nir_swap) {
 	}
 	hoist_field_overrides(node.value, build_node, status, "", node.name);
 	status.last_result_is_heap = false;
-	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 = fold_string_const(inlined, status.top_level_consts) ?? inlined.value;
@@ -23940,7 +23994,6 @@ function build_declaration_node$1(node, status, nir_init, nir_swap) {
 				consolidate_temp_anchors$1(status, node.value, node.type.name);
 			}
 		}
-		status.last_result_is_heap = prev_heap;
 	}
 	if (node.func_params) {
 		if (status.function_return_label) {
@@ -24828,8 +24881,12 @@ function build_declaration_node$1(node, status, nir_init, nir_swap) {
 					emit_init_value$1(node.value, nir_init, status);
 					ensure_newline(status);
 					status.int_dest_hint = void 0;
-					if (size === 16 && node.type.name === "string") emit_pair_store_x29(status, offset);
-					else emit_var_store(status, "x0", node.name, size);
+					if (size === 16 && node.type.name === "string") {
+						const force_heap_init = (status.force_heap_strings?.has(node.name) ?? false) && raw !== "null";
+						if (force_heap_init) emit_strdup_string(status);
+						emit_pair_store_x29(status, offset);
+						if (force_heap_init) mark_heap_string(status, node.name);
+					} else emit_var_store(status, "x0", node.name, size);
 				} else if (is_float_type$1(node.type.name)) {
 					const label = `_float_const_${decl_const_counter++}`;
 					emit_data(status, `${label}: .double ${raw}\n.p2align 2\n`);
@@ -31099,6 +31156,10 @@ function build_auto_free(status) {
 function free_scoped_declarations(status, decls, persist_string_field_records = false) {
 	let commented = false;
 	if (status.heap_string_fields?.size) for (const dec of decls) {
+		if (dec.moved_value_struct_param) {
+			const dec_struct = status.structs.find((s) => s.name === mono_type_name(dec.type) && !s.is_simple_type && !s.is_generic);
+			if (dec_struct && has_destroy(dec_struct)) continue;
+		}
 		const prefix = `${dec.name}.`;
 		const keys = Array.from(status.heap_string_fields).filter((key) => key.startsWith(prefix));
 		if (!keys.length) continue;
@@ -31130,6 +31191,18 @@ function free_scoped_declarations(status, decls, persist_string_field_records =
 		}
 		if (persist_string_field_records && dec.force_owned_string === true) continue;
 		if (status.moved?.has(dec.name)) continue;
+		if (dec.moved_value_struct_param) {
+			const mono_name = mono_type_name(dec.type);
+			const param_struct = status.structs.find((s) => s.name === mono_name && !s.is_simple_type && !s.is_generic);
+			if (param_struct && struct_needs_destroy(param_struct, status)) {
+				if (!commented) {
+					status.code += "\n// Auto-free\n";
+					commented = true;
+				}
+				emit_struct_destroys(status, param_struct, `(*${c_function_name(dec.name)})`);
+			}
+			continue;
+		}
 		const cname = c_function_name(dec.name);
 		if (dec.type.name === "func") {
 			if (!commented) {
@@ -33620,13 +33693,15 @@ function build_assignment_node$1(node, status, nir_rhs, nir_swap) {
 			}
 		}
 	}
-	if (!node.operator && node.left_value.node_type === "access" && node.left_value.access.node_type === "access_field" && node.right_value.node_type === "value" && node.right_value.is_moved) {
+	const assign_rhs_is_moved_value = node.right_value.node_type === "value" && node.right_value.is_moved;
+	const assign_rhs_is_fresh_call = !node.swap && node.right_value.node_type === "func_call";
+	if (!node.operator && node.left_value.node_type === "access" && node.left_value.access.node_type === "access_field" && (assign_rhs_is_moved_value || assign_rhs_is_fresh_call)) {
 		const access_lhs = node.left_value;
 		const field_type = access_lhs.access.type;
 		const field_resolved = field_type?.name && !field_type.is_view && !field_type.is_array ? resolve_struct_type(field_type, status) : void 0;
 		const field_struct = field_resolved && !field_resolved.is_class ? field_resolved : void 0;
 		if (field_struct) {
-			splice_decl_from_c_scopes(status, node.right_value.value);
+			if (assign_rhs_is_moved_value) splice_decl_from_c_scopes(status, node.right_value.value);
 			const saved_len = begin_code_scratch(status);
 			build_node$1(node.left_value, status);
 			const field_access = end_code_scratch(status, saved_len);
@@ -36845,9 +36920,16 @@ function build_struct_functions(node, status, skip_init = false) {
 		for (const param of func.params) {
 			if (param.is_self_param) continue;
 			const param_struct = status.structs.find((s) => s.name === param.type.name);
-			if (param.is_moved && param_struct?.is_class && !moved_param_is_consumed(func, param.name, param_struct.name, status.structs)) {
+			if (!param.is_moved) continue;
+			if (param_struct?.is_class && !moved_param_is_consumed(func, param.name, param_struct.name, status.structs)) {
 				const pname = c_function_name(param.name);
 				status.scoped_declarations.push(new DeclarationNode(param.start, "private", "move", pname, param.type));
+			} else if (param_struct && !param_struct.is_class && !param_struct.is_simple_type && !param_struct.is_generic && !param.type.is_nullable && struct_needs_destroy(param_struct, status) && !moved_param_is_consumed(func, param.name, param_struct.name, status.structs)) {
+				const pname = c_function_name(param.name);
+				const decl = new DeclarationNode(param.start, "private", "move", pname, param.type);
+				decl.moved_value_struct_param = true;
+				decl.string_fields_via_pointer = true;
+				status.scoped_declarations.push(decl);
 			}
 		}
 		const saved_sig = begin_code_scratch(status);
@@ -37734,6 +37816,12 @@ function build_function_node(node, status) {
 				if (param_trait && !param_struct?.is_class) decl.trait_class_trait = param.type.name;
 				status.scoped_declarations.push(decl);
 			}
+			if (param.is_moved && !moved_owning_param && param_struct && !param_struct.is_class && !param_struct.is_generic && !param.type.is_nullable && node.name !== "main" && struct_needs_destroy(param_struct, status) && !moved_param_is_consumed(node, param.name, param_struct.name, status.structs)) {
+				const decl = new DeclarationNode(param.start, "private", "move", pname, param.type);
+				decl.moved_value_struct_param = true;
+				decl.string_fields_via_pointer = true;
+				status.scoped_declarations.push(decl);
+			}
 			const is_free_function = (!node.scope || node.scope.node_type === "root" || node.scope.node_type === "func") && !node.params.some((p) => p.is_self_param);
 			const fn_name = node.name;
 			const fn_label = emission_label(node);
@@ -41741,7 +41829,9 @@ function build_assignment_node(node, status, nir_rhs, nir_swap) {
 			const explicit_move_source = !node.swap && !!rhs_value && rhs_value.is_moved && size === 16 && rhs_value.type?.name === "string" && !rhs_value.type?.is_view ? rhs_value.value : void 0;
 			const rhs_is_borrow_reception = !node.swap && size === 16 && is_string_borrow(node.right_value);
 			const rhs_is_field_read = !node.swap && size === 16 && node.right_value.node_type === "access" && node.right_value.access.node_type === "access_field";
-			const borrow_needs_dup = (rhs_is_borrow_reception || rhs_is_field_read) && !!status.force_heap_strings?.has(name);
+			const rhs_var_name = !node.swap && size === 16 && node.right_value.node_type === "value" && !node.right_value.type?.is_view ? node.right_value.value : void 0;
+			const rhs_is_unrecorded_var_read = rhs_var_name !== void 0 && !status.heap_strings?.has(rhs_var_name);
+			const borrow_needs_dup = (rhs_is_borrow_reception || rhs_is_field_read || rhs_is_unrecorded_var_read) && !!status.force_heap_strings?.has(name);
 			const move_source_owns_heap = move_source !== void 0 && !!status.heap_strings?.has(move_source);
 			if (rhs_is_view_into_owned) {
 				if (!status.heap_strings) status.heap_strings = /* @__PURE__ */ new Set();
@@ -41751,7 +41841,7 @@ function build_assignment_node(node, status, nir_rhs, nir_swap) {
 				if (move_source !== void 0 && move_source_owns_heap) status.heap_strings?.delete(move_source);
 				if (!status.heap_strings) status.heap_strings = /* @__PURE__ */ new Set();
 				status.heap_strings.add(name);
-			} else if (rhs_is_field_read) status.last_result_is_heap = false;
+			} else if (rhs_is_field_read || rhs_is_unrecorded_var_read) status.last_result_is_heap = false;
 			else if (status.last_result_is_heap) {
 				if (!status.heap_strings) status.heap_strings = /* @__PURE__ */ new Set();
 				status.heap_strings.add(name);
@@ -41969,7 +42059,9 @@ function build_assignment_node(node, status, nir_rhs, nir_swap) {
 						get_base_address(access, status, "x0");
 						emit_asm(status, `str x0, [sp, #-16]!\n`);
 					}
-					if (!node.operator && node.right_value.node_type === "value" && node.right_value.is_moved) {
+					const field_rhs_is_moved_value = node.right_value.node_type === "value" && node.right_value.is_moved;
+					const field_rhs_is_fresh_call = !node.swap && node.right_value.node_type === "func_call";
+					if (!node.operator && (field_rhs_is_moved_value || field_rhs_is_fresh_call)) {
 						const field_resolved = resolve_struct_type(field_type, status);
 						const field_target_var = access.target.node_type === "value" ? access.target.value : "";
 						const first_init_write = is_first_init_field_write(field_target_var, field_name, status);
@@ -63202,6 +63294,7 @@ function generate_harness(tests, benches) {
 	}).join("\n");
 	let main = "\nimport System\nimport System::Test\n";
 	main += "\npub func main = () {\n";
+	main += `\tConsole.unbuffered()\n`;
 	main += "	var Tester t = Tester()\n";
 	main += "	var int64 audit_mark = 0\n";
 	main += "	var int64 audit_leaked = 0\n";
@@ -63334,7 +63427,7 @@ async function run_test_file(entry_path, lib_path, arch, audit = false, audit_ru
 		result.ms = performance.now() - start;
 		return result;
 	}
-	const audit_obj = path.join(buildDir, "audit_runtime.o");
+	const audit_obj = path.join(buildDir, path.basename(entry_path, ".nm") + "_audit.o");
 	await execFile_async("clang", [
 		"-c",
 		runtime_src,
@@ -63345,8 +63438,11 @@ async function run_test_file(entry_path, lib_path, arch, audit = false, audit_ru
 	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 ?? "");
-	fs.writeFileSync(codefile, buildResult.code);
+	const header_name = path.basename(entry_path, ".nm") + ".main.h";
+	fs.writeFileSync(path.join(buildDir, header_name), buildResult.headers ?? "");
+	let code_text = buildResult.code;
+	if (arch !== "aarch64") code_text = code_text.replace("#include \"main.h\"", `#include "${header_name}"`);
+	fs.writeFileSync(codefile, code_text);
 	let companionfile;
 	if (buildResult.companion) {
 		const comp_ext = platform === "macos" || platform === "ios" ? ".m" : ".c";
@@ -63372,20 +63468,48 @@ async function run_test_file(entry_path, lib_path, arch, audit = false, audit_ru
 		result.ms = performance.now() - start;
 		return result;
 	}
+	const run_out = outfile + ".out";
+	const run_err = outfile + ".err";
 	let runStdout = "";
+	let runStderr = "";
 	let crashed;
+	const out_fd = fs.openSync(run_out, "w");
+	const err_fd = fs.openSync(run_err, "w");
 	try {
-		runStdout = (await execFile_async(outfile, [], {
-			encoding: "utf8",
+		const child = spawn(outfile, [], {
 			timeout: 3e4,
-			maxBuffer: 16777216,
+			stdio: [
+				"ignore",
+				out_fd,
+				err_fd
+			],
 			cwd: cwd ?? process.cwd()
-		})).stdout;
-	} catch (err) {
-		runStdout = err.stdout ? err.stdout.toString() : "";
-		if (err.signal === "SIGTERM") crashed = "test binary timed out after 30s";
-		else crashed = `test binary exited abnormally (signal ${err.signal ?? err.code})`;
+		});
+		const run = await new Promise((resolve) => {
+			child.on("error", () => resolve({
+				code: null,
+				signal: null
+			}));
+			child.on("close", (code, signal) => resolve({
+				code,
+				signal
+			}));
+		});
+		if (run.signal === "SIGTERM") crashed = "test binary timed out after 30s";
+		else if (run.signal !== null) crashed = `test binary exited abnormally (signal ${run.signal})`;
+		else if (run.code === null) crashed = "test binary could not be run";
+		else if (run.code !== 0) crashed = `test binary exited abnormally (signal ${run.code})`;
+	} finally {
+		fs.closeSync(out_fd);
+		fs.closeSync(err_fd);
+	}
+	runStdout = fs.readFileSync(run_out, "utf8");
+	try {
+		runStderr = fs.readFileSync(run_err, "utf8");
+	} catch {
+		runStderr = "";
 	}
+	if (crashed && runStderr.trim()) crashed += `\n${runStderr.trim()}`;
 	const records = parse_records(runStdout);
 	result.tests = records.tests;
 	result.fails = records.fails;

package/package.json

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

package/src/test.ts

@@ -1,4 +1,4 @@
-import { execFile } from "node:child_process";
+import { execFile, spawn } from "node:child_process";
 import fs from "node:fs";
 import os from "node:os";
 import path from "node:path";
@@ -220,6 +220,11 @@ export function generate_harness(tests: TestFunction[], benches: BenchFunction[]
 	// reports as a leaking test instead of leaving the file's exit-time
 	// total unattributed.
 	main += "\npub func main = () {\n";
+	// Unbuffered stdout: a binary that crashes mid-suite still leaves every
+	// record it printed (the CLI reads them from the run's .out file), and a
+	// crash is diagnosed with the tests that PASSED before it instead of
+	// "(crashed before records)".
+	main += `\tConsole.unbuffered()\n`;
 	main += "\tvar Tester t = Tester()\n";
 	main += "\tvar int64 audit_mark = 0\n";
 	main += "\tvar int64 audit_leaked = 0\n";
@@ -398,7 +403,11 @@ export async function run_test_file(
 		result.ms = performance.now() - start;
 		return result;
 	}
-	const audit_obj = path.join(buildDir, "audit_runtime.o");
+	// Per-file audit object: two concurrent workers compiling to the SHARED
+	// `audit_runtime.o` raced — a link could read the object mid-rewrite
+	// (concurrent `clang -c` open the output with O_TRUNC) and fail, or link
+	// a stale slab. The runtime is tiny; recompiling per file costs ~0.1s.
+	const audit_obj = path.join(buildDir, path.basename(entry_path, ".nm") + "_audit.o");
 	await execFile_async("clang", ["-c", runtime_src, "-o", audit_obj]);
 	const platform = default_platform();
 	// Match the run/build command's emission: ObjC-bearing sources (GUI code
@@ -408,10 +417,19 @@ export async function run_test_file(
 	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"));
-	// The C backend's generated source does `#include "main.h"`, so write the
-	// header next to the code. (aarch64 inlines everything into the .s file.)
-	fs.writeFileSync(path.join(buildDir, "main.h"), buildResult.headers ?? "");
-	fs.writeFileSync(codefile, buildResult.code);
+	// The C backend's generated source does `#include "main.h"`, so the
+	// header lands next to the code. (aarch64 inlines everything into the
+	// .s file and ignores it.) Per-file header name: every test file shares
+	// one build folder, and two concurrent C builds writing the SAME
+	// `main.h` raced — a compile could read another file's header between
+	// the write and the clang read and fail (or mis-declare) spuriously.
+	const header_name = path.basename(entry_path, ".nm") + ".main.h";
+	fs.writeFileSync(path.join(buildDir, header_name), buildResult.headers ?? "");
+	let code_text: string = buildResult.code;
+	if (arch !== "aarch64") {
+		code_text = code_text.replace('#include "main.h"', `#include "${header_name}"`);
+	}
+	fs.writeFileSync(codefile, code_text);
 
 	// Companion C (raw-block functions + the pool/fiber/file-scope C infra):
 	// `run`/`build` compile and link it next to the main TU. The aarch64 .s
@@ -458,30 +476,63 @@ export async function run_test_file(
 		return result;
 	}
 
-	// Run the binary and collect the records it streams over stdout. A
+	// Run the binary with its stdout/stderr redirected to per-file FILES
+	// (next to the binary, doubling as debugging artifacts) instead of node
+	// pipes, then read them. (Why not pipes: this runner's parse/build
+	// phases block the event loop for tens of seconds at a time. A binary
+	// that finished inside such a block exited 0 long before its records
+	// were read, but the 30s execFile timeout that became due during the
+	// block still fired at loop-resume — and the kill path destroyed the
+	// child's unread pipe, silently dropping EVERY record: the file
+	// reported "(0 tests)" and passed. Records on disk are immune to
+	// anything the parent does after the fact.) The documented CWD
+	// contract: the binary runs in the `--in` root (the folder `nomen test`
+	// scanned for *.test.nm files), so fixture paths in tests resolve
+	// against that folder regardless of where the CLI was invoked from. A
 	// non-zero exit (crash, abort) still surfaces whatever records were
-	// emitted before the crash; a timeout is treated as a crash. The
-	// documented CWD contract: the binary runs in the `--in` root (the
-	// folder `nomen test` scanned for *.test.nm files), so fixture paths in
-	// tests resolve against that folder regardless of where the CLI was
-	// invoked from.
+	// emitted before the crash (the harness runs its stdout unbuffered, so
+	// a crashing binary keeps the records it printed); a timeout is treated
+	// as a crash.
+	const run_out = outfile + ".out";
+	const run_err = outfile + ".err";
 	let runStdout = "";
+	let runStderr = "";
 	let crashed: string | undefined;
+	const out_fd = fs.openSync(run_out, "w");
+	const err_fd = fs.openSync(run_err, "w");
 	try {
-		const run = await execFile_async(outfile, [], {
-			encoding: "utf8",
+		const child = spawn(outfile, [], {
 			timeout: 30_000,
-			maxBuffer: 16 * 1024 * 1024,
+			stdio: ["ignore", out_fd, err_fd],
 			cwd: cwd ?? process.cwd(),
 		});
-		runStdout = run.stdout;
-	} catch (err: any) {
-		runStdout = err.stdout ? err.stdout.toString() : "";
-		if (err.signal === "SIGTERM") {
+		const run = await new Promise<{ code: number | null; signal: string | null }>((resolve) => {
+			child.on("error", () => resolve({ code: null, signal: null }));
+			child.on("close", (code, signal) => resolve({ code, signal }));
+		});
+		if (run.signal === "SIGTERM") {
 			crashed = "test binary timed out after 30s";
-		} else {
-			crashed = `test binary exited abnormally (signal ${err.signal ?? err.code})`;
+		} else if (run.signal !== null) {
+			crashed = `test binary exited abnormally (signal ${run.signal})`;
+		} else if (run.code === null) {
+			crashed = "test binary could not be run";
+		} else if (run.code !== 0) {
+			crashed = `test binary exited abnormally (signal ${run.code})`;
 		}
+	} finally {
+		fs.closeSync(out_fd);
+		fs.closeSync(err_fd);
+	}
+	runStdout = fs.readFileSync(run_out, "utf8");
+	try {
+		runStderr = fs.readFileSync(run_err, "utf8");
+	} catch {
+		runStderr = "";
+	}
+	if (crashed && runStderr.trim()) {
+		// A crashed binary's own diagnosis (a libmalloc abort message, a
+		// panic dump) goes to stderr — surface it with the crash record.
+		crashed += `\n${runStderr.trim()}`;
 	}
 
 	const records = parse_records(runStdout);