nomen-lang 0.6.8 → 0.6.10

package/dist/index.mjs

@@ -1,13 +1,14 @@
 #! /usr/bin/env node
-import { execFileSync, execSync } from "node:child_process";
+import { execFile, execFileSync, execSync } 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";
 import { EventEmitter } from "node:events";
 import { lstat, open, readdir, realpath, stat as stat$1 } from "node:fs/promises";
 import { Readable } from "node:stream";
-import { type } from "node:os";
+import os, { type } from "node:os";
 import { fileURLToPath } from "node:url";
+import { promisify } from "node:util";
 //#region ../node_modules/.pnpm/readdirp@5.1.1/node_modules/readdirp/index.js
 const EntryTypes = {
 	FILE_TYPE: "files",
@@ -2121,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;
@@ -2406,34 +2439,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;
 }
@@ -2561,37 +2573,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,
@@ -2600,8 +2612,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;
@@ -2613,7 +2632,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++;
@@ -2661,7 +2680,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 }, () => []);
@@ -8971,6 +8990,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) {
@@ -11647,85 +11745,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();
@@ -14908,7 +14927,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);
@@ -15134,6 +15179,33 @@ function emit_destroy_for_scope(status, declarations_before) {
 				emit_asm(status, `ldr x19, [sp], #16\n`);
 				continue;
 			}
+			if (status.heap_array_vars?.has(decl.name)) {
+				if (status.heap_owned_string_arrays?.has(decl.name)) {
+					emit_asm(status, `str x19, [sp, #-16]!\n`);
+					emit_asm(status, `str x20, [sp, #-16]!\n`);
+					emit_var_load(status, "x0", decl.name, 8);
+					emit_asm(status, `mov x19, x0\n`);
+					emit_asm(status, `ldr x20, [x19]\n`);
+					emit_asm(status, `add x19, x19, #8\n`);
+					const loop = `.Lhosa_${decl.name}`;
+					emit_asm(status, `${loop}:\n`);
+					emit_asm(status, `cbz x20, .Lhosa_done_${decl.name}\n`);
+					emit_asm(status, `ldr x0, [x19]\n`);
+					emit_free(status);
+					emit_asm(status, `add x19, x19, #16\n`);
+					emit_asm(status, `sub x20, x20, #1\n`);
+					emit_asm(status, `b ${loop}\n`);
+					emit_asm(status, `.Lhosa_done_${decl.name}:\n`);
+					emit_var_load(status, "x0", decl.name, 8);
+					emit_free(status);
+					emit_asm(status, `ldr x20, [sp], #16\n`);
+					emit_asm(status, `ldr x19, [sp], #16\n`);
+					continue;
+				}
+				emit_var_load(status, "x0", decl.name, 8);
+				emit_free(status);
+				continue;
+			}
 			if (status.heap_strings?.has(decl.name)) {
 				emit_var_load(status, "x0", decl.name, 8);
 				emit_free(status);
@@ -21187,7 +21259,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`);
@@ -21244,7 +21316,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`);
@@ -24960,6 +25032,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();
@@ -33540,7 +33623,8 @@ 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 access_lhs = node.left_value;
 		const field_type = access_lhs.access.type;
-		const field_struct = field_type?.name && !field_type.is_view && !field_type.is_array ? status.structs.find((s) => s.name === field_type.name && !s.is_simple_type && !s.is_class) : void 0;
+		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);
 			const saved_len = begin_code_scratch(status);
@@ -39017,10 +39101,31 @@ function build_access_node$1(node, status) {
 						status.code += `${ret_c} ${ctor_temp_val} = `;
 					}
 				}
