nomen-lang 0.6.7 → 0.6.9

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",
@@ -6811,6 +6812,27 @@ function find_enum(name, status) {
 }
 //#endregion
 //#region ../src/build_common/mono_name.ts
+/**
+* Whether `name` is a monomorphized owning-container struct whose
+* `<Mono>_copy` is safe to call from the owning-`Buffer.load_T`
+* specialization — `List_<T>` / `Buffer_<T>` (and their bare generics).
+* These own a heap slab their `#destroy` frees unconditionally, and `copy`
+* yields an independent slab, so a returned element's field must be
+* deep-copied or the caller's unconditional container-field teardown
+* double-frees the slot's slab.
+*
+* `Map`/`Set` are deliberately EXCLUDED from the automatic deep copy: their
+* monomorphized `copy` (which composes several `Buffer.copy` calls) is
+* verified standalone on both backends, but invoking it from the load
+* specialization corrupts the returned struct on aarch64 (a codegen
+* interaction still open — see FOLLOWUP.md). A `Map`/`Set` FIELD reached
+* through a container element's `load` therefore stays shallow (the
+* pre-existing bounded gap); an EXPLICIT `.copy()` on the owning struct or
+* the Map/Set itself works on both backends.
+*/
+function is_load_deep_copy_container(name) {
+	return name === "List" || name === "Buffer" || name.startsWith("List_") || name.startsWith("Buffer_");
+}
 function mono_type_name(type_or_name, type_args) {
 	const name = typeof type_or_name === "string" ? type_or_name : type_or_name.name;
 	const args = typeof type_or_name === "string" ? type_args : type_or_name.type_args;
@@ -7676,10 +7698,15 @@ function direct_string_fields(node) {
 * callee's own records are scope-local and die at return, so without the
 * transfer the stored copy leaks.
 *
-* Only DIRECT statements qualify: a store nested in a branch/loop may not
-* execute, and a record over the pre-call value would free it at the caller's
-* scope exit (possibly rodata — an invalid free). Memoized on the function
-* node; forwarding cycles are cut by a visited set (the cycle member's own
+* Only DIRECT statements qualify for the plain transfer: a store nested in a
+* branch/loop may not execute, and a record over the pre-call value would
+* free it at the caller's scope exit (possibly rodata — an invalid free).
+* Those CONDITIONAL stores are reported separately
+* (scan_ref_param_string_field_may_writes): the callee's function builder
+* emits an ENTRY DUP for each of them (`field = strdup(field)` at function
+* entry, recorded), which makes the field heap-owned on EVERY path and the
+* may-store record sound to transfer. Memoized on the function node;
+* forwarding cycles are cut by a visited set (the cycle member's own
 * contribution is skipped, bounded-leak).
 */
 function scan_ref_param_string_field_writes(func, structs) {
@@ -7687,6 +7714,51 @@ function scan_ref_param_string_field_writes(func, structs) {
 	if (stamp._ref_param_string_field_writes) return stamp._ref_param_string_field_writes;
 	const result = /* @__PURE__ */ new Map();
 	stamp._ref_param_string_field_writes = result;
+	const tracked = tracked_ref_params(func, structs);
+	if (tracked.size) scan_top_level(func.statements ?? [], tracked, structs, result);
+	return result;
+}
+/**
+* The CONDITIONAL (`may-executed`) ref-param field stores: direct stores
+* nested in if/else branches, switch cases, and loop bodies. Forwarded
+* calls from a nested position are deliberately EXCLUDED: a helper's store
+* builds with its own (fresh) record set, so it cannot reclaim the
+* displaced entry-dup — dup'ing for a forwarded store would trade the
+* old bounded leak for a new one. Those chains keep the documented
+* bounded-leak posture (the stored copy leaks, never an invalid free).
+* The function builder entry-dups these fields (see
+* ref_param_entry_dup_fields), making the may-store record transferable.
+*/
+function scan_ref_param_string_field_may_writes(func, structs) {
+	const stamp = func;
+	if (stamp._ref_param_string_field_may_writes) return stamp._ref_param_string_field_may_writes;
+	const result = /* @__PURE__ */ new Map();
+	stamp._ref_param_string_field_may_writes = result;
+	const tracked = tracked_ref_params(func, structs);
+	if (tracked.size) scan_nested(func.statements ?? [], tracked, result);
+	return result;
+}
+/**
+* The fields a function's builder must ENTRY DUP: the conditional
+* (may-executed) ref-param string-field stores that are NOT also
+* definitely-executed (a must-store already leaves the field heap-owned on
+* every path — dup'ing it too would just add a pointless strdup per call).
+* The dup runs at callee entry on both backends and records the field, so a
+* call site may transfer these as heap records soundly.
+*/
+function ref_param_entry_dup_fields(func, structs) {
+	const must = scan_ref_param_string_field_writes(func, structs);
+	const may = scan_ref_param_string_field_may_writes(func, structs);
+	const result = /* @__PURE__ */ new Map();
+	for (const [param, fields] of may) {
+		const dup = /* @__PURE__ */ new Set();
+		for (const field of fields) if (!must.get(param)?.has(field)) dup.add(field);
+		if (dup.size) result.set(param, dup);
+	}
+	return result;
+}
+/** The tracked ref params of `func`: name -> writable plain string fields. */
+function tracked_ref_params(func, structs) {
 	const tracked = /* @__PURE__ */ new Map();
 	for (const param of func.params ?? []) {
 		if (param.is_self_param) continue;
@@ -7695,8 +7767,7 @@ function scan_ref_param_string_field_writes(func, structs) {
 		const fields = ref_param_writable_fields(param.type.name, structs);
 		if (fields.size) tracked.set(param.name, fields);
 	}
-	if (tracked.size) scan_function(func, tracked, structs, result, /* @__PURE__ */ new Set());
-	return result;
+	return tracked;
 }
 /** The writable plain string fields of the value struct `type_name` resolves
 *  to, or the empty set (non-struct, class, or no string fields). */
@@ -7706,46 +7777,91 @@ function ref_param_writable_fields(type_name, structs) {
 	if (!struct) return /* @__PURE__ */ new Set();
 	return new Set(direct_string_fields(struct).map((f) => f.name));
 }
-function scan_function(func, tracked, structs, result, visiting) {
-	visiting.add(func);
-	for (const stmt of func.statements ?? []) {
+/**
+* The top-level (definitely-executed) walk: direct `param.field = …`
+* statements and top-level forwarded calls only — nothing nested.
+*/
+function scan_top_level(statements, tracked, structs, result) {
+	for (const stmt of statements) {
 		if (stmt.node_type === "assign") {
-			const lhs = stmt.left_value;
-			if (lhs?.node_type === "access") {
-				const access = lhs;
-				if (access.access.node_type === "access_field" && access.target.node_type === "value") {
-					const name = access.target.value ?? "";
-					const fields = tracked.get(name);
-					const field = access.access.name ?? "";
-					if (fields?.has(field)) {
-						if (!result.has(name)) result.set(name, /* @__PURE__ */ new Set());
-						result.get(name).add(field);
-					}
-				}
-			}
+			record_direct_store(stmt, tracked, result);
 			continue;
 		}
 		const call = ref_forward_call(stmt);
-		if (!call) continue;
-		const [callee, args] = call;
-		const non_self_params = (callee.params ?? []).filter((p) => !p.is_self_param);
-		for (let i = 0; i < args.length && i < non_self_params.length; i++) {
-			const arg = args[i];
-			if (arg?.node_type !== "value") continue;
-			const arg_name = arg.value ?? "";
-			const my_fields = tracked.get(arg_name);
-			if (!my_fields) continue;
-			const callee_param = non_self_params[i];
-			if (!(callee_param.is_ref || callee_param.type.is_ref)) continue;
-			if (visiting.has(callee)) continue;
-			const callee_writes = scan_ref_param_string_field_writes(callee, structs).get(callee_param.name);
-			if (!callee_writes?.size) continue;
-			if (!result.has(arg_name)) result.set(arg_name, /* @__PURE__ */ new Set());
-			const mine = result.get(arg_name);
-			for (const field of callee_writes) if (my_fields.has(field)) mine.add(field);
-		}
-	}
-	visiting.delete(func);
+		if (call) merge_forwarded(call, tracked, structs, result);
+	}
+}
+/**
+* The nested walk: direct stores at ANY depth below the top level are
+* may-stores. Forwarded calls are skipped everywhere (their contributions
+* would need cross-function displaced-value knowledge the callee's fresh
+* record set cannot carry — see the may-scan doc).
+*/
+function scan_nested(statements, tracked, result) {
+	for (const stmt of statements) {
+		if (stmt.node_type === "assign") {
+			record_direct_store(stmt, tracked, result);
+			continue;
+		}
+		for (const nested of nested_statement_lists(stmt)) scan_nested(nested, tracked, result);
+	}
+}
+/** Record a direct `param.<field> = …` store into `result`. */
+function record_direct_store(stmt, tracked, result) {
+	const lhs = stmt.left_value;
+	if (lhs?.node_type !== "access") return;
+	const access = lhs;
+	if (access.access.node_type !== "access_field" || access.target.node_type !== "value") return;
+	const name = access.target.value ?? "";
+	const fields = tracked.get(name);
+	const field = access.access.name ?? "";
+	if (!fields?.has(field)) return;
+	if (!result.has(name)) result.set(name, /* @__PURE__ */ new Set());
+	result.get(name).add(field);
+}
+/** Merge a forwarded call's callee stores for the forwarded param: the
+*  callee's MUST stores at a top-level position. */
+function merge_forwarded(call, tracked, structs, result) {
+	const [callee, args] = call;
+	const non_self_params = (callee.params ?? []).filter((p) => !p.is_self_param);
+	for (let i = 0; i < args.length && i < non_self_params.length; i++) {
+		const arg = args[i];
+		if (arg?.node_type !== "value") continue;
+		const arg_name = arg.value ?? "";
+		const my_fields = tracked.get(arg_name);
+		if (!my_fields) continue;
+		const callee_param = non_self_params[i];
+		if (!(callee_param.is_ref || callee_param.type.is_ref)) continue;
+		const source = scan_ref_param_string_field_writes(callee, structs).get(callee_param.name);
+		if (!source?.size) continue;
+		if (!result.has(arg_name)) result.set(arg_name, /* @__PURE__ */ new Set());
+		const mine = result.get(arg_name);
+		for (const field of source) if (my_fields.has(field)) mine.add(field);
+	}
+}
+/** The statement lists nested inside `stmt` (branch bodies, loop bodies) —
+*  the same walk scan_reassigned_vars uses. */
+function nested_statement_lists(stmt) {
+	const branch_of = (b) => b?.statements ?? [];
+	const lists = [];
+	if (stmt.node_type === "while" || stmt.node_type === "for") {
+		const nested = stmt.statements;
+		if (nested) lists.push(nested);
+		return lists;
+	}
+	if (stmt.node_type === "if") {
+		const n = stmt;
+		if (n.if_branch) lists.push(branch_of(n.if_branch));
+		if (n.else_branch) lists.push(branch_of(n.else_branch));
+		return lists;
+	}
+	if (stmt.node_type === "switch" || stmt.node_type === "match") {
+		const n = stmt;
+		for (const c of n.cases ?? []) if (c.branch) lists.push(branch_of(c.branch));
+		if (n.else_branch) lists.push(branch_of(n.else_branch));
+		return lists;
+	}
+	return lists;
 }
 /**
 * The forwarded-call shape of a top-level statement: a resolved free-function
@@ -7776,6 +7892,12 @@ function ref_forward_call(stmt) {
 * stores (scan_ref_param_string_field_writes) onto the caller's records for
 * the argument variable, making the caller's scope exit free them.
 *
+* The callee's CONDITIONAL stores transfer too
+* (ref_param_entry_dup_fields): the callee's builder entry-dups those
+* fields (`field = strdup(field)` at entry, recorded), so the field is
+* heap-owned on EVERY path out of the call — the not-taken path holds the
+* dup — and a caller-side record is sound.
+*
 * `arg_is_trackable_local` must report true only for variables whose storage
 * THIS function's scope exit owns — a plain local. A `ref` param of the
 * enclosing function forwards caller storage, so a record here would free the
@@ -7783,19 +7905,22 @@ function ref_forward_call(stmt) {
 */
 function transfer_ref_param_field_records(callee, args, status, arg_is_trackable_local) {
 	const writes = scan_ref_param_string_field_writes(callee, status.structs);
-	if (!writes.size) return;
+	const dups = ref_param_entry_dup_fields(callee, status.structs);
+	if (!writes.size && !dups.size) return;
 	const non_self_params = (callee.params ?? []).filter((p) => !p.is_self_param);
 	for (let i = 0; i < args.length && i < non_self_params.length; i++) {
 		const param = non_self_params[i];
 		if (!(param.is_ref || param.type.is_ref)) continue;
 		const fields = writes.get(param.name);
-		if (!fields?.size) continue;
+		const dup_fields = dups.get(param.name);
+		if (!fields?.size && !dup_fields?.size) continue;
 		const arg = args[i];
 		if (arg?.node_type !== "value") continue;
 		const name = arg.value;
 		if (!name || !arg_is_trackable_local(name)) continue;
 		if (!status.heap_string_fields) status.heap_string_fields = /* @__PURE__ */ new Set();
-		for (const field of fields) status.heap_string_fields.add(`${name}.${field}`);
+		for (const field of fields ?? []) status.heap_string_fields.add(`${name}.${field}`);
+		for (const field of dup_fields ?? []) status.heap_string_fields.add(`${name}.${field}`);
 	}
 }
 //#endregion
@@ -8288,7 +8413,7 @@ function is_container_borrow_accessor_name(name) {
 * site (see build_return_node), so it counts as owned for classification.
 */
 function is_call_site_borrow_accessor(fn_name) {
-	return fn_name === "at" || fn_name === "first";
+	return fn_name === "at" || fn_name === "first" || fn_name === "load";
 }
 /**
 * Whether `node` is a container/buffer borrow accessor CALL (an
@@ -15010,6 +15135,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);
@@ -17957,7 +18109,7 @@ function emit_load_deep_copy_fields$1(elem, status, sret, slot) {
 		const size = get_type_size(field.type, status);
 		if (!field.type.is_ref && !field.type.is_view && !field.type.is_array && !field.type.is_nullable && field.type.name !== "string") {
 			const field_struct = resolve_struct_type(field.type, status);
-			if (field_struct && !field_struct.is_class && field_struct.name.startsWith("List_") && struct_needs_destroy(field_struct, status) && field_struct.functions.find((f) => f.name === "copy")) {
+			if (field_struct && !field_struct.is_class && is_load_deep_copy_container(field_struct.name) && struct_needs_destroy(field_struct, status) && field_struct.functions.find((f) => f.name === "copy")) {
 				emit_asm(status, `add x8, ${sret}, #${offset}\n`);
 				emit_asm(status, `add x0, ${slot}, #${offset}\n`);
 				emit_asm(status, `bl ${field_struct.name}_copy\n`);
@@ -20611,6 +20763,7 @@ function build_function_node$1(node, status) {
 	} else status.nir_emit_ctx = void 0;
 	const old_raw_param_reloads = status.raw_param_reloads;
 	install_raw_reload_plan(status, raw_reload_plan_lines);
+	emit_ref_param_entry_dups$1(node, status);
 	try {
 		build_block_node$1(node, status);
 	} finally {
@@ -20756,6 +20909,49 @@ function build_function_node$1(node, status) {
 	status.return_buffer_stack_offset = void 0;
 	status.function_return_type = void 0;
 }
+/**
+* Entry-dup the ref-param string fields the body stores through
+* CONDITIONALLY (see ref_param_entry_dup_fields): load the field pair's
+* ptr half, strdup it, store the fresh pointer back — with the field
+* recorded in heap_string_fields — so the field is heap-owned on every
+* path out of the function and the call-site record transfer is sound.
+* Mirrors the C backend's emit_ref_param_entry_dups; the len half is
+* unchanged by a dup, so only the ptr half is rewritten. A nullable
+* string field guards the dup (strdup(NULL) traps; a null pair stores as
+* null and every reclaim path no-ops on free(NULL)).
+*/
+function emit_ref_param_entry_dups$1(node, status) {
+	const dups = ref_param_entry_dup_fields(node, status.structs);
+	if (!dups.size) return;
+	for (const param of node.params ?? []) {
+		if (param.is_self_param) continue;
+		if (!(param.is_ref || param.type.is_ref)) continue;
+		const fields = dups.get(param.name);
+		if (!fields?.size) continue;
+		const struct = status.structs.find((s) => s.name === param.type.name && !s.is_simple_type && !s.is_class);
+		for (const field of fields) {
+			const offset = get_field_offset(param.type.name, field, status);
+			const paramReg = status.function_param_regs?.get(param.name);
+			if (paramReg) emit_asm(status, `mov x0, ${paramReg}\n`);
+			else if (is_local_ref_var(param.name, status)) emit_deref_var_address(status, "x0", param.name);
+			else emit_var_address(status, "x0", param.name);
+			emit_asm(status, `str x0, [sp, #-16]!\n`);
+			emit_asm(status, `ldr x0, [x0, #${offset}]\n`);
+			const nullable = !!struct?.fields.find((f) => f.name === field)?.type.is_nullable;
+			let skip_label;
+			if (nullable) {
+				skip_label = `.Lentry_dup_${status.label_counter = (status.label_counter ?? 0) + 1}`;
+				emit_asm(status, `cbz x0, ${skip_label}\n`);
+			}
+			emit_strdup(status);
+			if (skip_label) emit_asm(status, `${skip_label}:\n`);
+			emit_asm(status, `ldr x1, [sp], #16\n`);
+			emit_asm(status, `str x0, [x1, #${offset}]\n`);
+			if (!status.heap_string_fields) status.heap_string_fields = /* @__PURE__ */ new Set();
+			status.heap_string_fields.add(`${param.name}.${field}`);
+		}
+	}
+}
 //#endregion
 //#region ../src/build_aarch64/build_struct_node.ts
 let field_strdup_guard_counter = 0;
@@ -23997,6 +24193,14 @@ function build_declaration_node$1(node, status, nir_init, nir_swap) {
 						if (element_size === 1) emit_asm(status, `strb w0, [x9, #${slot}]\n`);
 						else if (element_size === 4) emit_asm(status, `str w0, [x9, #${slot}]\n`);
 						else emit_asm(status, `str x0, [x9, #${slot}]\n`);
+					} else if (element_size > 8 && struct_element && !struct_element.is_class) {
+						emit_struct_address_param(value, status);
+						ensure_newline(status);
+						emit_asm(status, `ldr x9, [x29, #${offset}]\n`);
+						emit_asm(status, `mov x1, x0\n`);
+						emit_asm(status, `add x0, x9, #${slot}\n`);
+						emit_asm(status, `mov x2, #${element_size}\n`);
+						emit_asm(status, `bl _memcpy\n`);
 					} else {
 						emit_init_value$1(value, nir_array_element(nir_init, array_literal_node, i), status);
 						ensure_newline(status);
@@ -24036,6 +24240,14 @@ function build_declaration_node$1(node, status, nir_init, nir_swap) {
 						if (element_size === 1) emit_asm(status, `strb w0, [x9, #${slot}]\n`);
 						else if (element_size === 4) emit_asm(status, `str w0, [x9, #${slot}]\n`);
 						else emit_asm(status, `str x0, [x9, #${slot}]\n`);
+					} else if (element_size > 8 && struct_element && !struct_element.is_class) {
+						emit_struct_address_param(value, status);
+						ensure_newline(status);
+						emit_asm(status, `ldr x9, [${node.name}]\n`);
+						emit_asm(status, `mov x1, x0\n`);
+						emit_asm(status, `add x0, x9, #${slot}\n`);
+						emit_asm(status, `mov x2, #${element_size}\n`);
+						emit_asm(status, `bl _memcpy\n`);
 					} else {
 						emit_init_value$1(value, nir_array_element(nir_init, array_literal_node, i), status);
 						ensure_newline(status);
@@ -24142,6 +24354,13 @@ function build_declaration_node$1(node, status, nir_init, nir_swap) {
 								if (element_size === 1) emit_asm(status, `strb w0, [x29, #${slot_offset}]\n`);
 								else if (element_size === 4) emit_asm(status, `str w0, [x29, #${slot_offset}]\n`);
 								else emit_asm(status, `str x0, [x29, #${slot_offset}]\n`);
+							} else if (element_size > 8 && struct_element && !struct_element.is_class) {
+								emit_struct_address_param(value, status);
+								ensure_newline(status);
+								emit_asm(status, `mov x1, x0\n`);
+								emit_asm(status, `add x0, x29, #${slot_offset}\n`);
+								emit_asm(status, `mov x2, #${element_size}\n`);
+								emit_asm(status, `bl _memcpy\n`);
 							} else {
 								emit_init_value$1(value, nir_array_element(nir_init, array_values, i), status);
 								ensure_newline(status);
@@ -24167,6 +24386,13 @@ function build_declaration_node$1(node, status, nir_init, nir_swap) {
 								if (element_size === 1) emit_asm(status, `strb w0, [${node.name} + ${i * element_size}]\n`);
 								else if (element_size === 4) emit_asm(status, `str w0, [${node.name} + ${i * element_size}]\n`);
 								else emit_asm(status, `str x0, [${node.name} + ${i * element_size}]\n`);
+							} else if (element_size > 8 && struct_element && !struct_element.is_class) {
+								emit_struct_address_param(value, status);
+								ensure_newline(status);
+								emit_asm(status, `mov x1, x0\n`);
+								emit_global_slot_addr(status, node.name, i * element_size);
+								emit_asm(status, `mov x2, #${element_size}\n`);
+								emit_asm(status, `bl _memcpy\n`);
 							} else {
 								emit_init_value$1(value, nir_array_element(nir_init, array_values, i), status);
 								ensure_newline(status);
@@ -33342,7 +33568,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);
@@ -34953,6 +35180,7 @@ function build_if_else_node(node, status, nir) {
 	status.code += `) {\n`;
 	let then_fields;
 	if (node.if_branch) {
+		status.heap_string_fields = new Set(pre_heap_string_fields ?? []);
 		build_block_with_cursor(node.if_branch, nir?.then_branch, status);
 		build_auto_free(status);
 	}
@@ -34961,7 +35189,7 @@ function build_if_else_node(node, status, nir) {
 	if (node.else_branch) {
 		status.scoped_declarations = enter_c_scope(status);
 		status.deferred_frees = [];
-		status.heap_string_fields = pre_heap_string_fields;
+		status.heap_string_fields = new Set(pre_heap_string_fields ?? []);
 		status.code += `} else {\n`;
 		build_block_with_cursor(node.else_branch, nir?.else_branch, status);
 		build_auto_free(status);
@@ -35395,7 +35623,7 @@ function build_switch_node(node, status, nir) {
 	for (let i = 0; i < node.cases.length; i++) {
 		const c = node.cases[i];
 		status.scoped_declarations = enter_c_scope(status);
-		status.heap_string_fields = pre_heap_string_fields;
+		status.heap_string_fields = new Set(pre_heap_string_fields ?? []);
 		const saved_code = begin_code_scratch(status);
 		build_node$1(c.condition, status);
 		let cond_code = end_code_scratch(status, saved_code);
@@ -35441,7 +35669,7 @@ function build_switch_node(node, status, nir) {
 	if (node.else_branch) {
 		status.code += "} else ";
 		status.scoped_declarations = enter_c_scope(status);
-		status.heap_string_fields = pre_heap_string_fields;
+		status.heap_string_fields = new Set(pre_heap_string_fields ?? []);
 		status.code += `{\n`;
 		build_block_with_cursor(node.else_branch, nir?.otherwise ?? void 0, status);
 		build_auto_free(status);
@@ -35864,11 +36092,13 @@ function emit_transfer_owning_fields(elem, src, status, prefix = "") {
 /**
 * Emit the deep-copy half of owning load_T: for each field whose type has a
 * monomorphized `copy` helper that yields an independent value (a `List<T>`
-* field — `<List_T>_copy` deep-copies slots per the owning store contract —
-* or an enum-with-data field whose string payloads `<E>_copy` duplicates),
-* overwrite the shallow-copied bytes with an owned copy. Fields without a
-* copyable shape (nested owning user structs, class fields) stay shallow —
-* recorded in FOLLOWUP.md ("remaining shallow container-field shapes").
+* /`Buffer<T>`/`Map`/`Set` field — `<Mono>_copy` deep-copies the slots or
+* member buffers — or an enum-with-data field whose string payloads
+* `<E>_copy` duplicates), overwrite the shallow-copied bytes with an owned
+* copy. A struct local's CONTAINER fields are reclaimed unconditionally at
+* scope exit, so a shallow return would double-free the slot's slab. Fields
+* without a copyable shape (class fields, nested owning user structs without
+* a synthesized copy) stay shallow — recorded in FOLLOWUP.md.
 */
 function emit_load_deep_copy_fields(elem, dst, status) {
 	for (const field of elem.fields) {
@@ -35876,7 +36106,7 @@ function emit_load_deep_copy_fields(elem, dst, status) {
 		if (field.type.is_nullable) continue;
 		if (field.type.name === "string") continue;
 		const field_struct = resolve_struct_type(field.type, status);
-		if (field_struct && !field_struct.is_class && field_struct.name.startsWith("List_") && struct_needs_destroy(field_struct, status) && field_struct.functions.find((f) => f.name === "copy")) {
+		if (field_struct && !field_struct.is_class && is_load_deep_copy_container(field_struct.name) && struct_needs_destroy(field_struct, status) && field_struct.functions.find((f) => f.name === "copy")) {
 			status.code += `${dst}.${field.name} = ${field_struct.name}_copy(&${dst}.${field.name});\n`;
 			continue;
 		}
@@ -37470,6 +37700,7 @@ function build_function_node(node, status) {
 		stmts: nir.body,
 		ast: node.statements
 	} : void 0;
+	emit_ref_param_entry_dups(node, status);
 	build_block_node(node, status, false);
 	status.nir_emit_ctx = old_nir_ctx;
 	status.function_ref_params = old_ref_params;
@@ -37515,6 +37746,37 @@ function build_function_node(node, status) {
 	status.stack_array_lengths = old_stack_array_lengths;
 	status.moved = old_moved;
 }
+/**
+* Emit the entry-dup for every `ref` value-struct param string field the
+* body stores through CONDITIONALLY (see ref_param_entry_dup_fields):
+* `{ field = nomen_str_dup(field) }` at function entry, recorded in
+* heap_string_fields, so the field is heap-owned on every path out of the
+* function and the call-site record transfer is sound. Nullable string
+* fields guard the dup (a null pair stores as null — free(NULL) is a
+* no-op on every reclaim path).
+*/
+function emit_ref_param_entry_dups(node, status) {
+	const dups = ref_param_entry_dup_fields(node, status.structs);
+	if (!dups.size) return;
+	for (const param of node.params ?? []) {
+		if (param.is_self_param) continue;
+		if (!(param.is_ref || param.type.is_ref)) continue;
+		const fields = dups.get(param.name);
+		if (!fields?.size) continue;
+		const struct = status.structs.find((s) => s.name === param.type.name && !s.is_simple_type && !s.is_class);
+		const base = c_function_name(param.name);
+		for (const field of fields) {
+			const nullable = !!struct?.fields.find((f) => f.name === field)?.type.is_nullable;
+			if (nullable) status.code += `if (${base}->${field}.ptr) {\n`;
+			const temp = `_dup_t_${status.label_counter = (status.label_counter ?? 0) + 1}`;
+			status.code += `nomen_string ${temp} = nomen_str_dup(${base}->${field});\n`;
+			status.code += `${base}->${field} = ${temp};\n`;
+			if (nullable) status.code += `}\n`;
+			if (!status.heap_string_fields) status.heap_string_fields = /* @__PURE__ */ new Set();
+			status.heap_string_fields.add(`${param.name}.${field}`);
+		}
+	}
+}
 function emit_nested_declarations(node, status) {
 	const block = node;
 	for (let child of block.statements) switch (child.node_type) {
@@ -37805,6 +38067,17 @@ function build_function_call_node(node, status) {
 	status.code += `${func_name}(${is_closure_callee ? "NULL" : ""}`;
 	if (is_closure_callee && node.params.length > 0) status.code += ", ";
 	const variadic_idx = node.variadic_param_name ? node.params.findIndex((p) => p.node_type === "array") : -1;
+	if (!node.variadic_param_name) {
+		const resolved = node.resolved_function ?? (is_struct ? status.structs.find((s) => s.name === node.name)?.functions.find((f) => f.name === "#init") : void 0);
+		const variadic_param = resolved?.params?.find((p) => p.is_variadic);
+		if (resolved && variadic_param) {
+			if (node.params.length === 1 && node.params[0].node_type === "array") node.variadic_param_name = variadic_param.name;
+			else if (node.params.length === 0 && resolved.params.filter((p) => !p.is_self_param && !p.is_variadic).length === 0) {
+				const elem_c = c_type(variadic_param.type.name);
+				status.code += `0, (${elem_c}[]){ }`;
+			}
+		}
+	}
 	for (let i = 0; i < node.params.length; i++) {
 		if (i > 0) status.code += ", ";
 		if (i === variadic_idx && node.params[i].node_type === "array") {
@@ -38773,10 +39046,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));
@@ -38861,6 +39155,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}`;
@@ -41412,7 +41711,11 @@ function build_assignment_node(node, status, nir_rhs, nir_swap) {
 				if (name === "self" && status.current_struct) target_type = new Type(status.current_struct.name);
 				else if (status.variable_types?.has(name)) target_type = status.variable_types.get(name);
 			}
-			const field_type = access.access.type;
+			let field_type = access.access.type;
+			if (!field_type?.name && target_type?.name) {
+				const tf = status.structs.find((s) => s.name === target_type.name)?.fields.find((f) => f.name === field_name);
+				if (tf) field_type = tf.type;
+			}
 			const field_is_struct = is_struct_type$2(field_type, status);
 			if (access.target.node_type === "value") {
 				const name = access.target.value;
@@ -45387,7 +45690,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`);
 	}
@@ -56114,6 +56417,14 @@ function check_function_call(node, status, func, target_type, self_value, self_p
 	}
 	node.type = func.return_type;
 	node.is_static = func.is_static;
+	if (target_type?.type_args?.length && node.type?.type_args?.length) {
+		const owner = func.scope;
+		if (owner && owner.node_type === "struct" && owner.is_generic && owner.type_params.length === target_type.type_args.length) {
+			const rebind = /* @__PURE__ */ new Map();
+			owner.type_params.forEach((tp, i) => rebind.set(tp, target_type.type_args[i].name));
+			node.type = substitute_type(node.type, rebind);
+		}
+	}
 	if (node.type?.type_args?.length) instantiate_generic_type(node.type, status);
 	if (node.type && node.type.name && self_value && is_class_type$1(node.type.name, status) && receiver_is_const(target_type, self_value, status)) {
 		node.type = clone_type$2(node.type);
@@ -56297,7 +56608,10 @@ function check_function_call(node, status, func, target_type, self_value, self_p
 			else {
 				const stamped = String(func_param.type.length.value);
 				const incoming = String(param_type.length.value);
-				if (stamped !== incoming) add_error(status, `Call passes ${incoming} elements to array parameter '${func_param.name}' whose compile-time length is ${stamped} — the raw array ABI carries no runtime length, so one parameter serves one compile-time length; use Array<${func_param.type.name}> for varying lengths`, param.start);
+				if (stamped !== incoming) {
+					if (is_heap_array_type(func_param.type)) func_param.type.length = void 0;
+					else add_error(status, `Call passes ${incoming} elements to array parameter '${func_param.name}' whose compile-time length is ${stamped} — the raw array ABI carries no runtime length, so one parameter serves one compile-time length; use Array<${func_param.type.name}> for varying lengths`, param.start);
+				}
 			}
 		}
 		let arg_value;
@@ -56528,6 +56842,13 @@ function check_function_call(node, status, func, target_type, self_value, self_p
 			if (typeof size_val === "number" && size_val > 0) record_buffer_cap(self_path, size_val, status);
 		}
 	}
+	if (self_path && self_path !== "?" && is_bufferish && func.name === "copy") {
+		const source_cap = lookup_buffer_cap(self_path, status);
+		if (source_cap !== void 0) {
+			const lhs_name = find_lhs_var_name(status);
+			if (lhs_name) record_buffer_cap(lhs_name, source_cap, status);
+		}
+	}
 	if (func.return_constraint) {
 		const param_to_arg = /* @__PURE__ */ new Map();
 		if (self_path && self_path !== "?") param_to_arg.set("self", path_to_node(self_path));
@@ -60581,6 +60902,68 @@ function parse_case_branch(status) {
 	return null;
 }
 //#endregion
+//#region ../src/parse/utils/parse_embed_file.ts
+/**
+* `#embed_file("relative/path")` — a compile-time string literal whose value
+* is the contents of the file at parse time. The path resolves against the
+* package root (the directory containing package.jsonc, found by climbing
+* from the entry file), falling back to the entry file's folder; with no
+* known base it resolves against the process CWD.
+*
+* The parsed form is a plain string-literal ValueNode: escapes are encoded
+* with the source-level escape set (`\\`, `\"`, `\n`, `\r`, `\t`, and
+* three-digit octal for other control bytes — self-terminating, matching the
+* escape scanner), so every downstream consumer (length counting, C/asm
+* emission) treats it exactly like a hand-written literal.
+*/
+function parse_embed_file(status) {
+	const start = get_index(status);
+	consume(status);
+	const name = consume(status);
+	if (name !== "embed_file") {
+		add_error(status, `Unknown compiler directive '#${name}' — did you mean '#embed_file'?`, start);
+		return new ValueNode(start, "\"\"");
+	}
+	if (!expect("(", status)) return new ValueNode(start, "\"\"");
+	const path_token = status.tokens[status.i];
+	if (!path_token || !path_token.value.startsWith("\"")) {
+		add_error(status, "Expected a string literal path in #embed_file", start);
+		return new ValueNode(start, "\"\"");
+	}
+	status.i += 1;
+	const rel_path = path_token.value.slice(1, -1);
+	if (!expect(")", status)) return new ValueNode(start, "\"\"");
+	if (!rel_path) {
+		add_error(status, "#embed_file path is empty", start);
+		return new ValueNode(start, "\"\"");
+	}
+	const base = status.embed_root ?? process.cwd();
+	const full = path.isAbsolute(rel_path) ? rel_path : path.join(base, rel_path);
+	let content;
+	try {
+		content = fs.readFileSync(full, "utf8");
+	} catch {
+		add_error(status, `#embed_file could not read '${rel_path}' (resolved '${full}')`, start);
+		return new ValueNode(start, "\"\"");
+	}
+	return new ValueNode(start, `"${escape_embedded(content)}"`);
+}
+/** Encode file contents as a source-level string literal body. */
+function escape_embedded(content) {
+	let out = "";
+	for (const ch of content) {
+		const code = ch.charCodeAt(0);
+		if (ch === "\\") out += "\\\\";
+		else if (ch === "\"") out += "\\\"";
+		else if (ch === "\n") out += "\\n";
+		else if (ch === "\r") out += "\\r";
+		else if (ch === "	") out += "\\t";
+		else if (code < 32 || code === 127) out += `\\${code.toString(8).padStart(3, "0")}`;
+		else out += ch;
+	}
+	return out;
+}
+//#endregion
 //#region ../src/parse/parse_expression.ts
 function restructure_op(start, current_op, current_prec, current_node, expression) {
 	if (current_prec <= operator_precedence(expression.op)) {
@@ -60720,6 +61103,7 @@ function parse_primary(status, value) {
 			expect(")", status);
 			return node;
 		}
+		case "#": return parse_embed_file(status);
 		case "if": return parse_if_else(status);
 		case "match": return parse_match(status);
 		case "switch": return parse_switch(status);
@@ -61862,7 +62246,8 @@ function parse(source, library, file_path, options) {
 		qualified_paths: [],
 		library,
 		errors: [],
-		allow_user_raw: options?.allow_user_raw
+		allow_user_raw: options?.allow_user_raw,
+		embed_root: embed_root_for(file_path)
 	};
 	if (library) status.unsafe_boundary = user_source_length;
 	parse_statement(status);
@@ -61939,6 +62324,23 @@ function mark_library_nodes(root, boundary) {
 	walk(root);
 }
 /**
+* The base directory for `#embed_file` paths: the package root (the nearest
+* enclosing directory with a package.jsonc), falling back to the entry
+* file's folder. No file path — undefined, so `#embed_file` resolves
+* against the process CWD.
+*/
+function embed_root_for(file_path) {
+	if (!file_path) return void 0;
+	let dir = path.dirname(path.resolve(file_path));
+	for (let i = 0; i < 32; i++) {
+		if (fs.existsSync(path.join(dir, "package.jsonc"))) return dir;
+		const parent = path.dirname(dir);
+		if (parent === dir) break;
+		dir = parent;
+	}
+	return path.dirname(path.resolve(file_path));
+}
+/**
 * Append the library source that `source` needs, exactly as `parse` does.
 * Exported so tooling (e.g. the editor extension) can reproduce the combined
 * source that node offsets refer to.
@@ -62096,7 +62498,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"],
@@ -62192,7 +62596,7 @@ function print_help() {
 		"  nomen check --in [file/folder]    Parse and check only",
 		"  nomen format [--in folder]        Reformat every .nm file",
 		"  nomen docs [--in file]            Generate markdown documentation",
-		"  nomen test [--in folder]          Discover and run *.test.nm files",
+		"  nomen test [--in folder]          Discover and run *.test.nm files (binary CWD = --in folder)",
 		"  nomen init <name>                 Scaffold a new project in ./<name>",
 		"  nomen lib-path                    Print the bundled System library path",
 		"",
@@ -62206,8 +62610,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"
@@ -62555,6 +62960,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
@@ -62633,6 +63041,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 = [];
@@ -62782,7 +63191,7 @@ function extract_leaks(stdout) {
 * 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) {
+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));
@@ -62809,7 +63218,8 @@ function run_test_file(entry_path, lib_path, arch, audit = false, audit_runtime)
 	}
 	const buildResult = build(parsed.root, {
 		arch,
-		audit
+		audit,
+		optimize: release
 	});
 	if (buildResult.errors && buildResult.errors.length) {
 		result.ok = false;
@@ -62822,7 +63232,7 @@ function run_test_file(entry_path, lib_path, arch, audit = false, audit_runtime)
 	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));
+		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";
@@ -62831,7 +63241,7 @@ function run_test_file(entry_path, lib_path, arch, audit = false, audit_runtime)
 			return result;
 		}
 		audit_obj = path.join(buildDir, "audit_runtime.o");
-		execFileSync("clang", [
+		await execFile_async("clang", [
 			"-c",
 			runtime_src,
 			"-o",
@@ -62844,22 +63254,23 @@ function run_test_file(entry_path, lib_path, arch, audit = false, audit_runtime)
 	const outfile = path.join(buildDir, path.basename(entry_path, ".nm"));
 	fs.writeFileSync(path.join(buildDir, "main.h"), buildResult.headers ?? "");
 	fs.writeFileSync(codefile, buildResult.code);
+	let companionfile;
+	if (buildResult.companion) {
+		const comp_ext = platform === "macos" || platform === "ios" ? ".m" : ".c";
+		companionfile = path.join(buildDir, path.basename(entry_path, ".nm") + "_companion" + comp_ext);
+		fs.writeFileSync(companionfile, buildResult.companion);
+	}
 	const link_args = [
 		"-o",
 		outfile,
 		codefile
 	];
+	if (companionfile) link_args.push(companionfile);
+	if (release) link_args.unshift("-O2");
 	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;
@@ -62871,16 +63282,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
-		});
+			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";
@@ -62939,10 +63346,16 @@ function report_file(result) {
 		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;
@@ -62955,18 +63368,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 results = [];
-	for (const file of files) {
-		const result = run_test_file(file, lib, arch, options.audit, options.audit_runtime);
-		report_file(result);
-		results.push(result);
-	}
+	const binary_cwd = path.resolve(root);
+	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);
@@ -63067,11 +63487,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
+			audit_runtime: args.audit_runtime,
+			release: args.release,
+			jobs: args.jobs !== void 0 ? parseInt(args.jobs, 10) : void 0
 		});
 		process.exit(ok ? 0 : 1);
 	}
@@ -63182,6 +63604,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);