nomen-lang 0.6.9 → 0.6.11

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";
@@ -2122,8 +2122,40 @@ function try_parse_operands(parts) {
 * is not an instruction — label, directive, comment, blank, OR an
 * instruction outside the contract table). Shared by the validator and the
 * phase-2 optimizer so both see identical shapes.
-*/
+*
+* Memoized by raw text: the post-processing pipeline (frame slots, coalesce,
+* loop promote, if-convert, float forwarding, widen masks, …) plus the
+* validators each re-parse the SAME instruction texts — prologue/epilogue
+* lines repeat across every function, so the hit rate is very high. Every
+* call returns a PRIVATE deep copy (the passes treat parsed instructions as
+* mutable IR — coalesce renames operands in place — so sharing a parsed
+* object would corrupt the memo and cross-pass state).
+*/
+const parse_memo = /* @__PURE__ */ new Map();
+const PARSE_MEMO_CAP = 2e5;
+function clone_parsed(c, line) {
+	return {
+		text: c.text,
+		op: c.op,
+		setsFlags: c.setsFlags,
+		readsFlags: c.readsFlags,
+		operands: c.operands.map((o) => {
+			const copy = { ...o };
+			if (copy.kind === "mem" && copy.offset) copy.offset = { ...copy.offset };
+			return copy;
+		}),
+		line
+	};
+}
 function parse_asm_instruction(text, line) {
+	const cached = parse_memo.get(text);
+	if (cached !== void 0) return cached === null ? null : clone_parsed(cached, line);
+	const parsed = parse_asm_instruction_uncached(text, line);
+	if (parse_memo.size >= PARSE_MEMO_CAP) parse_memo.clear();
+	parse_memo.set(text, parsed ? clone_parsed(parsed, 0) : null);
+	return parsed;
+}
+function parse_asm_instruction_uncached(text, line) {
 	const t = strip_comment$1(text).trim();
 	const m = /^([a-z][a-z0-9.]*)\s*(.*)$/.exec(t);
 	if (!m) return null;
@@ -2274,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;
@@ -2407,34 +2446,13 @@ function validate_asm(code) {
 	}
 	return errors;
 }