+				const owned_string_recv = !ctor_temp_receiver && (node.target.node_type === "func_call" || node.target.node_type === "access" && node.target.access.node_type === "access_func") && method_type?.name === "string" && !method_type.is_view && !is_string_borrow(node.target);
+				let owned_recv_temp;
+				let owned_recv_val;
+				if (owned_string_recv) {
+					const id = status.label_counter = (status.label_counter ?? 0) + 1;
+					owned_recv_temp = `_osrecv_${id}`;
+					status.code += `({ nomen_string ${owned_recv_temp} = `;
+					{
+						const saved_suppress = status.suppress_dereference;
+						status.suppress_dereference = true;
+						build_node$1(node.target, status);
+						status.suppress_dereference = saved_suppress;
+					}
+					status.code += `; `;
+					const recv_ret_c = c_return_type((target_method ?? trait_default_func)?.return_type ?? access_func.type, status);
+					if (recv_ret_c !== "void") {
+						owned_recv_val = `_osrecvv_${id}`;
+						status.code += `${recv_ret_c} ${owned_recv_val} = `;
+					}
+				}
 				if (lambda_ret_tmp) status.code += `${lambda_ret_c} ${lambda_ret_tmp} = `;
 				status.code += `${label}(`;
 				if (!access_func.is_static) {
 					if (ctor_temp_free) status.code += ctor_temp_free;
+					else if (owned_recv_temp) status.code += owned_recv_temp;
 					else if (array_wrap) status.code += array_wrap.self_expr;
 					else {
 						const method_self_is_ref = !!target_method?.params?.some((p) => p.is_self_param && (p.is_ref || p.type?.is_ref));
@@ -39105,6 +39210,11 @@ function build_access_node$1(node, status) {
 					if (ctor_temp_val) status.code += ` ${ctor_temp_val};`;
 					status.code += ` })`;
 				}
+				if (owned_recv_temp) {
+					status.code += `; ${status.audit ? "nomen_free_wrap" : "free"}(${owned_recv_temp}.ptr);`;
+					if (owned_recv_val) status.code += ` ${owned_recv_val};`;
+					status.code += ` })`;
+				}
 				if (lambda_arg_temps.size > 0) {
 					for (const tmp of lambda_arg_temps.values()) status.code += `; ${closure_dispose_arm(tmp)}`;
 					if (lambda_ret_tmp) status.code += `; ${lambda_ret_tmp}`;
@@ -41629,7 +41739,9 @@ 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 borrow_needs_dup = (rhs_is_borrow_reception || rhs_is_field_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();
@@ -41639,7 +41751,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) 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);
@@ -41856,6 +41969,22 @@ 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_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`);
@@ -45635,7 +45764,7 @@ function build_access_method(node, access_func, status) {
 		status.last_result_is_heap = false;
 		build_node(node.target, status);
 		ensure_newline(status);
-		frees_string_receiver = method_name === "string_to_string" && status.last_result_is_heap;
+		frees_string_receiver = status.last_result_is_heap;
 		status.last_result_is_heap = false;
 		emit_asm(status, `stp x0, x1, [sp, #-16]!\n`);
 	}
@@ -47257,7 +47386,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({
@@ -47265,7 +47395,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({
@@ -62443,7 +62573,9 @@ const STRING_OPTIONS = /* @__PURE__ */ new Map([
 	["p", "platform"],
 	["lib", "lib"],
 	["l", "lib"],
-	["audit-runtime", "audit_runtime"]
+	["audit-runtime", "audit_runtime"],
+	["jobs", "jobs"],
+	["j", "jobs"]
 ]);
 const BOOLEAN_OPTIONS = /* @__PURE__ */ new Map([
 	["watch", "watch"],
@@ -62553,8 +62685,9 @@ function print_help() {
 		"  --platform, -p <name>   Target platform: macos, ios, linux, android, windows, web",
 		"  --lib, -l <path>        Path to System library directory (containing package.jsonc)",
 		"  --audit                 Audit the generated program for memory issues",
-		"  --audit-runtime <path>  Path to audit_runtime.c, linked in when --audit is set",
-		"  --release, -r           Build with optimizations (clang -O2; asm passes on aarch64)",
+		"  --audit-runtime <path>  Path to audit_runtime.c (default: auto-discovered — walk-up or the CLI-bundled copy)",
+		"  --jobs, -j <n>          For `nomen test`: max test files run in parallel (default: CPU count)",
+		"  --release, -r           Build with optimizations (clang -O2; aarch64 asm cleanup passes)",
 		"  --fast-math             Allow FP reassociation (float loop reductions vectorize on aarch64)",
 		"  --check                 For `nomen format`: report files that would change",
 		"  -h, --help              Show this help"
@@ -62902,6 +63035,9 @@ function find_bundled(filename) {
 	const candidates = !cli_root.includes("node_modules") ? [path.join(repo_root, filename), path.join(cli_root, filename)] : [path.join(cli_root, filename), path.join(repo_root, filename)];
 	for (const c of candidates) if (fs.existsSync(c)) return path.resolve(c);
 }
+function find_bundled_audit_runtime() {
+	return find_bundled("src/audit_runtime.c") ?? find_bundled("audit_runtime.c");
+}
 /**
 * `nomen init <name>`: scaffold a new project under `./<name>` with a sensible
 * starting layout (package.jsonc, src/main.nm, a starter test, README and an
@@ -62980,6 +63116,7 @@ function outfile_for(input_path, is_test, out) {
 //#endregion
 //#region src/test.ts
 const RECORD_PREFIX = "\\nomen|";
+const execFile_async = promisify(execFile);
 /** Recursively collect `*.test.nm` files under `root`, skipping build output. */
 function collect_test_files(root) {
 	const out = [];
@@ -63063,11 +63200,19 @@ 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 += "	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) {
@@ -63086,6 +63231,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)) {
@@ -63104,6 +63250,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),
@@ -63118,18 +63268,25 @@ 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,
 * returning its parsed records and any crash info.
 */
-function run_test_file(entry_path, lib_path, arch, audit = false, audit_runtime, release = false, cwd) {
+async function run_test_file(entry_path, lib_path, arch, audit = false, audit_runtime, release = false, cwd) {
 	const start = performance.now();
 	const source_text = fs.readFileSync(entry_path, "utf8");
 	const harness = generate_harness(extract_test_functions(source_text), extract_bench_functions(source_text));
@@ -63139,8 +63296,9 @@ function run_test_file(entry_path, lib_path, arch, audit = false, audit_runtime,
 		tests: [],
 		fails: [],
 		benches: [],
-		other: [],
 		leaks: [],
+		leaking_tests: [],
+		other: [],
 		ms: 0
 	};
 	const resolved = path.resolve(entry_path);
@@ -63168,24 +63326,21 @@ function run_test_file(entry_path, lib_path, arch, audit = false, audit_runtime,
 	}
 	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));
-		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");
-		execFileSync("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, "audit_runtime.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);
@@ -63208,14 +63363,7 @@ function run_test_file(entry_path, lib_path, arch, audit = false, audit_runtime,
 	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",
-			stdio: [
-				"ignore",
-				"pipe",
-				"pipe"
-			]
-		});
+		await execFile_async("clang", link_args, { encoding: "utf8" });
 	} catch (err) {
 		const stderr = err.stderr ? err.stderr.toString() : err.message ?? "";
 		result.ok = false;
@@ -63227,17 +63375,12 @@ function run_test_file(entry_path, lib_path, arch, audit = false, audit_runtime,
 	let runStdout = "";
 	let crashed;
 	try {
-		runStdout = execFileSync(outfile, [], {
+		runStdout = (await execFile_async(outfile, [], {
 			encoding: "utf8",
-			stdio: [
-				"ignore",
-				"pipe",
-				"pipe"
-			],
 			timeout: 3e4,
 			maxBuffer: 16777216,
 			cwd: cwd ?? process.cwd()
-		});
+		})).stdout;
 	} catch (err) {
 		runStdout = err.stdout ? err.stdout.toString() : "";
 		if (err.signal === "SIGTERM") crashed = "test binary timed out after 30s";
@@ -63247,9 +63390,10 @@ function run_test_file(entry_path, lib_path, arch, audit = false, audit_runtime,
 	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;
@@ -63290,16 +63434,26 @@ 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 ---"));
 		for (const line of result.other) console.log(C.dim(`   ${line}`));
 	}
 }
+/** The default concurrency for `runTests` when no `jobs` is given. */
+function default_jobs() {
+	const n = typeof os.availableParallelism === "function" ? os.availableParallelism() : os.cpus().length;
+	return Math.max(1, n);
+}
 /**
 * Locate audit_runtime.c for an audited test build: an explicit path wins,
 * otherwise walk up from `dir` looking for a `src/audit_runtime.c` (the same
-* convention the run/build commands use).
+* convention the run/build commands use). When both miss, the caller falls
+* back to the CLI-bundled runtime (`find_bundled_audit_runtime`).
 */
 function find_audit_runtime(dir) {
 	let cur = dir;
@@ -63312,19 +63466,25 @@ function find_audit_runtime(dir) {
 	}
 }
 /** Discover, run, and report every `*.test.nm` under `root`. */
-function runTests(root, options = {}) {
+async function runTests(root, options = {}) {
 	const arch = options.arch ?? "aarch64";
 	const lib = resolve_lib_for(root);
 	const files = collect_test_files(root).filter((f) => !options.filter || options.filter.test(f));
 	console.log(`Found ${files.length} test file(s)\n`);
 	const startTime = performance.now();
 	const binary_cwd = path.resolve(root);
-	const results = [];
-	for (const file of files) {
-		const result = run_test_file(file, lib, arch, options.audit, options.audit_runtime, options.release, binary_cwd);
-		report_file(result);
-		results.push(result);
-	}
+	const jobs = Math.max(1, Math.min(options.jobs ?? default_jobs(), files.length));
+	const results = new Array(files.length);
+	let next = 0;
+	const worker = async () => {
+		for (;;) {
+			const i = next++;
+			if (i >= files.length) return;
+			results[i] = await run_test_file(files[i], lib, arch, options.audit, options.audit_runtime, options.release, binary_cwd);
+		}
+	};
+	await Promise.all(Array.from({ length: jobs }, worker));
+	for (const result of results) report_file(result);
 	const elapsed = performance.now() - startTime;
 	const totalFiles = results.length;
 	const totalFilesFailed = results.reduce((a, r) => a + (r.ok ? 0 : 1), 0);
@@ -63333,11 +63493,12 @@ 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;
@@ -63425,12 +63586,13 @@ try {
 	if (command === "test") {
 		const root = args.in ?? process.cwd();
 		const filter = args.filter ? new RegExp(args.filter) : void 0;
-		const ok = runTests(root, {
+		const ok = await runTests(root, {
 			arch: args.arch ?? "aarch64",
 			filter,
 			audit: args.audit,
 			audit_runtime: args.audit_runtime,
-			release: args.release
+			release: args.release,
+			jobs: args.jobs !== void 0 ? parseInt(args.jobs, 10) : void 0
 		});
 		process.exit(ok ? 0 : 1);
 	}
@@ -63541,6 +63703,7 @@ function resolve_audit_runtime(config, input_path) {
 		if (parent === dir) break;
 		dir = parent;
 	}
+	return find_bundled_audit_runtime();
 }
 function compile_audit_runtime(config, input_path, buildDir) {
 	const runtime_src = resolve_audit_runtime(config, input_path);
@@ -63617,7 +63780,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}`;