-/**
-* The deferred phase-1 check: every function's sp must return to its entry
-* value at each `ret`. A LINEAR scan double-counts across diamond control
-* flow (`b .epilogue` skipping the sibling path's `add sp` — the classic
-* false positive on bool_to_string), so this runs a per-block dataflow over
-* the lifted function bodies:
-*
-* - Block splitting: labels and branch/terminator instructions bound blocks,
-*   exactly like the CFG the emitters produce.
-* - Per-instruction sp effects: pre-indexed `stp/str [sp, #-N]!` subtracts,
-*   post-indexed `ldp/ldr [sp], #N` adds, `sub/add sp, sp, #imm` adjusts;
-*   any other sp write (`mov sp, xN`, register-scaled adds, `ldr sp, …`)
-*   is UNKNOWN and conservatively poisons downstream deltas.
-* - Join = require equal deltas or unknown: a label reached by paths with
-*   differing deltas becomes unknown; only a KNOWN non-zero delta at a
-*   `ret` is reported. Unknown never errors — the check is conservative by
-*   construction (no false positives, only silence).
-* - `bl`/`blr` preserve sp (the callee rebalances under the ABI) and do not
-*   terminate blocks; `br xN` (tail-jump) ends propagation with no check;
-*   `svc` continues (the kernel preserves sp).
-* - Branch targets resolve within the function, including the numeric local
-*   form raw `#arch` blocks use (`1:` / `b.hs 1f` — forward/backward by
-*   suffix); an unresolvable target makes downstream deltas unknown.
-*/
-function validate_stack_balance(code) {
-	const { result } = lift_functions(code);
-	if (!result.ok) return [];
+/** Stack-balance check over an ALREADY-lifted result — lets the build
+*  pipeline lift+validate once and share the structured functions between
+*  the shape/branch validation and the balance pass (lift_functions runs
+*  validate_asm internally, so re-lifting per check doubled the cost). */
+function stack_balance_errors_from_lift(result) {
 	const errors = [];
+	if (!result.ok) return [];
 	for (const fn of result.functions) check_function_balance(fn, errors);
 	return errors;
 }
@@ -2562,37 +2580,37 @@ function line_effect(text) {
 	};
 }
 /** Resolve a branch target token to a body line index, or null when the
-*  target is outside this function / unresolved (numeric f/b forms scan
-*  linearly, matching the assembler's semantics). */
-function resolve_target(token, from, body) {
+*  target is outside this function. Backed by the per-function label maps
+*  built once in check_function_balance — a linear rescan of the body per
+*  pending branch used to be the single hottest spot in large builds
+*  (branches × body-length re-stripping + regex). Numeric `Nf`/`Nb` forms
+*  resolve directionally against the (possibly redefined) definitions,
+*  matching the assembler's semantics; a named label resolves to its FIRST
+*  definition (the old body scan returned the first match too). */
+function resolve_target(token, from, named_labels, numeric_labels) {
 	const numeric = /^(\d+)([fb])$/.exec(token);
 	if (numeric) {
-		const n = numeric[1];
+		const defs = numeric_labels.get(numeric[1]);
+		if (!defs) return null;
 		if (numeric[2] === "f") {
-			for (let i = from + 1; i < body.length; i++) {
-				const lm = /^(\d+):/.exec(strip_comment$1(body[i].text).trim());
-				if (lm && lm[1] === n) return i;
-			}
+			for (let k = 0; k < defs.length; k++) if (defs[k] > from) return defs[k];
 			return null;
 		}
-		for (let i = from - 1; i >= 0; i--) {
-			const lm = /^(\d+):/.exec(strip_comment$1(body[i].text).trim());
-			if (lm && lm[1] === n) return i;
-		}
+		for (let k = defs.length - 1; k >= 0; k--) if (defs[k] < from) return defs[k];
 		return null;
 	}
-	for (let i = 0; i < body.length; i++) {
-		const lm = LABEL_RE.exec(strip_comment$1(body[i].text).trim());
-		if (lm && lm[1] === token) return i;
-	}
-	return null;
+	return named_labels.get(token) ?? null;
 }
 function check_function_balance(fn, errors) {
 	const body = fn.body;
+	const stripped_text = [];
 	const effects = [];
 	const is_code = [];
+	const named_labels = /* @__PURE__ */ new Map();
+	const numeric_labels = /* @__PURE__ */ new Map();
 	for (let i = 0; i < body.length; i++) {
 		const t = strip_comment$1(body[i].text).trim();
+		stripped_text.push(t);
 		effects.push({
 			delta: null,
 			branch: null,
@@ -2601,8 +2619,15 @@ function check_function_balance(fn, errors) {
 			unknown_jump: false
 		});
 		is_code.push(false);
-		if (!t) continue;
 		const lm = LABEL_RE.exec(t);
+		if (lm) {
+			if (/^\d+$/.test(lm[1])) {
+				const defs = numeric_labels.get(lm[1]);
+				if (defs) defs.push(i);
+				else numeric_labels.set(lm[1], [i]);
+			} else if (!named_labels.has(lm[1])) named_labels.set(lm[1], i);
+		}
+		if (!t) continue;
 		const rest = lm ? lm[2].trim() : t;
 		if (rest.startsWith(".") || /^[\w.$]+\s*=\s*[\w.$]+$/.test(rest) || !rest) continue;
 		is_code[i] = true;
@@ -2614,7 +2639,7 @@ function check_function_balance(fn, errors) {
 	let cur = -1;
 	let terminated = true;
 	for (let i = 0; i < body.length; i++) {
-		const t = strip_comment$1(body[i].text).trim();
+		const t = stripped_text[i];
 		if (!t) continue;
 		if (LABEL_RE.test(t)) {
 			cur++;
@@ -2662,7 +2687,7 @@ function check_function_balance(fn, errors) {
 		}
 	}
 	for (const p of pending) {
-		const line = resolve_target(p.token, p.from, body);
+		const line = resolve_target(p.token, p.from, named_labels, numeric_labels);
 		blocks[p.block].targets.push(line === null ? null : line_block.get(line) ?? null);
 	}
 	const preds = Array.from({ length: blocks.length }, () => []);
@@ -7511,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;
@@ -8972,6 +9004,85 @@ function record_ctor_heap_default_fields(var_name, struct_node, status, is_owned
 	}
 }
 //#endregion
+//#region ../src/build_common/destroy_analysis.ts
+/**
+* Whether any field of the struct is an enum-with-data value owning heap
+* payloads (a string payload — always heap, case construction strdups it —
+* or a class/trait reference payload — construction transfers ownership).
+* Such a field must be reclaimed when the struct dies.
+*/
+function struct_has_owning_enum_field(struct, table) {
+	for (const field of struct.fields) {
+		if (field.type.is_ref) continue;
+		const en = table.enums?.find((e) => e.name === field.type.name);
+		if (!en?.has_associated_data) continue;
+		for (const c of en.cases) for (const p of c.params) {
+			if (p.type.name === "string" && !p.type.is_array) return true;
+			if (table.traits?.some((t) => t.name === p.type.name)) return true;
+			if (table.structs.find((s) => s.name === p.type.name)?.is_class) return true;
+		}
+	}
+	return false;
+}
+/**
+* Whether a struct declares its own `#destroy` (user side effects /
+* resource release).
+*/
+function has_destroy(struct) {
+	return !!struct.functions.find((f) => f.name === "#destroy");
+}
+/**
+* Whether any field (recursively) requires destroy handling — a class
+* field (heap instance to reclaim) or a nested struct with its own
+* `#destroy` (or nested fields that do). Deliberately excludes `string`
+* fields: a struct local whose only owning fields are strings is NOT
+* auto-destroyed at scope exit (the strings may be raw rodata arg
+* pointers, not heap) — see `struct_needs_auto_destroy` for the broader
+* form used to decide whether a `<Struct>_destroy` function is generated.
+*/
+function has_struct_fields_with_destroy(struct, table) {
+	for (const field of struct.fields) {
+		if (field.type.is_ref) continue;
+		const field_struct = resolve_struct_type(field.type, table);
+		if (!field_struct) continue;
+		if (field_struct.is_class) return true;
+		if (has_destroy(field_struct)) return true;
+		if (has_struct_fields_with_destroy(field_struct, table)) return true;
+	}
+	return false;
+}
+/**
+* Whether a struct (or any embedded struct field, recursively) needs a
+* destroy call at scope exit — it has a `#destroy`, a class-typed field,
+* or a nested struct field that itself needs destroying. This does NOT
+* count `string` fields (see `has_struct_fields_with_destroy`).
+*/
+function struct_needs_destroy(struct, table) {
+	return has_destroy(struct) || has_struct_fields_with_destroy(struct, table) || struct_has_owning_enum_field(struct, table);
+}
+/**
+* Whether a struct needs an auto-generated `<Struct>_destroy` function.
+* Broader than `struct_needs_destroy`: also returns true for structs with
+* `string` fields, because a Buffer<T> for such a struct deep-copies the
+* strings into slots (strdup on store) and the per-element destroy must
+* free them. The generated destroy frees each string field; it is called
+* from Buffer's specialized #destroy / replace_T, NOT from struct local
+* scope exit (`struct_needs_destroy` governs that path and excludes
+* strings).
+*/
+function struct_needs_auto_destroy(struct, table) {
+	if (struct_needs_destroy(struct, table)) return true;
+	if (struct_has_owning_enum_field(struct, table)) return true;
+	for (const field of struct.fields) {
+		if (field.type.is_ref) continue;
+		if (field.type.is_view) continue;
+		if (field.type.name === "string" && !field.type.is_array) return true;
+		const field_struct = resolve_struct_type(field.type, table);
+		if (field_struct && !field_struct.is_class && struct_needs_auto_destroy(field_struct, table)) return true;
+	}
+	return false;
+}
+//#endregion
 //#region ../src/nodes/child_nodes.ts
 /** Whether `value` is an AST node (carries a string `node_type`). */
 function is_ast_node(value) {
@@ -11648,85 +11759,6 @@ function array_struct_name(type, status) {
 	return status.structs.find((s) => s.name === mono && !s.is_generic) ? mono : void 0;
 }
 //#endregion
-//#region ../src/build_common/destroy_analysis.ts
-/**
-* Whether any field of the struct is an enum-with-data value owning heap
-* payloads (a string payload — always heap, case construction strdups it —
-* or a class/trait reference payload — construction transfers ownership).
-* Such a field must be reclaimed when the struct dies.
-*/
-function struct_has_owning_enum_field(struct, table) {
-	for (const field of struct.fields) {
-		if (field.type.is_ref) continue;
-		const en = table.enums?.find((e) => e.name === field.type.name);
-		if (!en?.has_associated_data) continue;
-		for (const c of en.cases) for (const p of c.params) {
-			if (p.type.name === "string" && !p.type.is_array) return true;
-			if (table.traits?.some((t) => t.name === p.type.name)) return true;
-			if (table.structs.find((s) => s.name === p.type.name)?.is_class) return true;
-		}
-	}
-	return false;
-}
-/**
-* Whether a struct declares its own `#destroy` (user side effects /
-* resource release).
-*/
-function has_destroy(struct) {
-	return !!struct.functions.find((f) => f.name === "#destroy");
-}
-/**
-* Whether any field (recursively) requires destroy handling — a class
-* field (heap instance to reclaim) or a nested struct with its own
-* `#destroy` (or nested fields that do). Deliberately excludes `string`
-* fields: a struct local whose only owning fields are strings is NOT
-* auto-destroyed at scope exit (the strings may be raw rodata arg
-* pointers, not heap) — see `struct_needs_auto_destroy` for the broader
-* form used to decide whether a `<Struct>_destroy` function is generated.
-*/
-function has_struct_fields_with_destroy(struct, table) {
-	for (const field of struct.fields) {
-		if (field.type.is_ref) continue;
-		const field_struct = resolve_struct_type(field.type, table);
-		if (!field_struct) continue;
-		if (field_struct.is_class) return true;
-		if (has_destroy(field_struct)) return true;
-		if (has_struct_fields_with_destroy(field_struct, table)) return true;
-	}
-	return false;
-}
-/**
-* Whether a struct (or any embedded struct field, recursively) needs a
-* destroy call at scope exit — it has a `#destroy`, a class-typed field,
-* or a nested struct field that itself needs destroying. This does NOT
-* count `string` fields (see `has_struct_fields_with_destroy`).
-*/
-function struct_needs_destroy(struct, table) {
-	return has_destroy(struct) || has_struct_fields_with_destroy(struct, table) || struct_has_owning_enum_field(struct, table);
-}
-/**
-* Whether a struct needs an auto-generated `<Struct>_destroy` function.
-* Broader than `struct_needs_destroy`: also returns true for structs with
-* `string` fields, because a Buffer<T> for such a struct deep-copies the
-* strings into slots (strdup on store) and the per-element destroy must
-* free them. The generated destroy frees each string field; it is called
-* from Buffer's specialized #destroy / replace_T, NOT from struct local
-* scope exit (`struct_needs_destroy` governs that path and excludes
-* strings).
-*/
-function struct_needs_auto_destroy(struct, table) {
-	if (struct_needs_destroy(struct, table)) return true;
-	if (struct_has_owning_enum_field(struct, table)) return true;
-	for (const field of struct.fields) {
-		if (field.type.is_ref) continue;
-		if (field.type.is_view) continue;
-		if (field.type.name === "string" && !field.type.is_array) return true;
-		const field_struct = resolve_struct_type(field.type, table);
-		if (field_struct && !field_struct.is_class && struct_needs_auto_destroy(field_struct, table)) return true;
-	}
-	return false;
-}
-//#endregion
 //#region ../src/build_common/scan_force_heap_strings.ts
 function scan_force_heap_strings(statements, structs) {
 	const result = /* @__PURE__ */ new Set();
@@ -14909,7 +14941,33 @@ function emit_base_ptr(status, decl_name, is_class_parent) {
 	if (is_class_parent) emit_var_load(status, "x0", decl_name, 8);
 	else emit_var_address(status, "x0", decl_name);
 }
-function emit_field_destroys(status, struct_type, decl_name, base_offset, is_class_parent, free_strings = true) {
+/**
+* Reclaim a struct's owning fields in place (base + every nested owning field).
+*
+* `base_offset` (added to each field offset) and `is_class_parent` (a class's
+* base is a pointer LOADED from the slot; a value struct is inline AT it)
+* locate `decl_name`'s storage.
+*
+* `free_strings` is REQUIRED — it is a per-call-site OWNOWNITY fact, not a
+* per-type one, so it deliberately has no default:
+* - `true` from a DESTROY function (`<T>_destroy`), which only ever runs on
+*   heap-owned storage: a class's plain string fields are always heap-owned
+*   (`_init` strdup's defaults, assignments strdup a non-heap RHS), and a
+*   VALUE struct arrives with the per-slot copies `store_T`/`_copy` strdup'd
+*   (Buffer per-element teardown, the displaced-field reclaim, the
+*   anchor-slot walk). Matches C's build_auto_destroy, which frees string
+*   fields unconditionally.
+* - `false` from struct-LOCAL scope exit, where a string field may still hold
+*   a rodata literal (aarch64 constructors don't strdup) and freeing it would
+*   `free` rodata (SIGABRT).
+*
+* A default (`= true`) previously stood in for the `true` arm while
+* `node.is_class` (undefined on plain parsed structs) was passed as if it
+* selected between the arms — so the day `is_class` becomes explicitly false,
+* value-struct slot strings would silently stop being reclaimed. Passing the
+* boolean at every call site makes both arms visible.
+*/
+function emit_field_destroys(status, struct_type, decl_name, base_offset, is_class_parent, free_strings) {
 	const destroy_fields = struct_type.is_class ? layout_fields(struct_type, status) : struct_type.fields;
 	for (const field of destroy_fields) {
 		const offset = get_field_offset_of_fields(destroy_fields, field.name, status);
@@ -20720,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
 				});
 			}
 		}
@@ -20837,6 +20898,16 @@ 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);
@@ -21047,6 +21118,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;
@@ -21215,7 +21287,7 @@ function build_destroy_function(node, func, status) {
 			status.code = status.code.slice(0, after_prologue) + saves + status.code.slice(after_prologue);
 		}
 	}
-	if (node.is_class) emit_field_destroys(status, node, "self", void 0, false);
+	if (node.is_class) emit_field_destroys(status, node, "self", void 0, false, true);
 	emit_asm(status, `${return_label}:\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`);
@@ -21272,7 +21344,7 @@ function build_auto_destroy_function(node, status) {
 	status.function_param_regs.set("self", "x19");
 	emit_asm(status, `sub sp, sp, #${stack_placeholder}\n`);
 	emit_asm(status, `mov x29, sp\n`);
-	emit_field_destroys(status, node, "self", void 0, false, node.is_class);
+	emit_field_destroys(status, node, "self", void 0, false, true);
 	emit_asm(status, `${return_label}:\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`);
@@ -22172,7 +22244,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);
@@ -22181,7 +22256,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);
@@ -22189,7 +22265,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
 				});
 			}
 		}
@@ -22244,6 +22321,16 @@ 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);
@@ -22689,6 +22776,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);
 		}
@@ -22698,6 +22786,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;
@@ -23874,7 +23963,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;
@@ -23896,7 +23984,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) {
@@ -24784,8 +24871,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`);
@@ -24988,6 +25079,17 @@ function build_declaration_node$1(node, status, nir_init, nir_swap) {
 				check_heap();
 				return;
 			}
+			const decl_string_field_read = node.type.name === "string" && !node.type.is_view && !node.type.is_array && size === 16 && node.value.node_type === "access" && node.value.access.node_type === "access_field";
+			if (decl_string_field_read && !!status.force_heap_strings?.has(node.name)) {
+				emit_init_value$1(node.value, nir_init, status);
+				ensure_newline(status);
+				emit_strdup_string(status);
+				emit_var_store(status, "x0", node.name, size);
+				mark_heap_string(status, node.name);
+				status.last_result_is_heap = false;
+				return;
+			}
+			if (decl_string_field_read) status.last_result_is_heap = false;
 			emit_init_value$1(node.value, nir_init, status);
 			emit_var_store(status, "x0", node.name, size);
 			check_heap();
@@ -31044,6 +31146,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;
@@ -31075,6 +31181,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) {
@@ -33565,13 +33683,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);
@@ -36790,9 +36910,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);
@@ -37679,6 +37806,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);
@@ -41684,7 +41817,11 @@ function build_assignment_node(node, status, nir_rhs, nir_swap) {
 			const rhs_is_string_var = !node.swap && !!rhs_value && typeof rhs_value.value === "string" && /^[A-Za-z_][A-Za-z0-9_]*$/.test(rhs_value.value) && rhs_value.value !== "true" && rhs_value.value !== "false" && rhs_value.value !== "null" && !rhs_value.is_moved && size === 16 && rhs_value.type?.name === "string" && !rhs_value.type?.is_view;
 			const move_source = rhs_is_string_var && node.last_use_move && move_on_last_use_enabled() ? rhs_value.value : void 0;
 			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 borrow_needs_dup = !node.swap && size === 16 && is_string_borrow(node.right_value) && !!status.force_heap_strings?.has(name);
+			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 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();
@@ -41694,7 +41831,8 @@ 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 (status.last_result_is_heap) {
+			} 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);
 			} else if (explicit_move_source !== void 0 && status.heap_strings?.delete(explicit_move_source)) status.heap_strings.add(name);
@@ -41911,6 +42049,24 @@ function build_assignment_node(node, status, nir_rhs, nir_swap) {
 						get_base_address(access, status, "x0");
 						emit_asm(status, `str x0, [sp, #-16]!\n`);
 					}
+					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);
+						mark_init_field_write(field_target_var, field_name, status);
+						if (field_resolved && !field_resolved.is_class && !first_init_write && struct_needs_auto_destroy(field_resolved, status)) {
+							if (base_reg !== void 0) {
+								if (offset !== 0) emit_asm(status, `add x0, ${base_reg}, #${offset}\n`);
+								else emit_asm(status, `mov x0, ${base_reg}\n`);
+							} else {
+								emit_asm(status, `ldr x0, [sp]\n`);
+								if (offset !== 0) emit_asm(status, `add x0, x0, #${offset}\n`);
+							}
+							emit_asm(status, `bl ${field_resolved.name}_destroy\n`);
+						}
+					}
 					get_source_address(node.right_value, status, nir_rhs);
 					ensure_newline(status);
 					emit_asm(status, `mov x1, x0\n`);
@@ -47312,7 +47468,8 @@ function build(root, options = {}) {
 			status.code = status.code.replaceAll("bl _strdup\n", "bl _nomen_strdup_wrap\n");
 			status.code = status.code.replaceAll("bl _free\n", "bl _nomen_free_wrap\n");
 		}
-		const lift_errors = validate_asm(status.code);
+		const { result: lifted } = lift_functions(status.code);
+		const lift_errors = lifted.errors;
 		if (lift_errors.length > 0) {
 			if (!status.build_errors) status.build_errors = [];
 			for (const e of lift_errors.slice(0, 20)) status.build_errors.push({
@@ -47320,7 +47477,7 @@ function build(root, options = {}) {
 				start: 0
 			});
 		}
-		const balance_errors = validate_stack_balance(status.code);
+		const balance_errors = stack_balance_errors_from_lift(lifted);
 		if (balance_errors.length > 0) {
 			if (!status.build_errors) status.build_errors = [];
 			for (const e of balance_errors.slice(0, 20)) status.build_errors.push({
@@ -63125,11 +63282,20 @@ function generate_harness(tests, benches) {
 		const n = Math.min(raw, 4096);
 		return template.replace(/__NAME__/g, b.name).replace(/__TARGET__/g, b.target).replace(/__N__/g, String(n));
 	}).join("\n");
-	let main = "\nimport System\nimport System::Test\n\npub func main = () {\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";
 	for (const test of tests) {
+		main += `\taudit_mark = Tester.audit_count()\n`;
 		main += `\tt.begin_test("${escape_nm_string(test.name)}")\n`;
 		main += `\t${test.name}(ref t)\n`;
+		main += `\taudit_leaked = Tester.audit_count() - audit_mark\n`;
+		main += `\tif audit_leaked > 0 {\n`;
+		main += `\t\tConsole.write_line("\\\\nomen|leaks|" + "${escape_nm_string(test.name)}" + "|\\{audit_leaked}")\n`;
+		main += `\t}\n`;
 		main += `\tt.end_test()\n`;
 	}
 	for (const bench of benches) {
@@ -63148,6 +63314,7 @@ function parse_records(stdout) {
 	const tests = [];
 	const fails = [];
 	const benches = [];
+	const leaks = [];
 	const other = [];
 	for (const line of stdout.split("\n")) {
 		if (!line.startsWith(RECORD_PREFIX)) {
@@ -63166,6 +63333,10 @@ function parse_records(stdout) {
 			test: parts[1],
 			message: parts.slice(2).join("|")
 		});
+		else if (kind === "leaks") leaks.push({
+			test: parts[1],
+			count: parseInt(parts[2] || "0", 10)
+		});
 		else if (kind === "bench") benches.push({
 			label: parts[1],
 			n: parseInt(parts[2] || "0", 10),
@@ -63180,12 +63351,19 @@ function parse_records(stdout) {
 		tests,
 		fails,
 		benches,
+		leaks,
 		other
 	};
 }
-/** Pull the exit-time audit "LEAK: N allocation(s)" lines out of stdout. */
+/**
+* Pull the exit-time audit lines out of stdout: "LEAK: N allocation(s)" (a
+* nonzero malloc/free balance) and "AUDIT-STALE-FREE: N pointer(s) freed that
+* were not live audit allocations" (a free that matched no live block — a
+* foreign pointer or a double free; the runtime no longer passes those to
+* libc free, so this is the only record they leave). Both fail the file.
+*/
 function extract_leaks(stdout) {
-	return stdout.split("\n").map((l) => l.trim()).filter((l) => l.startsWith("LEAK:"));
+	return stdout.split("\n").map((l) => l.trim()).filter((l) => l.startsWith("LEAK:") || l.startsWith("AUDIT-STALE-FREE:"));
 }
 /**
 * Compile one `*.test.nm` file (with the generated harness) and run it,
@@ -63201,8 +63379,9 @@ async function run_test_file(entry_path, lib_path, arch, audit = false, audit_ru
 		tests: [],
 		fails: [],
 		benches: [],
-		other: [],
 		leaks: [],
+		leaking_tests: [],
+		other: [],
 		ms: 0
 	};
 	const resolved = path.resolve(entry_path);
@@ -63230,30 +63409,30 @@ async function run_test_file(entry_path, lib_path, arch, audit = false, audit_ru
 	}
 	const buildDir = build_dir_for(resolved, true);
 	if (!fs.existsSync(buildDir)) fs.mkdirSync(buildDir, { recursive: true });
-	let audit_obj;
-	if (audit) {
-		const runtime_src = audit_runtime ? path.resolve(audit_runtime) : find_audit_runtime(path.dirname(resolved)) ?? find_bundled_audit_runtime();
-		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;
-		}
-		audit_obj = path.join(buildDir, "audit_runtime.o");
-		await execFile_async("clang", [
-			"-c",
-			runtime_src,
-			"-o",
-			audit_obj
-		]);
+	const runtime_src = audit_runtime ? path.resolve(audit_runtime) : find_audit_runtime(path.dirname(resolved)) ?? find_bundled_audit_runtime();
+	if (!runtime_src || !fs.existsSync(runtime_src)) {
+		result.ok = false;
+		result.phase = "setup";
+		result.crashed = "audit_runtime.c was not found. Pass --audit-runtime <path>.";
+		result.ms = performance.now() - start;
+		return result;
 	}
+	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();
 	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";
@@ -63279,27 +63458,56 @@ 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;
 	result.benches = records.benches;
+	result.leaking_tests = records.leaks;
 	result.other = records.other;
 	result.leaks = audit ? extract_leaks(runStdout) : [];
-	if (result.leaks.length) result.other = result.other.filter((l) => !l.trim().startsWith("LEAK:"));
+	if (result.leaks.length) result.other = result.other.filter((l) => !l.trim().startsWith("LEAK:") && !l.trim().startsWith("AUDIT-STALE-FREE:"));
 	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.leaks.length === 0;
@@ -63340,6 +63548,10 @@ function report_file(result) {
 	if (result.crashed) console.log(C.red(`   ${result.crashed}`));
 	for (const f of result.fails) console.log(`   ${C.red("✗")} ${f.test} ${C.dim(">")} ${f.message}`);
 	for (const leak of result.leaks) console.log(`   ${C.yellow("⚠")} ${C.yellow(leak)}`);
+	if (result.leaks.length) {
+		for (const lt of result.leaking_tests) console.log(`   ${C.yellow("⚠")} ${lt.test} ${C.dim(`leaked ${lt.count} allocation(s)`)}`);
+		if (!result.leaking_tests.length) console.log(`   ${C.yellow("⚠")} ${C.yellow("LEAK: no per-test attribution — leaked outside a test (harness/setup/teardown) or crashed mid-test")}`);
+	}
 	for (const b of result.benches) console.log(`   ${C.cyan("⏱")} ${b.label} ${C.dim(`(n=${b.n})`)} ${C.dim("min")} ${fmt_ns(b.min)} ${C.dim("median")} ${fmt_ns(b.median)} ${C.dim("mean")} ${fmt_ns(Math.round(b.mean))} ${C.dim("max")} ${fmt_ns(b.max)} ${C.dim("±")} ${fmt_ns(Math.round(b.stddev))}`);
 	if (result.other.length) {
 		console.log(C.dim("   --- test stdout ---"));
@@ -63395,11 +63607,12 @@ async function runTests(root, options = {}) {
 	const totalFailed = results.reduce((a, r) => a + r.tests.reduce((x, t) => x + t.failed, 0), 0);
 	const totalPassed = totalTests - totalFailed;
 	const totalLeaks = results.reduce((a, r) => a + r.leaks.length, 0);
+	const totalLeakingTests = results.reduce((a, r) => a + r.leaking_tests.length, 0);
 	const anyFailed = results.some((r) => !r.ok);
 	console.log("");
 	console.log(` ${C.dim("Files ")} ${C.green(`${totalFilesPassed} passed`)}` + (totalFilesFailed ? ` ${C.dim("|")} ${C.red(`${totalFilesFailed} failed`)}` : "") + C.dim(` (${totalFiles})`));
 	console.log(` ${C.dim("Tests ")} ${C.green(`${totalPassed} passed`)}` + (totalFailed ? ` ${C.dim("|")} ${C.red(`${totalFailed} failed`)}` : "") + C.dim(` (${totalTests})`));
-	if (totalLeaks) console.log(` ${C.dim("Leaks ")} ${C.yellow(`${totalLeaks} reported`)}` + C.dim(" (--audit; leaked files count as failures)"));
+	if (totalLeaks) console.log(` ${C.dim("Leaks ")} ${C.yellow(`${totalLeakingTests} leaking test(s)`)}` + (totalLeakingTests !== totalLeaks ? C.dim(` (${totalLeaks} leaked file(s))`) : "") + C.dim(" (--audit; leaking tests fail their file)"));
 	console.log(` ${C.dim(" Time ")} ${format_duration(elapsed)}`);
 	console.log("");
 	return !anyFailed;
@@ -63681,7 +63894,7 @@ function processFile(filename, config, mode, program_args) {
 	console.log(`Created ${codefile} in ${(compileTime - startTime).toFixed(2)}ms`);
 	console.log("");
 	startTime = performance.now();
-	const audit_obj = config.audit ? compile_audit_runtime(config, resolved, buildDir) : void 0;
+	const audit_obj = config.audit || result.code.includes("nomen_audit_count") ? compile_audit_runtime(config, resolved, buildDir) : void 0;
 	let link_inputs = codefile;
 	if (companionfile) link_inputs += ` ${companionfile}`;
 	if (audit_obj) link_inputs += ` ${audit_obj}`;