nomen-lang 0.0.13 → 0.0.15

package/dist/index.mjs

@@ -2,8 +2,12 @@
 import { execFileSync, execSync } from "node:child_process";
 import fs from "node:fs";
 import path from "node:path";
-import chokidar from "chokidar";
 import { fileURLToPath } from "node:url";
+//#region node_modules/chokidar/index.mjs
+var chokidar_default = { watch() {
+	throw new Error("chokidar stub: watch mode unavailable");
+} };
+//#endregion
 //#region ../src/nodes/BaseNode.ts
 /**
 * The base node type which all nodes extend
@@ -480,30 +484,6 @@ function resolve_mono_type(type, table) {
 	return resolved;
 }
 //#endregion
-//#region ../src/built_in_types.ts
-const built_in_types = [
-	"bool",
-	"int",
-	"uint",
-	"int8",
-	"uint8",
-	"int16",
-	"uint16",
-	"int32",
-	"uint32",
-	"int64",
-	"uint64",
-	"float",
-	"ufloat",
-	"float32",
-	"ufloat32",
-	"float64",
-	"ufloat64",
-	"char",
-	"string",
-	"func"
-];
-//#endregion
 //#region ../src/nodes/BranchNode.ts
 /**
 * A branch such as the result of an IfElseNode, or the arm of a SwitchNode
@@ -639,6 +619,30 @@ var FunctionNode = class extends BaseNode {
 	}
 };
 //#endregion
+//#region ../src/built_in_types.ts
+const built_in_types = [
+	"bool",
+	"int",
+	"uint",
+	"int8",
+	"uint8",
+	"int16",
+	"uint16",
+	"int32",
+	"uint32",
+	"int64",
+	"uint64",
+	"float",
+	"ufloat",
+	"float32",
+	"ufloat32",
+	"float64",
+	"ufloat64",
+	"char",
+	"string",
+	"func"
+];
+//#endregion
 //#region ../src/nodes/DeclarationNode.ts
 var DeclarationNode = class extends BaseNode {
 	visibility;
@@ -736,6 +740,82 @@ var StructNode = class extends BaseNode {
 	}
 };
 //#endregion
+//#region ../src/build_common/scan_self_string_writes.ts
+/**
+* The plain (owned, non-ref, non-array) `string` fields of a VALUE struct that
+* a method may overwrite through `self` — direct `self.<field> = ...` writes
+* plus writes made by same-struct methods the method calls on `self`
+* (transitively). Nested function/struct declarations inside the body are
+* boundaries and are not descended into (they are separate functions).
+*/
+function scan_self_string_field_writes(struct, method) {
+	const string_fields = new Set(struct.fields.filter((f) => f.type.name === "string" && !f.type.is_ref && !f.type.is_array).map((f) => f.name));
+	const written = /* @__PURE__ */ new Set();
+	if (!string_fields.size) return written;
+	const visited = /* @__PURE__ */ new Set();
+	const scan_method = (func) => {
+		if (visited.has(func.name)) return;
+		visited.add(func.name);
+		walk$2(func.statements ?? [], (n) => {
+			if (n.node_type === "assign") {
+				const lhs = n.left_value;
+				if (lhs?.node_type !== "access") return;
+				const access = lhs;
+				if (access.access.node_type !== "access_field") return;
+				const target = access.target;
+				const field = access.access.name ?? "";
+				if (target?.node_type === "value" && target.value === "self") {
+					if (string_fields.has(field)) written.add(field);
+				}
+			} else if (n.node_type === "access") {
+				const access = n;
+				if (access.access.node_type !== "access_func") return;
+				const target = access.target;
+				if (target?.node_type === "value" && target.value === "self") {
+					const callee = struct.functions.find((f) => f.name === access.access.name);
+					if (callee) scan_method(callee);
+				}
+			}
+		});
+	};
+	scan_method(method);
+	return written;
+}
+/**
+* Drop a receiver's heap_string_fields records for the fields a value-struct
+* method may have overwritten through `self`. The method's writes go through
+* to the caller's storage, and the method cannot know whether the displaced
+* values were heap-owned — that knowledge lives in the CALLER's records. A
+* surviving record could free a non-heap value at scope exit (invalid free),
+* so the records are dropped WITHOUT emitting frees. Conservative: a heap
+* value the method displaced or wrote leaks instead of being freed — never a
+* double-free.
+*/
+function drop_self_written_string_field_records(status, receiver_name, fields) {
+	if (!status.heap_string_fields?.size || !fields.size) return;
+	for (const field of fields) status.heap_string_fields.delete(`${receiver_name}.${field}`);
+}
+/** Visit every AST node reachable from `value` — through arrays AND
+*  single-node properties (an `if` node's branch blocks are node objects, not
+*  statement arrays) — skipping `parent`/`scope` back-references and NOT
+*  descending INTO nested `func`/`struct`/`trait` declarations (a nested
+*  function's body is a separate function, not part of this one's writes). */
+function walk$2(value, cb) {
+	if (!value || typeof value !== "object") return;
+	if (Array.isArray(value)) {
+		for (const item of value) walk$2(item, cb);
+		return;
+	}
+	const n = value;
+	const is_boundary = n.node_type === "func" || n.node_type === "struct" || n.node_type === "trait";
+	if (typeof n.node_type === "string") cb(n);
+	if (is_boundary) return;
+	for (const key of Object.keys(value)) {
+		if (key === "parent" || key === "scope" || key === "node_type") continue;
+		walk$2(value[key], cb);
+	}
+}
+//#endregion
 //#region ../src/check/utils/function_overload.ts
 function find_function_by_params(functions, name, arg_types) {
 	const candidates = functions.filter((f) => f.name === name);
@@ -1368,6 +1448,50 @@ 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/scan_moved_param_consumed.ts
+/**
+* Whether a `mov` class parameter's ownership escapes the function body —
+* i.e. it is passed (as an argument or receiver) into some call/constructor
+* whose result may outlive the function (stored into a returned
+* container/struct), or it is a bare value used as an argument. In those cases
+* the callee must NOT destroy it at exit (it would double-free / leave a
+* dangling pointer in the escaping value). A bare reference that is only read
+* (e.g. field access `x.value` or interpolation) does NOT consume it.
+*
+* Shared by the C backend's function epilogue and the aarch64 function /
+* method mov-param reclaims so both agree on when a mov'd param is reclaimed.
+*/
+function moved_param_is_consumed(root, name) {
+	let consumed = false;
+	const refs_name = (n) => !!n && n.node_type === "value" && n.value === name;
+	const walk = (n) => {
+		if (!n || typeof n !== "object" || consumed) return;
+		const node = n;
+		if (node.node_type === "func_call") {
+			for (const p of node.params ?? []) if (refs_name(p)) consumed = true;
+		}
+		if (node.node_type === "access") {
+			const access = node.access;
+			if (access?.node_type === "access_func" && refs_name(node.target)) consumed = true;
+			for (const p of access?.params ?? []) if (refs_name(p)) consumed = true;
+		}
+		if (node.node_type === "array") {
+			for (const v of node.values ?? []) if (refs_name(v)) consumed = true;
+		}
+		if (node.node_type === "return" && refs_name(node.value)) consumed = true;
+		if (node.node_type === "assign" && refs_name(node.right_value)) consumed = true;
+		if (node.node_type === "declare" && refs_name(node.value)) consumed = true;
+		for (const key of Object.keys(node)) {
+			if (key === "node_type") continue;
+			const v = node[key];
+			if (Array.isArray(v)) for (const item of v) walk(item);
+			else if (v && typeof v === "object") walk(v);
+		}
+	};
+	for (const stmt of root.statements ?? []) walk(stmt);
+	return consumed;
+}
+//#endregion
 //#region ../src/build_aarch64/utils/aarch64_size.ts
 function aarch64_size(type) {
 	switch (type) {
@@ -1684,8 +1808,10 @@ function emit_var_address(status, reg, name) {
 		if (offset !== void 0) status.code += `str ${alloc_reg}, [x29, #${offset}]\n`;
 	}
 	const offset = status.stack_offsets?.get(name);
-	if (offset !== void 0) status.code += `add ${reg}, x29, #${offset}\n`;
-	else {
+	if (offset !== void 0) {
+		if (status.function_struct_param_slots?.has(name)) status.code += `ldr ${reg}, [x29, #${offset}]\n`;
+		else status.code += `add ${reg}, x29, #${offset}\n`;
+	} else {
 		const param_reg = status.function_param_regs?.get(name);
 		if (param_reg) status.code += `mov ${reg}, ${param_reg}\n`;
 		else status.code += `adr ${reg}, ${name}\n`;
@@ -1752,6 +1878,78 @@ function emit_var_store(status, reg, name, size) {
 }
 //#endregion
 //#region ../src/build_aarch64/utils/auto_destroy.ts
+/**
+* Whether a declaration's initializer is a non-`mov` FIELD ACCESS — a shallow
+* struct borrow (`diff.changes`, the checker-hoisted `_param_N` temp for a
+* struct call arg). The struct bytes are copied but any embedded buffer data
+* belongs to the owner, so the declaration must NOT be destroyed at scope
+* exit / return (mirrors the C backend's is_destructured_field_access).
+*/
+function is_field_struct_borrow(decl) {
+	if (!decl.value || typeof decl.value !== "object") return false;
+	const value = decl.value;
+	return value.node_type === "access" && value.access.node_type === "access_field" && !value.is_moved;
+}
+/**
+* Record that a VALUE-struct local's `string` field now holds a heap-owned
+* value ("var.field"). See BuildStatus.heap_string_fields.
+*/
+function record_heap_string_field(status, var_name, field) {
+	if (!status.heap_string_fields) status.heap_string_fields = /* @__PURE__ */ new Set();
+	status.heap_string_fields.add(`${var_name}.${field}`);
+}
+/**
+* Drop a local's heap-string-field records — used when the struct's bytes
+* (and thus its string pointers) transfer to the caller, e.g. `return u`.
+*/
+function clear_heap_string_fields(status, var_name) {
+	if (!status.heap_string_fields) return;
+	const prefix = `${var_name}.`;
+	for (const key of Array.from(status.heap_string_fields)) if (key.startsWith(prefix)) status.heap_string_fields.delete(key);
+}
+/**
+* Free every heap-owned string field recorded for `decl_name` (a VALUE-struct
+* local) and drop the records. Class locals are never recorded — their string
+* fields are unconditionally heap and freed by the destroy path. Called from
+* emit_destroy_for_decl and directly from cleanup loops that skip moved
+* declarations before reaching it.
+*/
+function release_heap_string_fields(status, decl_name, decl_type_name) {
+	if (!status.heap_string_fields?.size) return;
+	const prefix = `${decl_name}.`;
+	const fields = Array.from(status.heap_string_fields).filter((k) => k.startsWith(prefix)).map((k) => k.slice(prefix.length));
+	if (!fields.length) return;
+	for (const field of fields) {
+		const offset = get_field_offset(decl_type_name, field, status);
+		emit_var_address(status, "x0", decl_name);
+		status.code += `ldr x0, [x0, #${offset}]\n`;
+		emit_free(status);
+		status.heap_string_fields.delete(`${decl_name}.${field}`);
+	}
+}
+/**
+* Swap in a fresh scoped_declarations frame for a nested scope (if/while/
+* for/switch/match body), pushing the enclosing array onto
+* outer_scope_declarations so return-path cleanup can still reach it.
+* Pair with exit_scope_frame.
+*/
+function enter_scope_frame(status) {
+	const old = status.scoped_declarations ?? [];
+	if (!status.outer_scope_declarations) status.outer_scope_declarations = [];
+	status.outer_scope_declarations.push(old);
+	status.scoped_declarations = [];
+	return old;
+}
+/** Restore the enclosing scoped_declarations frame (enter_scope_frame's pair). */
+function exit_scope_frame(status, old) {
+	status.outer_scope_declarations?.pop();
+	status.scoped_declarations = old;
+}
+/** Every declaration frame a `return` must clean: enclosing scopes first,
+*  the current (innermost) frame last — matching fall-through cleanup order. */
+function all_scope_frames(status) {
+	return [...status.outer_scope_declarations ?? [], status.scoped_declarations ?? []];
+}
 function mark_heap_string(status, name) {
 	if (!status.heap_strings) status.heap_strings = /* @__PURE__ */ new Set();
 	status.heap_strings.add(name);
@@ -1898,7 +2096,7 @@ function emit_field_destroys_from_slot(status, struct_type, base_offset) {
 			const field_size = get_type_size(field.type, status);
 			emit_nested_field_destroys_from_slot(status, field_struct, base_offset + offset);
 			offset += field_size;
-		} else if (field.type.name === "string" && !field.type.is_array && !field.type.is_ref && !struct_type.is_class) {
+		} else if (field.type.name === "string" && !field.type.is_array && !field.type.is_ref) {
 			status.code += `ldr x0, [x29, #${base_offset}]\n`;
 			status.code += `ldr x0, [x0, #${offset}]\n`;
 			emit_free(status);
@@ -1949,7 +2147,9 @@ function is_struct_type$4(type_name, status) {
 	return status.structs.find((s) => s.name === type_name && !s.is_simple_type);
 }
 function emit_destroy_for_decl(status, decl_name, decl_type_name, addr_offset, type_args, is_nullable) {
-	if ((status.moved ?? /* @__PURE__ */ new Set()).has(decl_name)) return;
+	const moved = status.moved ?? /* @__PURE__ */ new Set();
+	release_heap_string_fields(status, decl_name, decl_type_name);
+	if (moved.has(decl_name)) return;
 	if (status.heap_strings?.has(decl_name)) {
 		if (addr_offset !== void 0) status.code += `add x0, x0, #${addr_offset}\n`;
 		else emit_var_load(status, "x0", decl_name, 8);
@@ -1966,7 +2166,7 @@ function emit_destroy_for_decl(status, decl_name, decl_type_name, addr_offset, t
 		skip_label = `.Lskip_nd_${status.label_counter = (status.label_counter ?? 0) + 1}`;
 		status.code += `cbz x0, ${skip_label}\n`;
 	}
-	if (has_destroy(struct_type)) {
+	if (has_destroy(struct_type) || struct_type.is_class) {
 		if (struct_type.is_class) {
 			if (addr_offset !== void 0) status.code += `ldr x0, [x0, #${addr_offset}]\n`;
 			else emit_var_load(status, "x0", decl_name, 8);
@@ -1980,7 +2180,6 @@ function emit_destroy_for_decl(status, decl_name, decl_type_name, addr_offset, t
 			else emit_var_load(status, "x0", decl_name, 8);
 			emit_free(status);
 		}
-		emit_field_destroys(status, struct_type, decl_name, addr_offset, true);
 	} else if (struct_needs_destroy(struct_type, status)) emit_field_destroys(status, struct_type, decl_name, addr_offset, void 0, false);
 	if (skip_label) status.code += `${skip_label}:\n`;
 }
@@ -2016,7 +2215,7 @@ function emit_field_destroys(status, struct_type, decl_name, base_offset, is_cla
 			}
 			const field_size = get_type_size(field.type, status);
 			offset += field_size;
-		} else if (free_strings && field.type.name === "string" && !field.type.is_array && !field.type.is_ref && !struct_type.is_class) {
+		} else if (free_strings && field.type.name === "string" && !field.type.is_array && !field.type.is_ref) {
 			const actual_offset = base_offset !== void 0 ? base_offset + offset : offset;
 			if (decl_name) emit_base_ptr(status, decl_name, is_class_parent);
 			status.code += `ldr x0, [x0, #${actual_offset}]\n`;
@@ -2101,6 +2300,7 @@ function emit_destroy_for_scope(status, declarations_before) {
 	if (current_scope?.heap_slots.length) {
 		for (let i = declarations_before; i < status.scoped_declarations.length; i++) {
 			const decl = status.scoped_declarations[i];
+			release_heap_string_fields(status, decl.name, decl.type.name);
 			if (moved.has(decl.name)) continue;
 			if (status.heap_string_arrays?.has(decl.name)) {
 				const len = status.heap_string_arrays.get(decl.name);
@@ -2138,6 +2338,7 @@ function emit_destroy_for_scope(status, declarations_before) {
 				emit_free(status);
 				continue;
 			}
+			if (is_field_struct_borrow(decl)) continue;
 			const resolved_decl = resolve_decl_struct(decl, status);
 			if (!resolved_decl) continue;
 			const struct_type = resolved_decl.struct_type;
@@ -2152,6 +2353,7 @@ function emit_destroy_for_scope(status, declarations_before) {
 	}
 	for (let i = declarations_before; i < status.scoped_declarations.length; i++) {
 		const decl = status.scoped_declarations[i];
+		release_heap_string_fields(status, decl.name, decl.type.name);
 		if (moved.has(decl.name)) continue;
 		if (status.heap_string_arrays?.has(decl.name)) {
 			const len = status.heap_string_arrays.get(decl.name);
@@ -2194,6 +2396,7 @@ function emit_destroy_for_scope(status, declarations_before) {
 			emit_free(status);
 			continue;
 		}
+		if (is_field_struct_borrow(decl)) continue;
 		const resolved_decl = resolve_decl_struct(decl, status);
 		if (!resolved_decl) continue;
 		const struct_type = resolved_decl.struct_type;
@@ -2259,13 +2462,13 @@ function consolidate_temp_anchors$1(status, call_node, result_type_name) {
 		status.moved.add(pname);
 	}
 }
-function mark_moved_if_struct(value, status) {
+function mark_moved_if_struct(value, status, opts) {
 	if (value?.node_type !== "value") return;
 	const var_name = value.value;
 	let var_type = value.type;
-	if (!var_type?.name) var_type = status.scoped_declarations?.find((d) => d.name === var_name)?.type;
+	if (!var_type?.name) var_type = all_scope_frames(status).flat().find((d) => d.name === var_name)?.type;
 	if (!var_type) return;
-	const is_local = status.scoped_declarations.some((d) => d.name === var_name);
+	const is_local = all_scope_frames(status).some((frame) => frame.some((d) => d.name === var_name));
 	const has_anchor = find_anchor_slot(status, var_name) !== void 0;
 	const is_class_param = !!status.moved_class_params?.has(var_name) || !!status.function_param_regs?.has(var_name) && is_struct_type$4(var_type.name, status);
 	if (!is_local && !has_anchor && !is_class_param) return;
@@ -2273,7 +2476,7 @@ function mark_moved_if_struct(value, status) {
 		if (!status.moved) status.moved = /* @__PURE__ */ new Set();
 		status.moved.add(var_name);
 	}
-	if (status.heap_strings?.has(var_name)) {
+	if (opts?.for_return && status.heap_strings?.has(var_name)) {
 		if (!status.moved) status.moved = /* @__PURE__ */ new Set();
 		status.moved.add(var_name);
 	}
@@ -2318,10 +2521,10 @@ var SwitchNode = class extends BaseNode {
 //#region ../src/build_aarch64/utils/scan_force_heap_strings.ts
 function scan_force_heap_strings(statements) {
 	const result = /* @__PURE__ */ new Set();
-	walk(statements, result);
+	walk$1(statements, result);
 	return result;
 }
-function walk(statements, result) {
+function walk$1(statements, result) {
 	if (!statements) return;
 	for (const stmt of statements) visit(stmt, result);
 }
@@ -2335,18 +2538,18 @@ function visit(node, result) {
 		}
 		case "while":
 		case "for":
-			walk(node.statements, result);
+			walk$1(node.statements, result);
 			break;
 		case "if": {
 			const n = node;
-			walk(n.if_branch?.statements, result);
-			walk(n.else_branch?.statements, result);
+			walk$1(n.if_branch?.statements, result);
+			walk$1(n.else_branch?.statements, result);
 			break;
 		}
 		case "switch": {
 			const n = node;
-			for (const c of n.cases) walk(c.branch?.statements, result);
-			walk(n.else_branch?.statements, result);
+			for (const c of n.cases) walk$1(c.branch?.statements, result);
+			walk$1(n.else_branch?.statements, result);
 			break;
 		}
 	}
@@ -2594,11 +2797,13 @@ function build_function_node$1(node, status) {
 	const old_function_array_params = status.function_array_params;
 	const old_function_ref_params = status.function_ref_params;
 	const old_ref_class_slots = status.ref_class_slots;
+	const old_struct_param_slots = status.function_struct_param_slots;
 	status.function_param_regs = /* @__PURE__ */ new Map();
 	status.function_param_vars = /* @__PURE__ */ new Set();
 	status.function_array_params = /* @__PURE__ */ new Set();
 	status.function_ref_params = /* @__PURE__ */ new Set();
 	status.ref_class_slots = /* @__PURE__ */ new Map();
+	status.function_struct_param_slots = /* @__PURE__ */ new Set();
 	const old_variadic_params_aarch64 = status.function_variadic_params;
 	status.function_variadic_params = /* @__PURE__ */ new Set();
 	status.moved_class_params = /* @__PURE__ */ new Map();
@@ -2637,6 +2842,9 @@ function build_function_node$1(node, status) {
 				const size = is_ref ? 8 : aarch64_size(param.type.name);
 				const offset = allocate_stack_space(status, size, is_ref ? 8 : size);
 				status.stack_offsets.set(param.name, offset);
+				if (!is_ref && !param.type.is_array && !param.is_variadic) {
+					if (!!status.structs.find((s) => s.name === param.type.name && !s.is_simple_type) || !!status.traits.find((t) => t.name === param.type.name) || !!status.enums.find((e) => e.name === param.type.name && e.has_associated_data)) status.function_struct_param_slots.add(param.name);
+				}
 				if (param_idx < 8) {
 					const reg = param_regs[param_idx];
 					if (size === 1) status.code += `strb ${reg.replace("x", "w")}, [x29, #${offset}]\n`;
@@ -2726,13 +2934,15 @@ function build_function_node$1(node, status) {
 	const moved_set = status.moved;
 	if (moved_param_save_slots.size > 0 && node.name !== "main") {
 		const need_guard = return_is_class;
+		const need_save = !!node.return_type?.name;
 		let return_save;
-		if (need_guard) {
+		if (need_guard || need_save) {
 			return_save = allocate_stack_space(status, 8);
 			status.code += `str x0, [x29, #${return_save}]\n`;
 		}
 		for (const [name, info] of moved_param_save_slots) {
 			if (moved_set?.has(name)) continue;
+			if (moved_param_is_consumed(node, name)) continue;
 			if (need_guard) {
 				status.code += `ldr x0, [x29, #${info.offset}]\n`;
 				status.code += `ldr x1, [x29, #${return_save}]\n`;
@@ -2744,7 +2954,7 @@ function build_function_node$1(node, status) {
 			emit_free(status);
 			if (need_guard) status.code += `${keep_prefix}_${name}:\n`;
 		}
-		if (need_guard) status.code += `ldr x0, [x29, #${return_save}]\n`;
+		if (need_guard || need_save) status.code += `ldr x0, [x29, #${return_save}]\n`;
 	}
 	const total_stack = Math.ceil((status.stack_size || 0) / 16) * 16;
 	status.code = status.code.replace(`sub sp, sp, #${stack_placeholder}`, total_stack > 0 ? `sub sp, sp, #${total_stack}` : `// no stack needed`);
@@ -2787,6 +2997,7 @@ function build_function_node$1(node, status) {
 	status.function_array_params = old_function_array_params;
 	status.function_ref_params = old_function_ref_params;
 	status.ref_class_slots = old_ref_class_slots;
+	status.function_struct_param_slots = old_struct_param_slots;
 	status.function_variadic_params = old_variadic_params_aarch64;
 	status.function_return_label = old_return_label;
 	status.struct_return_buffer = void 0;
@@ -2965,6 +3176,30 @@ function is_mutable_param(name, status) {
 	return !!(status.function_param_vars?.has(name) || status.function_ref_params?.has(name));
 }
 /**
+* Whether `obj.field = rhs` writes a plain `string` field of a struct or
+* class instance. CLASS string fields follow an always-heap-owned convention
+* (see the assignment branch that uses this): `_init` strdup's defaults and
+* assignments strdup non-heap RHS, so destroys can free them unconditionally.
+* VALUE-struct string fields keep per-assignment ownership tracking instead
+* (construction may leave rodata in them): non-heap RHS is strdup'd and the
+* field is recorded in heap_string_fields for release at scope exit.
+* `ref` string fields (borrows) are excluded either way.
+*/
+function field_is_struct_string(target_type, field_type, status) {
+	if (!target_type?.name || !field_type) return void 0;
+	if (field_type.name !== "string" || field_type.is_ref || field_type.is_array) return void 0;
+	const target_struct = status.structs.find((s) => s.name === target_type.name && !s.is_simple_type);
+	if (!target_struct) return void 0;
+	if (target_struct.is_class) return {
+		name: field_type.name,
+		target_is_class: true
+	};
+	return {
+		name: field_type.name,
+		target_is_class: false
+	};
+}
+/**
 * Load a `ref T` parameter's caller-side pointer into `reg`. The pointer is the
 * 8-byte value held in the parameter's stack slot (or, rarely, a register
 * allocation). Only writes `reg` — safe to run after a RHS has been built into
@@ -3530,6 +3765,38 @@ function build_assignment_node$1(node, status) {
 				status.code += `mov x2, x0\n`;
 				status.code += `ldr x0, [sp], #16\n`;
 				status.code += `str x2, [x0, #${offset}]\n`;
+			} else if (field_is_struct_string(target_type, field_type, status) && !node.operator && (() => {
+				const st = field_is_struct_string(target_type, field_type, status);
+				const tv = access.target.node_type === "value" ? access.target.value : "";
+				return st.target_is_class || tv !== "" && tv !== "self";
+			})()) {
+				const string_target = field_is_struct_string(target_type, field_type, status);
+				const target_var = access.target.node_type === "value" ? access.target.value : "";
+				const tracked_key = `${target_var}.${field_name}`;
+				const is_class_target = string_target.target_is_class;
+				const old_was_heap = is_class_target || !!status.heap_string_fields?.has(tracked_key);
+				const offset = get_field_offset(target_type.name, field_name, status);
+				get_base_address(access, status, "x0");
+				status.code += `str x0, [sp, #-16]!\n`;
+				status.last_result_is_heap = false;
+				build_node$1(node.right_value, status);
+				if (!status.code.endsWith("\n")) status.code += "\n";
+				const rhs_is_heap = status.last_result_is_heap;
+				if (is_class_target && !rhs_is_heap) emit_strdup(status);
+				mark_moved_if_struct(node.right_value, status);
+				status.code += `str x0, [sp, #-16]!\n`;
+				if (old_was_heap) {
+					status.code += `ldr x0, [sp, #16]\n`;
+					status.code += `ldr x0, [x0, #${offset}]\n`;
+					emit_free(status);
+				}
+				status.code += `ldr x2, [sp], #16\n`;
+				status.code += `ldr x0, [sp], #16\n`;
+				status.code += `str x2, [x0, #${offset}]\n`;
+				if (!is_class_target && target_var && target_var !== "self") {
+					if (rhs_is_heap) record_heap_string_field(status, target_var, field_name);
+					else status.heap_string_fields?.delete(tracked_key);
+				}
 			} else if (field_is_struct && !node.operator) {
 				const field_struct = status.structs.find((s) => s.name === field_type.name);
 				if (field_struct?.is_class) {
@@ -4810,6 +5077,7 @@ function build_declaration_node$1(node, status) {
 					if (status.heap_cleanup_stack?.length) status.heap_cleanup_stack[status.heap_cleanup_stack.length - 1].heap_strings.add(node.name);
 				}
 			} else if (!node.type.is_array && status.structs.find((s) => s.name === node.type.name && s.is_class)) {
+				if (process.env.NOMEN_DEBUG_ANCHOR) console.error("ANCHOR check_heap:", node.name, "value:", node.value?.node_type, node.value?.name ?? "");
 				emit_var_load(status, "x0", node.name, 8);
 				anchor_heap_pointer(status, node.name);
 				consolidate_temp_anchors$1(status, node.value, node.type.name);
@@ -4946,7 +5214,9 @@ function build_declaration_node$1(node, status) {
 	}
 	const value_is_field_borrow = node.value?.node_type === "access" && node.value.access.node_type === "access_field";
 	const value_is_var_borrow = node.value?.node_type === "value" && !node.value.is_moved && node.value.value !== "null";
-	const is_borrowed_class_ref = !!(node.type?.name && struct_type && struct_type.is_class && (value_is_field_borrow || value_is_var_borrow));
+	const value_is_method_borrow = node.value?.node_type === "access" && node.value.access.node_type === "access_func" && !node.value.access.owned_return;
+	const value_is_borrowing_call = node.value?.node_type === "func_call" && !!status.borrow_returning_functions?.has(node.value.name);
+	const is_borrowed_class_ref = !!(node.type?.name && struct_type && struct_type.is_class && (value_is_field_borrow || value_is_var_borrow || value_is_method_borrow || value_is_borrowing_call));
 	if (!is_borrowed_class_ref) status.scoped_declarations.push(node);
 	if (struct_type?.is_class) {
 		const top = (status.heap_cleanup_stack?.length ?? 1) - 1;
@@ -4960,7 +5230,7 @@ function build_declaration_node$1(node, status) {
 			status.alias_owns_flag?.set(node.name, flag_offset);
 		}
 	}
-	if (!is_borrowed_class_ref && struct_type && struct_needs_destroy(struct_type, status)) track_struct_decl(status, node.name, node.type.name, node.type.type_args, node.type.is_nullable);
+	if (!is_borrowed_class_ref && !is_field_struct_borrow(node) && struct_type && struct_needs_destroy(struct_type, status)) track_struct_decl(status, node.name, node.type.name, node.type.type_args, node.type.is_nullable);
 	if (status.enums.find((e) => e.name === node.type.name && e.has_associated_data)) {
 		const enum_size = get_enum_size(node.type.name, status);
 		if (status.function_return_label) {
@@ -5372,8 +5642,10 @@ function build_declaration_node$1(node, status) {
 					build_node$1(func_call, status);
 					if (!status.code.endsWith("\n")) status.code += "\n";
 					emit_var_store(status, "x0", node.name, 8);
-					status.last_result_is_heap = true;
-					check_heap();
+					if (!status.borrow_returning_functions?.has(func_call.name)) {
+						status.last_result_is_heap = true;
+						check_heap();
+					}
 				}
 			} else if (node.value) {
 				if (node.value.node_type === "value") {
@@ -5942,8 +6214,7 @@ function reset_label_counter$4() {
 	label_counter$4 = 0;
 }
 function build_for_loop_node$1(node, status) {
-	const old_scoped_declarations = status.scoped_declarations;
-	status.scoped_declarations = [];
+	const old_scoped_declarations = enter_scope_frame(status);
 	const label = label_counter$4++;
 	const item_name = node.item.value;
 	const start_label = `.for_${label}`;
@@ -6233,7 +6504,7 @@ function build_for_loop_node$1(node, status) {
 	status.buffer_data_cache = saved_buffer_cache;
 	status.loop_labels.pop();
 	status.loop_writebacks?.pop();
-	status.scoped_declarations = old_scoped_declarations;
+	exit_scope_frame(status, old_scoped_declarations);
 }
 function is_enumerable_type$1(node, status) {
 	if (node.node_type !== "value") return false;
@@ -6640,7 +6911,7 @@ function build_function_call_node$1(node, status) {
 		const param = node.params[idx];
 		if (param?.node_type === "value") {
 			const vname = param.value;
-			if (((status.scoped_declarations?.find((d) => d.name === vname))?.type?.name ?? param.type?.name) === "string") continue;
+			if ((all_scope_frames(status).flat().find((d) => d.name === vname)?.type?.name ?? param.type?.name) === "string") continue;
 		}
 		if (param) mark_moved_if_struct(param, status);
 	}
@@ -6653,8 +6924,7 @@ function reset_label_counter$3() {
 }
 function build_if_else_node$1(node, status) {
 	const label = label_counter$3++;
-	const old_scoped_declarations = status.scoped_declarations;
-	status.scoped_declarations = [];
+	const old_scoped_declarations = enter_scope_frame(status);
 	build_node$1(node.condition, status);
 	status.code += `\ncmp x0, #0\n`;
 	const pre_cache = status.buffer_data_cache;
@@ -6675,7 +6945,7 @@ function build_if_else_node$1(node, status) {
 	}
 	status.buffer_data_cache = pre_cache;
 	status.code += `end_${label}:\n`;
-	status.scoped_declarations = old_scoped_declarations;
+	exit_scope_frame(status, old_scoped_declarations);
 }
 //#endregion
 //#region ../src/build_aarch64/build_let_node.ts
@@ -6737,7 +7007,7 @@ function emit_pattern_tag(match_value, enum_name, status) {
 }
 function build_match_node$1(node, status) {
 	const label = label_counter$2++;
-	const old_scoped_declarations = status.scoped_declarations;
+	const old_scoped_declarations = enter_scope_frame(status);
 	const old_stack_offsets = status.stack_offsets;
 	status.stack_offsets = new Map(old_stack_offsets);
 	const match_type_name = type_from_value_node$1(node.value)?.name;
@@ -6805,7 +7075,7 @@ function build_match_node$1(node, status) {
 	}
 	status.buffer_data_cache = pre_cache;
 	status.code += `end_match_${label}:\n`;
-	status.scoped_declarations = old_scoped_declarations;
+	exit_scope_frame(status, old_scoped_declarations);
 	status.stack_offsets = old_stack_offsets;
 }
 //#endregion
@@ -7449,8 +7719,12 @@ function build_return_node$1(node, status) {
 			status.code += `str xzr, [x8, #${struct_size}]\n`;
 		}
 		const finalized = status.moved ?? /* @__PURE__ */ new Set();
-		for (const decl of status.scoped_declarations) {
-			if (finalized.has(decl.name)) continue;
+		for (const decl of all_scope_frames(status).flat()) {
+			if (finalized.has(decl.name)) {
+				release_heap_string_fields(status, decl.name, decl.type.name);
+				continue;
+			}
+			if (is_field_struct_borrow(decl)) continue;
 			emit_destroy_for_decl(status, decl.name, decl.type.name, void 0, decl.type.type_args, decl.type.is_nullable);
 		}
 		emit_heap_slots_cleanup_for_return(status);
@@ -7464,8 +7738,12 @@ function build_return_node$1(node, status) {
 			emit_var_store(status, "x0", status.return_assign, size);
 		} else if (status.function_return_label) {
 			const finalized = status.moved ?? /* @__PURE__ */ new Set();
-			for (const decl of status.scoped_declarations) {
-				if (finalized.has(decl.name)) continue;
+			for (const decl of all_scope_frames(status).flat()) {
+				if (finalized.has(decl.name)) {
+					release_heap_string_fields(status, decl.name, decl.type.name);
+					continue;
+				}
+				if (is_field_struct_borrow(decl)) continue;
 				emit_destroy_for_decl(status, decl.name, decl.type.name, void 0, decl.type.type_args, decl.type.is_nullable);
 			}
 			emit_heap_slots_cleanup_for_return(status);
@@ -7629,11 +7907,16 @@ function build_return_node$1(node, status) {
 				status.moved.add(var_name);
 			}
 		}
-		mark_moved_if_struct(node.value, status);
+		mark_moved_if_struct(node.value, status, { for_return: true });
+		if (node.value?.node_type === "value") clear_heap_string_fields(status, node.value.value);
 		const finalized = status.moved ?? /* @__PURE__ */ new Set();
 		status.code += `str x0, [sp, #-16]!\n`;
-		for (const decl of status.scoped_declarations) {
-			if (finalized.has(decl.name)) continue;
+		for (const decl of all_scope_frames(status).flat()) {
+			if (finalized.has(decl.name)) {
+				release_heap_string_fields(status, decl.name, decl.type.name);
+				continue;
+			}
+			if (is_field_struct_borrow(decl)) continue;
 			emit_destroy_for_decl(status, decl.name, decl.type.name, void 0, decl.type.type_args, decl.type.is_nullable);
 		}
 		emit_heap_slots_cleanup_for_return(status);
@@ -7649,7 +7932,7 @@ function reset_label_counter$1() {
 }
 function build_switch_node$1(node, status) {
 	const label = label_counter$1++;
-	const old_scoped_declarations = status.scoped_declarations;
+	const old_scoped_declarations = enter_scope_frame(status);
 	const pre_cache = status.buffer_data_cache;
 	for (let i = 0; i < node.cases.length; i++) {
 		status.scoped_declarations = [];
@@ -7669,7 +7952,7 @@ function build_switch_node$1(node, status) {
 	}
 	status.buffer_data_cache = pre_cache;
 	status.code += `end_switch_${label}:\n`;
-	status.scoped_declarations = old_scoped_declarations;
+	exit_scope_frame(status, old_scoped_declarations);
 }
 //#endregion
 //#region ../src/build_aarch64/build_todo_node.ts
@@ -7896,8 +8179,7 @@ function reset_label_counter() {
 	label_counter = 0;
 }
 function build_while_loop_node$1(node, status) {
-	const old_scoped_declarations = status.scoped_declarations;
-	status.scoped_declarations = [];
+	const old_scoped_declarations = enter_scope_frame(status);
 	const label = label_counter++;
 	const start_label = `.while_${label}`;
 	const end_label = `.end_while_${label}`;
@@ -8017,7 +8299,7 @@ function build_while_loop_node$1(node, status) {
 	else status.register_allocations = void 0;
 	status.buffer_data_cache = saved_buffer_cache;
 	status.loop_labels.pop();
-	status.scoped_declarations = old_scoped_declarations;
+	exit_scope_frame(status, old_scoped_declarations);
 }
 //#endregion
 //#region ../src/build_aarch64/build_node.ts
@@ -8738,7 +9020,7 @@ function build_auto_destroy_function(node, status) {
 	status.function_param_regs.set("self", "x19");
 	status.code += `sub sp, sp, #${stack_placeholder}\n`;
 	status.code += `mov x29, sp\n`;
-	emit_field_destroys(status, node, "self", void 0, false);
+	emit_field_destroys(status, node, "self", void 0, false, node.is_class);
 	status.code += `${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`);
@@ -8821,6 +9103,13 @@ function build_init_function(node, status) {
 			}
 		} else {
 			const field_size = get_type_size(field.type, status);
+			if (node.is_class && field.type.name === "string" && !field.type.is_ref) {
+				status.code += `str ${src_reg}, [sp, #-16]!\n`;
+				status.code += `mov x0, ${src_reg}\n`;
+				status.code += `bl _strdup\n`;
+				status.code += `mov ${src_reg}, x0\n`;
+				status.code += `ldr x0, [sp], #16\n`;
+			}
 			emit_typed_store(status, src_reg, "x19", offset, field_size);
 		}
 	}
@@ -8838,6 +9127,11 @@ function build_init_function(node, status) {
 				const label = `_str_${func_name}_${field.name}`;
 				status.strings.set(label, val);
 				status.code += `adr x1, ${label}\n`;
+				if (node.is_class && field.type.name === "string" && !field.type.is_ref) {
+					status.code += `mov x0, x1\n`;
+					status.code += `bl _strdup\n`;
+					status.code += `mov x1, x0\n`;
+				}
 			} else {
 				const resolved = resolve_global_const_value(val, status);
 				if (resolved !== void 0) status.code += `ldr x1, =${resolved}\n`;
@@ -8975,6 +9269,11 @@ function build_custom_init_function(node, func, status) {
 				const label = `_str_${func_name}_${field.name}`;
 				status.strings.set(label, val);
 				status.code += `adr x1, ${label}\n`;
+				if (node.is_class && field.type.name === "string" && !field.type.is_ref) {
+					status.code += `mov x0, x1\n`;
+					status.code += `bl _strdup\n`;
+					status.code += `mov x1, x0\n`;
+				}
 			} else {
 				const resolved = resolve_global_const_value(val, status);
 				if (resolved !== void 0) status.code += `ldr x1, =${resolved}\n`;
@@ -9183,8 +9482,33 @@ function build_struct_functions$1(node, status) {
 			}
 			second_slot_idx++;
 		}
+		const moved_param_save_slots = /* @__PURE__ */ new Map();
+		for (const param of func.params) {
+			if (!param.is_moved || param.is_self_param) continue;
+			if (!status.structs.find((s) => s.name === param.type.name && s.is_class)) continue;
+			const reg = status.function_param_regs.get(param.name);
+			if (reg) {
+				const save_offset = allocate_stack_space(status, 8);
+				status.code += `str ${reg}, [x29, #${save_offset}]\n`;
+				moved_param_save_slots.set(param.name, {
+					offset: save_offset,
+					type_name: param.type.name,
+					type_args: param.type.type_args,
+					is_nullable: param.type.is_nullable
+				});
+			} else {
+				const offset = status.stack_offsets.get(param.name);
+				if (offset !== void 0) moved_param_save_slots.set(param.name, {
+					offset,
+					type_name: param.type.name,
+					type_args: param.type.type_args,
+					is_nullable: param.type.is_nullable
+				});
+			}
+		}
 		status.force_heap_strings = scan_force_heap_strings(func.statements);
 		status.buffer_data_cache = void 0;
+		const moved_before = new Set(status.moved ?? []);
 		if (!emit_owning_buffer_standalone_aarch64(node, func.name, status)) build_block_node$1(func, status);
 		const loop_regs_used = status.callee_saved_regs_used ? [...status.callee_saved_regs_used].sort() : [];
 		status.callee_saved_regs_used = void 0;
@@ -9199,6 +9523,31 @@ function build_struct_functions$1(node, status) {
 			}
 		}
 		status.code += `${return_label}:\n`;
+		if (moved_param_save_slots.size > 0) {
+			const ret_is_class = !!func.return_type?.name && !!status.structs.find((s) => s.name === func.return_type.name && s.is_class);
+			const need_save = !!func.return_type?.name;
+			const keep_prefix = `.Lkeep_mparam_${func_label.replace(/[^\w]/g, "_")}`;
+			let return_save;
+			if (ret_is_class || need_save) {
+				return_save = allocate_stack_space(status, 8);
+				status.code += `str x0, [x29, #${return_save}]\n`;
+			}
+			for (const [name, info] of moved_param_save_slots) {
+				if (status.moved?.has(name) && !moved_before.has(name)) continue;
+				if (moved_param_is_consumed(func, name)) continue;
+				if (ret_is_class) {
+					status.code += `ldr x0, [x29, #${info.offset}]\n`;
+					status.code += `ldr x1, [x29, #${return_save}]\n`;
+					status.code += `cmp x0, x1\n`;
+					status.code += `beq ${keep_prefix}_${name}\n`;
+				}
+				emit_destroy_for_anchor_slot(status, info.offset, info.type_name, info.type_args, info.is_nullable);
+				status.code += `ldr x0, [x29, #${info.offset}]\n`;
+				emit_free(status);
+				if (ret_is_class) status.code += `${keep_prefix}_${name}:\n`;
+			}
+			if (ret_is_class || need_save) status.code += `ldr x0, [x29, #${return_save}]\n`;
+		}
 		const total_stack = Math.ceil((status.stack_size || 0) / 16) * 16;
 		status.code = status.code.replace(`sub sp, sp, #${stack_placeholder}`, total_stack > 0 ? `sub sp, sp, #${total_stack}` : `// no stack needed`);
 		status.code = patch_overflow_placeholders(status.code, func_label, callee_idx + loop_regs_used.length, total_stack);
@@ -9655,6 +10004,8 @@ function build_inline_method(struct_node, func, status) {
 	const old_function_return_type = status.function_return_type;
 	const old_register_allocations = status.register_allocations;
 	const old_buffer_data_cache = status.buffer_data_cache;
+	const old_heap_cleanup_stack = status.heap_cleanup_stack;
+	const old_moved = status.moved;
 	const return_label = `.inline_ret_${inline_counter++}`;
 	status.function_return_label = return_label;
 	status.scoped_declarations = [];
@@ -9662,6 +10013,8 @@ function build_inline_method(struct_node, func, status) {
 	status.struct_return_buffer = void 0;
 	status.return_buffer_stack_offset = void 0;
 	status.buffer_data_cache = void 0;
+	status.heap_cleanup_stack = [];
+	status.moved = /* @__PURE__ */ new Set();
 	if (needs_x19) {
 		status.code += `str x19, [sp, #-16]!\n`;
 		status.code += `mov x19, x0\n`;
@@ -9740,6 +10093,8 @@ function build_inline_method(struct_node, func, status) {
 	status.function_return_type = old_function_return_type;
 	status.register_allocations = old_register_allocations;
 	status.buffer_data_cache = old_buffer_data_cache;
+	status.heap_cleanup_stack = old_heap_cleanup_stack;
+	status.moved = old_moved;
 }
 let inline_fn_depth = 0;
 const MAX_INLINE_DEPTH = 2;
@@ -9757,6 +10112,8 @@ function build_inline_function(func, status) {
 	const old_function_return_type = status.function_return_type;
 	const old_register_allocations = status.register_allocations;
 	const old_buffer_data_cache = status.buffer_data_cache;
+	const old_heap_cleanup_stack = status.heap_cleanup_stack;
+	const old_moved = status.moved;
 	const return_label = `.inline_fn_ret_${inline_counter++}`;
 	status.function_return_label = return_label;
 	status.scoped_declarations = [];
@@ -9764,6 +10121,8 @@ function build_inline_function(func, status) {
 	status.struct_return_buffer = void 0;
 	status.return_buffer_stack_offset = void 0;
 	status.buffer_data_cache = void 0;
+	status.heap_cleanup_stack = [];
+	status.moved = /* @__PURE__ */ new Set();
 	const param_regs = [
 		"x0",
 		"x1",
@@ -9830,6 +10189,8 @@ function build_inline_function(func, status) {
 	status.function_return_type = old_function_return_type;
 	status.register_allocations = old_register_allocations;
 	status.buffer_data_cache = old_buffer_data_cache;
+	status.heap_cleanup_stack = old_heap_cleanup_stack;
+	status.moved = old_moved;
 	inline_fn_depth--;
 	return true;
 }
@@ -10438,6 +10799,12 @@ function build_access_field(node, status) {
 			if (paramReg !== "x0") status.code += `mov x0, ${paramReg}\n`;
 		} else emit_var_load(status, "x0", name, 8);
 		const final_offset = get_field_offset(target_type?.name || "", access_field.name, status);
+		const field_type_obj = resolve_field_type(access_field, target_type?.name, status);
+		const resolved_field_type = field_type_obj?.name || "";
+		if (!!resolved_field_type && !field_type_obj?.is_ref && !field_type_obj?.is_nullable && is_struct_type(resolved_field_type, status)) {
+			if (final_offset > 0) status.code += `add x0, x0, #${final_offset}\n`;
+			return;
+		}
 		const field_type = access_field.type?.name || "";
 		const size = aarch64_size(field_type);
 		const signed = field_type.startsWith("int") || field_type === "float" || field_type === "float32" || field_type === "float64";
@@ -10991,10 +11358,14 @@ function build_access_method(node, access_func, status) {
 		const param = access_func.params[idx];
 		if (param?.node_type === "value") {
 			const vname = param.value;
-			if (((status.scoped_declarations?.find((d) => d.name === vname))?.type?.name ?? param.type?.name) === "string") continue;
+			if ((all_scope_frames(status).flat().find((d) => d.name === vname)?.type?.name ?? param.type?.name) === "string") continue;
 		}
 		if (param) mark_moved_if_struct(param, status);
 	}
+	if (node.target.node_type === "value" && target_struct && !target_struct.is_class && !trait_target) {
+		const target_method = target_struct.functions.find((f) => f.name === access_func.name);
+		if (target_method) drop_self_written_string_field_records(status, node.target.value, scan_self_string_field_writes(target_struct, target_method));
+	}
 	if (method_name.endsWith("_to_string") && method_name !== "string_to_string") status.last_result_is_heap = true;
 	if (status.heap_returning_functions?.has(method_name)) status.last_result_is_heap = true;
 	if (method_name === "Buffer_string_move_T") status.last_result_is_heap = true;
@@ -11739,13 +12110,7 @@ function build_spawn_node(node, status) {
 	if (!status.headers.includes("__nomen_pool_submit")) status.headers += POOL_HEADER;
 	const struct_name = `__nomen_spawn_${id}_args`;
 	const tramp_name = `__nomen_spawn_${id}_trampoline`;
-	const arg_c_types = [];
-	for (let i = 0; i < call.params.length; i++) {
-		const mono_name = mono_type_name(type_from_value_node$1(call.params[i]));
-		const is_class = !!status.structs.find((s) => s.name === mono_name && s.is_class);
-		const is_trait = !!status.traits.find((t) => t.name === mono_name);
-		arg_c_types.push(is_class || is_trait ? `struct ${mono_name} *` : c_type(mono_name));
-	}
+	const arg_c_types = spawn_arg_c_types(call, status);
 	const return_type_name = node.function_return_type?.name;
 	const returns_value = !!(return_type_name && return_type_name !== "void" && return_type_name !== "?");
 	const is_class_ret = returns_value && !!status.structs.find((s) => s.name === return_type_name && s.is_class);
@@ -11818,6 +12183,98 @@ function build_spawn_node(node, status) {
 	}
 	status.code += `})\n`;
 }
+const C_BUILTIN_TYPES = /* @__PURE__ */ new Set([
+	"bool",
+	"int",
+	"uint",
+	"int8",
+	"uint8",
+	"int16",
+	"uint16",
+	"int32",
+	"uint32",
+	"int64",
+	"uint64",
+	"float",
+	"ufloat",
+	"float32",
+	"ufloat32",
+	"float64",
+	"ufloat64",
+	"char",
+	"string",
+	"func",
+	"void",
+	"null"
+]);
+/**
+* Resolve each spawn argument's C type. Classes/traits are pointers;
+* primitives and by-value structs use c_type's output directly. Generic
+* instantiations (e.g. Channel<uint64>) use the monomorphized C name
+* (`Channel_uint64`). The type comes from the CALLEE's declared parameter
+* whenever it can be resolved — an argument's own node type can differ
+* (e.g. an int literal `41` passed for a `uint64` param lowers to `long`,
+* conflicting with the emitted `unsigned long long` prototype). Falls back
+* to the argument's type when the callee (or its param type) can't be
+* resolved at build time.
+*/
+function spawn_arg_c_types(call, status) {
+	const arg_c_types = [];
+	const callee_params = find_spawn_callee(call.name, status)?.params?.filter((p) => !p.is_self_param) ?? [];
+	for (let i = 0; i < call.params.length; i++) {
+		const mono_name = mono_type_name(callee_params[i]?.type && is_resolvable_c_type(callee_params[i].type, status) ? callee_params[i].type : type_from_value_node$1(call.params[i]));
+		const is_class = !!status.structs.find((s) => s.name === mono_name && s.is_class);
+		const is_trait = !!status.traits.find((t) => t.name === mono_name);
+		arg_c_types.push(is_class || is_trait ? `struct ${mono_name} *` : c_type(mono_name));
+	}
+	return arg_c_types;
+}
+/** Whether a Nomen type name lowers to a real C type in this build: a
+*  builtin primitive or a struct/enum the backend knows (post-monomorphization).
+*  Unresolved generic type params (`T`) fail this check. */
+function is_resolvable_c_type(type, status) {
+	if (C_BUILTIN_TYPES.has(type.name)) return true;
+	return !!status.structs.find((s) => s.name === type.name);
+}
+/**
+* Find the spawned function's definition — a top-level function, a function
+* nested in a block (parse wrappers hoist user code into `main`), or a
+* struct/trait method (matched by its mangled `Struct_method` name) — so the
+* trampoline's forward declaration can copy the callee's DECLARED parameter
+* types. Monomorphized clones are also reachable this way (they are appended
+* to the AST). A same-named pair would already collide at C level, so the
+* first match is as good as any.
+*/
+function find_spawn_callee(name, status) {
+	let found;
+	const visit = (node) => {
+		if (found || !node || typeof node !== "object") return;
+		if (node.node_type === "func") {
+			if (node.name === name) {
+				found = node;
+				return;
+			}
+		} else if (node.node_type === "struct" || node.node_type === "trait") {
+			const functions = node.functions ?? [];
+			for (const func of functions) {
+				const owner = node.name;
+				if (func.name === name || `${owner}_${func.name}` === name) {
+					found = func;
+					return;
+				}
+			}
+		}
+		for (const key of Object.keys(node)) {
+			if (key === "parent" || key === "scope") continue;
+			const v = node[key];
+			if (Array.isArray(v)) for (const item of v) visit(item);
+			else if (v && typeof v === "object" && "node_type" in v) visit(v);
+			if (found) return;
+		}
+	};
+	visit(status.root);
+	return found;
+}
 //#endregion
 //#region ../src/build_c/build_nursery_spawn.ts
 /**
@@ -11843,13 +12300,7 @@ function build_nursery_spawn(node, nursery_ptr, status) {
 	if (!status.headers.includes("__nomen_pool_submit")) status.headers += POOL_HEADER;
 	const struct_name = `__nomen_spawn_${id}_args`;
 	const tramp_name = `__nomen_spawn_${id}_trampoline`;
-	const arg_c_types = [];
-	for (let i = 0; i < args.length; i++) {
-		const mono_name = mono_type_name(type_from_value_node$1(args[i]));
-		const is_class = !!status.structs.find((s) => s.name === mono_name && s.is_class);
-		const is_trait = !!status.traits.find((t) => t.name === mono_name);
-		arg_c_types.push(is_class || is_trait ? `struct ${mono_name} *` : c_type(mono_name));
-	}
+	const arg_c_types = spawn_arg_c_types(call, status);
 	const return_type_name = node.function_return_type?.name;
 	const returns_value = !!(return_type_name && return_type_name !== "void" && return_type_name !== "?");
 	const is_class_ret = returns_value && !!status.structs.find((s) => s.name === return_type_name && s.is_class);
@@ -12060,21 +12511,25 @@ function build_operation_node(node, status) {
 	} else if (node.operator_func) {
 		const label = node.operator_func.mangled_name || `${node.operator_func.struct_name}_${node.operator_func.func_name}`;
 		const is_string_op = node.type?.name === "string";
-		const left_temp = is_string_op && is_owned_heap_temp(node.left_value, status);
-		const right_temp = is_string_op && is_owned_heap_temp(node.right_value, status);
+		const is_string_cmp = node.op === "==" || node.op === "!=";
+		const left_temp = (is_string_op || is_string_cmp) && is_owned_heap_temp(node.left_value, status);
+		const right_temp = (is_string_op || is_string_cmp) && is_owned_heap_temp(node.right_value, status);
 		if (left_temp || right_temp) {
 			const id = status.label_counter = (status.label_counter ?? 0) + 1;
 			const lt = `_ltmp_${id}`;
 			const rt = `_rtmp_${id}`;
+			const cres = `_cres_${id}`;
 			status.code += `({ `;
 			status.code += `char* ${lt} = `;
 			build_operand(node.left_value, status);
 			status.code += `; char* ${rt} = `;
 			build_operand(node.right_value, status);
-			status.code += `; char* _cres_${id} = ${label}(${lt}, ${rt}); `;
+			status.code += `; `;
+			if (is_string_op) status.code += `char* ${cres} = ${label}(${lt}, ${rt}); `;
+			else status.code += `int ${cres} = ${label}(${lt}, ${rt}); `;
 			if (left_temp) status.code += `free(${lt}); `;
 			if (right_temp) status.code += `free(${rt}); `;
-			status.code += `_cres_${id}; })`;
+			status.code += `${cres}; })`;
 		} else {
 			const is_array_op = node.operator_func.struct_name.startsWith("Array") && (type_from_value_node$1(node.left_value).is_array || type_from_value_node$1(node.right_value).is_array);
 			if (node.operator_func.invert) status.code += `(!`;
@@ -12133,7 +12588,7 @@ function is_owned_heap_temp(node, status) {
 		if (heap_set?.has(mangled)) return true;
 		if (heap_set && target_value && heap_set.has(`${target_value}_${raw_name}`)) return true;
 		if (heap_set && target_type_name && heap_set.has(`${target_type_name}_${raw_name}`)) return true;
-		return !(check_node.node_type === "access_func" && (raw_name === "at" || raw_name === "first") && !check_node.owned_return);
+		return !(check_node.node_type === "access_func" && (raw_name === "at" || raw_name === "first" || raw_name === "load_T") && !check_node.owned_return);
 	}
 	return false;
 }
@@ -12241,11 +12696,356 @@ function build_array_operand_for_call(node, status) {
 }
 let ns_tmp_counter = 0;
 //#endregion
-//#region ../src/build_c/build_access_node.ts
+//#region ../src/build_c/utils/is_string_borrow.ts
 /**
-* The C type of a single element of a `view T` slice, used to cast the
-* universal `nomen_view.ptr` for `.at`/`.set`. `view string`'s element is a
-* `char`; every other view's element is its own type name.
+* Whether a value node denotes a BORROWED string — a pointer into storage the
+* receiver does not own (an array element accessed via `.at()`/`.first()`, or
+* `init.args.at(n)` which points into the C runtime's `argv`). Borrowed
+* strings must NOT be freed by auto_free or by reassignment: freeing them
+* reclaims memory owned by the container (or argv), crashing with
+* "pointer being freed was not allocated". Mirrors aarch64's `heap_strings`
+* ownership tracking, which only frees freshly-allocated strings.
+*/
+function is_string_borrow(node) {
+	if (!node || node.node_type !== "access") return false;
+	const access = node.access;
+	if (access.node_type !== "access_func") return false;
+	const func = access;
+	return (func.name === "at" || func.name === "first") && !func.owned_return;
+}
+//#endregion
+//#region ../src/build_c/build_auto_free.ts
+function build_auto_free(status) {
+	free_scoped_declarations(status, status.scoped_declarations);
+	if (status.deferred_frees?.length) {
+		status.code += "\n// Deferred frees\n";
+		for (const d of status.deferred_frees) if (d.is_nullable) status.code += `if (${d.temp}) { ${d.struct_name}_destroy(${d.temp}); free(${d.temp}); }\n`;
+		else status.code += `${d.struct_name}_destroy(${d.temp}); free(${d.temp});\n`;
+		status.deferred_frees.length = 0;
+	}
+	status.scoped_declarations = [];
+}
+/**
+* Emit scope-exit free/destroy code for a list of declarations. Extracted from
+* build_auto_free so that break/continue can reclaim declarations from the
+* current scope AND enclosing scopes (up to the loop body) before jumping —
+* see build_break_node. Does NOT process deferred_frees or clear the list
+* (those are scope-exit-only concerns handled by build_auto_free).
+*/
+function free_scoped_declarations(status, decls, persist_string_field_records = false) {
+	let commented = false;
+	if (status.heap_string_fields?.size) for (const dec of decls) {
+		const prefix = `${dec.name}.`;
+		for (const key of Array.from(status.heap_string_fields)) if (key.startsWith(prefix)) {
+			if (!commented) {
+				status.code += "\n// Auto-free\n";
+				commented = true;
+			}
+			status.code += `free(${key});\n`;
+			if (!persist_string_field_records) status.heap_string_fields.delete(key);
+		}
+	}
+	for (const dec of decls) {
+		const struct = status.structs.find((s) => s.name === dec.type.name);
+		if (struct && struct.traits.includes("Disposable")) {
+			const trait = status.traits.find((t) => t.name === "Disposable");
+			const func = trait?.functions.find((f) => f.name == "dispose");
+			if (trait && func) {
+				if (!commented) {
+					status.code += "\n// Auto-free\n";
+					commented = true;
+				}
+				const cast = "(void *(*)(void *))";
+				const traitIndex = status.traits.indexOf(trait);
+				const funcIndex = trait.functions.indexOf(func);
+				status.code += `(${cast}_get_trait_func((void *)&${dec.name}, ${traitIndex}, ${funcIndex}))(&${dec.name});\n`;
+			}
+		}
+		const is_destructured_field_access = dec.value?.node_type === "access" && dec.value.access.node_type === "access_field" && !dec.value.is_moved;
+		const is_borrowed_string = is_string_borrow(dec.value) || !!status.string_borrow_vars?.has(dec.name);
+		const value_is_heap_string = dec.type.name === "string" && (dec.value?.node_type === "access" && dec.value.access.node_type === "access_func" || dec.value?.node_type === "func_call");
+		const dec_value = dec.value;
+		const dec_val_is_string_literal = dec.value?.node_type === "value" && dec_value.value.length >= 2 && dec_value.value.startsWith("\"") && dec_value.value.endsWith("\"");
+		const dec_val_is_heap_string_var = dec.value?.node_type === "value" && !dec_val_is_string_literal && !!status.scoped_declarations.find((d) => d.name === dec_value.value);
+		const was_strdup_string_var = dec.declaration === "var" && !dec.type.is_view && !is_borrowed_string && (dec_val_is_string_literal || dec_val_is_heap_string_var);
+		const is_normalized_join_string = !!status.string_join_owned_vars?.has(dec.name);
+		const dec_struct = status.structs.find((s) => s.name === dec.type.name);
+		const is_class_var = !!dec_struct?.is_class;
+		const trait_class_trait = status.trait_class_locals?.get(dec.name);
+		if (trait_class_trait !== void 0 && !is_destructured_field_access) {
+			if (!commented) {
+				status.code += "\n// Auto-free\n";
+				commented = true;
+			}
+			if (dec.type.is_nullable) status.code += `if (${dec.name}) { ${trait_class_trait}_destroy(${dec.name}); free(${dec.name}); }\n`;
+			else status.code += `${trait_class_trait}_destroy(${dec.name}); free(${dec.name});\n`;
+		}
+		if (!is_destructured_field_access && !is_borrowed_string && (!dec.type.is_static || value_is_heap_string || was_strdup_string_var || is_normalized_join_string) && dec.type.name === "string" && !dec.type.is_array) {
+			if (!commented) {
+				status.code += "\n// Auto-free\n";
+				commented = true;
+			}
+			status.code += `free(${dec.name});\n`;
+		}
+		if (!is_destructured_field_access && is_class_var && !dec.type.is_array) {
+			if (!commented) {
+				status.code += "\n// Auto-free\n";
+				commented = true;
+			}
+			const cls = struct ?? dec_struct;
+			const mono_cls_name = cls ? mono_type_name(dec.type) : void 0;
+			const has_destroy_fn = !!cls?.functions.find((f) => f.name === "#destroy") || !!cls?.is_class;
+			if (cls) {
+				const destroy_call = has_destroy_fn ? `${mono_cls_name}_destroy(${dec.name}); ` : "";
+				if (dec.type.is_nullable) status.code += `if (${dec.name}) { ${destroy_call}free(${dec.name}); }\n`;
+				else status.code += `${destroy_call}free(${dec.name});\n`;
+			} else status.code += `free(${dec.name});\n`;
+		}
+		if (!is_destructured_field_access && !is_class_var && !dec.type.is_array && dec.type.name !== "string") {
+			const mono_name = mono_type_name(dec.type);
+			const struct_type = status.structs.find((s) => s.name === mono_name && !s.is_simple_type && !s.is_generic);
+			if (struct_type && struct_needs_destroy(struct_type, status)) {
+				if (!commented) {
+					status.code += "\n// Auto-free\n";
+					commented = true;
+				}
+				emit_struct_destroys(status, struct_type, dec.name);
+			}
+		}
+		if (!!status.traits.find((t) => t.name === dec.type.name) && !is_destructured_field_access && !dec.type.is_array && dec.value) {
+			const val_type = type_from_value_node$1(dec.value);
+			const concrete = val_type?.name ? status.structs.find((s) => s.name === val_type.name && !s.is_simple_type && !s.is_generic) : void 0;
+			if (concrete && struct_needs_destroy(concrete, status)) {
+				if (!commented) {
+					status.code += "\n// Auto-free\n";
+					commented = true;
+				}
+				emit_struct_destroys(status, concrete, dec.name);
+			}
+		}
+		if (!is_destructured_field_access && !is_class_var && !dec.type.is_array && is_nullable_struct_type(dec.type, status)) {
+			const inner = status.structs.find((s) => s.name === dec.type.name);
+			if (inner && struct_needs_destroy(inner, status)) {
+				if (!commented) {
+					status.code += "\n// Auto-free\n";
+					commented = true;
+				}
+				const body = capture_destroys(status, inner, dec.name, ".");
+				status.code += `if (${has_flag_name(dec.name)}) { ${body} }\n`;
+			}
+		}
+		if (!is_destructured_field_access && dec.type.is_array && status.heap_array_vars?.has(dec.name)) {
+			if (!commented) {
+				status.code += "\n// Auto-free\n";
+				commented = true;
+			}
+			const elem_name = dec.type.name;
+			const elem_is_class = !!status.structs.find((s) => s.name === elem_name)?.is_class;
+			const elem_is_string = elem_name === "string";
+			const elem_c_type = elem_is_class ? `struct ${elem_name}*` : elem_name;
+			if (elem_is_class) {
+				status.code += `for (long _i = 0; _i < ${dec.name}->length; _i++) {\n`;
+				status.code += `\t${elem_c_type}* _data = (${elem_c_type}*)((char*)${dec.name} + sizeof(struct Array_${elem_name}));\n`;
+				status.code += `\t${elem_name}_destroy(_data[_i]); free(_data[_i]);\n`;
+				status.code += `}\n`;
+			} else if (elem_is_string) {
+				status.code += `for (long _i = 0; _i < ${dec.name}->length; _i++) {\n`;
+				status.code += `\tchar** _data = (char**)((char*)${dec.name} + sizeof(struct Array_string));\n`;
+				status.code += `\tfree(_data[_i]);\n`;
+				status.code += `}\n`;
+			}
+			status.code += `free(${dec.name});\n`;
+		}
+		if (!is_destructured_field_access && dec.type.is_array && status.stack_array_vars?.has(dec.name)) {
+			if (!commented) {
+				status.code += "\n// Auto-free\n";
+				commented = true;
+			}
+			const elem_name = dec.type.name;
+			const elem_struct = status.structs.find((s) => s.name === elem_name);
+			const elem_is_class = !!elem_struct?.is_class;
+			const elem_is_string = elem_name === "string";
+			const elem_struct_type = status.structs.find((s) => s.name === elem_name && !s.is_simple_type && !s.is_generic);
+			const arr_len = status.stack_array_lengths?.get(dec.name) ?? "0";
+			if (elem_is_string) status.code += `for (long _i = 0; _i < ${arr_len}; _i++) { free(${dec.name}[_i]); }\n`;
+			else if (elem_is_class) {
+				if (has_destroy(elem_struct)) status.code += `for (long _i = 0; _i < ${arr_len}; _i++) { if (${dec.name}[_i]) { ${elem_name}_destroy(${dec.name}[_i]); free(${dec.name}[_i]); } }\n`;
+				else status.code += `for (long _i = 0; _i < ${arr_len}; _i++) { free(${dec.name}[_i]); }\n`;
+			} else if (elem_struct_type && struct_needs_destroy(elem_struct_type, status)) {
+				status.code += `for (long _i = 0; _i < ${arr_len}; _i++) {\n`;
+				emit_struct_destroys(status, elem_struct_type, `${dec.name}[_i]`);
+				status.code += `}\n`;
+			}
+		}
+	}
+}
+/** Name-based variant of struct_needs_destroy for callers without the StructNode. */
+function struct_needs_destroy_by_name(name, status) {
+	const struct = status.structs.find((s) => s.name === name && !s.is_simple_type && !s.is_generic);
+	if (!struct) return false;
+	return struct_needs_destroy(struct, status);
+}
+/**
+* Emit destroy calls for a struct variable at scope exit. Calls the struct's
+* own `#destroy` first (if any), then walks each field: class-typed fields
+* are destroyed + freed (pointer); nested struct fields are recursively
+* destroyed via their own `#destroy`. Mirrors aarch64's
+* `emit_destroy_for_decl` + `emit_field_destroys`.
+*/
+function emit_struct_destroys(status, struct, var_expr) {
+	if (has_destroy(struct)) status.code += `${struct.name}_destroy(&${var_expr});\n`;
+	for (const field of struct.fields) {
+		if (field.type.is_ref) continue;
+		const field_struct = resolve_struct_type(field.type, status);
+		if (!field_struct) continue;
+		const field_expr = `${var_expr}.${field.name}`;
+		if (field_struct.is_class) {
+			if (has_destroy(field_struct)) status.code += `if (${field_expr}) { ${field_struct.name}_destroy(${field_expr}); free(${field_expr}); }\n`;
+		} else if (is_nullable_struct_type(field.type, status)) {
+			if (struct_needs_destroy(field_struct, status)) {
+				const body = capture_destroys(status, field_struct, field_expr, ".");
+				status.code += `if (${field_expr}_has) { ${body} }\n`;
+			}
+		} else emit_struct_destroys(status, field_struct, field_expr);
+	}
+}
+/**
+* Capture the destroy calls for a struct value as a single line (no trailing
+* newline) so it can be embedded inside an `if (...) { ... }` guard. Uses
+* `accessor` (`.` or `->`) for nested field expressions — `.` for by-value
+* locals/fields, `->` when the container is a class pointer.
+*/
+function capture_destroys(status, struct, var_expr, accessor) {
+	const before = status.code.length;
+	if (has_destroy(struct)) status.code += `${struct.name}_destroy(&${var_expr}); `;
+	for (const field of struct.fields) {
+		if (field.type.is_ref) continue;
+		const field_struct = resolve_struct_type(field.type, status);
+		if (!field_struct) continue;
+		const field_expr = `${var_expr}${accessor}${field.name}`;
+		if (field_struct.is_class) {
+			if (has_destroy(field_struct)) status.code += `if (${field_expr}) { ${field_struct.name}_destroy(${field_expr}); free(${field_expr}); } `;
+		} else if (is_nullable_struct_type(field.type, status)) {
+			if (struct_needs_destroy(field_struct, status)) {
+				const inner_before = status.code.length;
+				capture_destroys(status, field_struct, field_expr, accessor);
+				const inner_body = status.code.substring(inner_before).trim();
+				status.code = status.code.substring(0, inner_before);
+				status.code += `if (${field_expr}_has) { ${inner_body} } `;
+			}
+		} else capture_destroys(status, field_struct, field_expr, accessor);
+	}
+	const captured = status.code.substring(before).replace(/\s+/g, " ").trim();
+	status.code = status.code.substring(0, before);
+	return captured;
+}
+//#endregion
+//#region ../src/build_c/utils/c_scope.ts
+/**
+* Begin a new C scope frame: allocate a fresh declarations array, push it onto
+* c_scope_stack, and make it the active scoped_declarations. Returns the frame
+* so the caller can assign it to status.scoped_declarations (mirroring the
+* existing save/restore idiom). Pair with leave_c_scope at scope exit.
+*/
+function enter_c_scope(status) {
+	const frame = [];
+	if (!status.c_scope_stack) status.c_scope_stack = [];
+	status.c_scope_stack.push(frame);
+	return frame;
+}
+/** Pop the current scope frame from c_scope_stack (scope-exit counterpart to enter_c_scope). */
+function leave_c_scope(status) {
+	status.c_scope_stack?.pop();
+}
+/**
+* Find a declaration by name in the active scope frame or any enclosing frame
+* on c_scope_stack (innermost frame first, so a shadowing inner declaration
+* wins). Returns the owning frame and the declaration's index, so a mov site
+* can resolve and splice a declaration living in an OUTER scope — a `mov`
+* inside an if/loop branch must still transfer ownership of variables
+* declared before the branch (mirrors aarch64's all_scope_frames).
+*/
+function find_decl_in_c_scopes(status, name) {
+	const stack = status.c_scope_stack ?? [];
+	for (let i = stack.length - 1; i >= 0; i--) {
+		const index = stack[i].findIndex((d) => d.name === name);
+		if (index !== -1) return {
+			frame: stack[i],
+			index
+		};
+	}
+	const index = status.scoped_declarations.findIndex((d) => d.name === name);
+	return index === -1 ? void 0 : {
+		frame: status.scoped_declarations,
+		index
+	};
+}
+/**
+* Splice a declaration out of whichever scope frame holds it (the current
+* frame or an enclosing frame on c_scope_stack). Used at ownership-transfer
+* sites (`mov` args, alias moves) — without this, a declaration left in an
+* outer frame is reclaimed by that scope's exit cleanup even though the
+* callee/new owner now owns the value (latent double-free).
+*/
+function splice_decl_from_c_scopes(status, name) {
+	const hit = find_decl_in_c_scopes(status, name);
+	return hit ? hit.frame.splice(hit.index, 1)[0] : void 0;
+}
+/**
+* Mark the current top frame as a loop body, so break/continue know how far up
+* the scope stack to reclaim. Call AFTER entering the loop body scope.
+*/
+function push_c_loop_frame(status) {
+	if (!status.c_scope_stack?.length) return;
+	if (!status.c_loop_frame_depth) status.c_loop_frame_depth = [];
+	status.c_loop_frame_depth.push(status.c_scope_stack.length - 1);
+}
+function pop_c_loop_frame(status) {
+	status.c_loop_frame_depth?.pop();
+}
+/**
+* Reclaim declarations from every scope frame on c_scope_stack — a `return`
+* exits ALL enclosing scopes up to the function boundary, not just the
+* current one, so declarations living in outer frames (e.g. a class instance
+* declared before an `if (...) { ... return }`) must be freed before the
+* jump. Nothing is cleared: sibling return statements and the fall-through
+* path are mutually exclusive at runtime but are ALL emitted, so every path
+* needs its own copy of the frees (the function-tail scope-exit auto_free
+* serves the fall-through). Deferred frees are handled like build_auto_free.
+*/
+function reclaim_all_c_scopes(status) {
+	const stack = status.c_scope_stack;
+	if (!stack?.length) free_scoped_declarations(status, status.scoped_declarations, true);
+	else for (const frame of stack) free_scoped_declarations(status, frame, true);
+	if (status.deferred_frees?.length) {
+		status.code += "\n// Deferred frees\n";
+		for (const d of status.deferred_frees) if (d.is_nullable) status.code += `if (${d.temp}) { ${d.struct_name}_destroy(${d.temp}); free(${d.temp}); }\n`;
+		else status.code += `${d.struct_name}_destroy(${d.temp}); free(${d.temp});\n`;
+	}
+}
+/**
+* Reclaim declarations from every frame between the current scope and the
+* innermost loop's body frame (inclusive), then return the loop body index.
+* Used by break/continue: the freed declarations' scope-exit auto_free either
+* runs on the (mutually exclusive) non-jump path or is dead code after the
+* jump, so this never double-frees. The innermost frame is cleared afterwards
+* so its dead post-jump auto_free emits nothing.
+*/
+function reclaim_to_loop_body(status) {
+	const stack = status.c_scope_stack;
+	const loopDepth = status.c_loop_frame_depth;
+	if (!stack?.length || !loopDepth?.length) return void 0;
+	const loopBodyIdx = loopDepth[loopDepth.length - 1];
+	for (let i = stack.length - 1; i >= loopBodyIdx; i--) free_scoped_declarations(status, stack[i]);
+	stack[stack.length - 1].length = 0;
+	return loopBodyIdx;
+}
+//#endregion
+//#region ../src/build_c/build_access_node.ts
+/**
+* The C type of a single element of a `view T` slice, used to cast the
+* universal `nomen_view.ptr` for `.at`/`.set`. `view string`'s element is a
+* `char`; every other view's element is its own type name.
 */
 function view_element_c_type(view_type, status) {
 	const elem_name = view_type.name === "string" ? "char" : view_type.name;
@@ -12591,7 +13391,9 @@ function build_access_node(node, status) {
 					const specialized = status.structs.find((s) => s.name.startsWith(sname) && !s.is_generic && s.functions.find((f) => f.name === access_func.name));
 					if (specialized) mono_struct_name = specialized.name;
 				}
-				const target_method = (mono_struct_name ? status.structs.find((s) => s.name === mono_struct_name && !s.is_generic) : void 0)?.functions.find((f) => f.name === access_func.name);
+				const target_struct_for_method = mono_struct_name ? status.structs.find((s) => s.name === mono_struct_name && !s.is_generic) : void 0;
+				const target_method = target_struct_for_method?.functions.find((f) => f.name === access_func.name);
+				if (node.target.node_type === "value" && target_struct_for_method && !target_struct_for_method.is_class && target_method) drop_self_written_string_field_records(status, node.target.value, scan_self_string_field_writes(target_struct_for_method, target_method));
 				const self_offset = target_method?.params?.some((p) => p.is_self_param) ? 1 : 0;
 				let trait_default_label = "";
 				if (mono_struct_name && !access_func.mangled_name) {
@@ -12647,9 +13449,20 @@ function build_access_node(node, status) {
 				const param = access_func.params[idx];
 				if (param?.node_type === "value") {
 					const vname = param.value;
-					const di = status.scoped_declarations.findIndex((d) => d.name === vname);
-					if ((di !== -1 ? status.scoped_declarations[di].type?.name : param.type?.name) === "string") continue;
-					if (di !== -1) status.scoped_declarations.splice(di, 1);
+					const decl_hit = find_decl_in_c_scopes(status, vname);
+					const tname = decl_hit?.frame[decl_hit.index].type?.name ?? param.type?.name;
+					if (tname === "string") continue;
+					const decl_struct = decl_hit ? status.structs.find((s) => s.name === tname && !s.is_simple_type) : void 0;
+					const is_value_struct = !!decl_struct && !decl_struct.is_class;
+					if (decl_hit) decl_hit.frame.splice(decl_hit.index, 1);
+					if (is_value_struct) {
+						const prefix = `${vname}.`;
+						for (const key of Array.from(status.heap_string_fields ?? [])) if (key.startsWith(prefix)) {
+							if (!status.pending_string_releases) status.pending_string_releases = [];
+							status.pending_string_releases.push(`free(${key});`);
+							status.heap_string_fields.delete(key);
+						}
+					}
 				}
 			}
 			break;
@@ -12667,312 +13480,80 @@ function resolve_access_field_type(node, status) {
 		else if (name === "self" && status.current_struct) base_type = new Type(status.current_struct.name);
 		else if (status.variable_types?.has(name)) base_type = status.variable_types.get(name);
 	} else if (node.target.node_type === "access") base_type = resolve_access_field_type(node.target, status);
-	if (!base_type?.name) return void 0;
-	return (status.structs.find((s) => s.name === base_type.name && !s.is_simple_type)?.fields.find((f) => f.name === field_name))?.type;
-}
-function emit_string_length(target, status) {
-	if (is_owned_heap_temp(target, status)) {
-		const id = status.label_counter = (status.label_counter ?? 0) + 1;
-		const tmp = `_slen_${id}`;
-		status.code += `({ char* ${tmp} = `;
-		build_node(target, status);
-		status.code += `; long _slr_${id} = (long)strlen(${tmp}); free(${tmp}); _slr_${id}; })`;
-		return;
-	}
-	status.code += "((long)strlen(";
-	build_node(target, status);
-	status.code += "))";
-}
-/**
-* Resolve the type of an access-chain expression by walking through the
-* monomorphized structs (field types and method return types). Used when a
-* cached node type is stale (a generic type param like "T" that wasn't
-* substituted because it belonged to a nested generic, not the enclosing one).
-*/
-function resolve_access_type(node, status) {
-	const inner = node.access;
-	if (inner.node_type === "access_func") {
-		const access_func = inner;
-		let base_type = resolve_receiver_type(node.target, status);
-		if (!base_type?.name) return null;
-		const mono_name = mono_type_name(base_type);
-		const struct = status.structs.find((s) => s.name === mono_name && !s.is_generic) || status.structs.find((s) => s.name === base_type.name);
-		if (!struct) return null;
-		return struct.functions.find((f) => f.name === access_func.name || f.name === `#${access_func.name}`)?.return_type || null;
-	}
-	if (inner.node_type !== "access_field") return null;
-	const field_name = inner.name;
-	let base_type = resolve_receiver_type(node.target, status);
-	if (!base_type?.name) return null;
-	const struct = status.structs.find((s) => s.name === base_type.name);
-	if (!struct) return null;
-	return struct.fields.find((f) => f.name === field_name)?.type || null;
-}
-function resolve_receiver_type(node, status) {
-	if (node.node_type === "value") {
-		const name = node.value;
-		const vtype = node.type;
-		if (vtype?.name && status.structs.find((s) => s.name === vtype.name)) return vtype;
-		if (name === "self" && status.current_struct) return new Type(status.current_struct.name);
-		return vtype?.name ? vtype : null;
-	}
-	if (node.node_type === "access") {
-		const resolved = resolve_access_type(node, status);
-		if (resolved) return resolved;
-		return type_from_value_node$1(node);
-	}
-	return null;
-}
-//#endregion
-//#region ../src/build_c/build_array_values_node.ts
-function build_array_values_node(node, status) {
-	status.code += `{`;
-	const elem_is_string = node.type?.name === "string";
-	node.values.forEach((value, i) => {
-		if (i > 0) status.code += ", ";
-		if (elem_is_string && value.node_type === "value" && value.value.length >= 2 && value.value.startsWith("\"") && value.value.endsWith("\"")) {
-			status.code += `nomen_strdup_wrap(`;
-			build_node(value, status);
-			status.code += `)`;
-		} else build_node(value, status);
-	});
-	status.code += `}`;
-}
-//#endregion
-//#region ../src/build_c/utils/is_string_borrow.ts
-/**
-* Whether a value node denotes a BORROWED string — a pointer into storage the
-* receiver does not own (an array element accessed via `.at()`/`.first()`, or
-* `init.args.at(n)` which points into the C runtime's `argv`). Borrowed
-* strings must NOT be freed by auto_free or by reassignment: freeing them
-* reclaims memory owned by the container (or argv), crashing with
-* "pointer being freed was not allocated". Mirrors aarch64's `heap_strings`
-* ownership tracking, which only frees freshly-allocated strings.
-*/
-function is_string_borrow(node) {
-	if (!node || node.node_type !== "access") return false;
-	const access = node.access;
-	if (access.node_type !== "access_func") return false;
-	const func = access;
-	return (func.name === "at" || func.name === "first") && !func.owned_return;
-}
-//#endregion
-//#region ../src/build_c/build_auto_free.ts
-function build_auto_free(status) {
-	free_scoped_declarations(status, status.scoped_declarations);
-	if (status.deferred_frees?.length) {
-		status.code += "\n// Deferred frees\n";
-		for (const d of status.deferred_frees) if (d.is_nullable) status.code += `if (${d.temp}) { ${d.struct_name}_destroy(${d.temp}); free(${d.temp}); }\n`;
-		else status.code += `${d.struct_name}_destroy(${d.temp}); free(${d.temp});\n`;
-		status.deferred_frees.length = 0;
-	}
-	status.scoped_declarations = [];
-}
-/**
-* Emit scope-exit free/destroy code for a list of declarations. Extracted from
-* build_auto_free so that break/continue can reclaim declarations from the
-* current scope AND enclosing scopes (up to the loop body) before jumping —
-* see build_break_node. Does NOT process deferred_frees or clear the list
-* (those are scope-exit-only concerns handled by build_auto_free).
-*/
-function free_scoped_declarations(status, decls) {
-	let commented = false;
-	for (const dec of decls) {
-		const struct = status.structs.find((s) => s.name === dec.type.name);
-		if (struct && struct.traits.includes("Disposable")) {
-			const trait = status.traits.find((t) => t.name === "Disposable");
-			const func = trait?.functions.find((f) => f.name == "dispose");
-			if (trait && func) {
-				if (!commented) {
-					status.code += "\n// Auto-free\n";
-					commented = true;
-				}
-				const cast = "(void *(*)(void *))";
-				const traitIndex = status.traits.indexOf(trait);
-				const funcIndex = trait.functions.indexOf(func);
-				status.code += `(${cast}_get_trait_func((void *)&${dec.name}, ${traitIndex}, ${funcIndex}))(&${dec.name});\n`;
-			}
-		}
-		const is_destructured_field_access = dec.value?.node_type === "access" && dec.value.access.node_type === "access_field" && !dec.value.is_moved;
-		const is_borrowed_string = is_string_borrow(dec.value) || !!status.string_borrow_vars?.has(dec.name);
-		const value_is_heap_string = dec.type.name === "string" && (dec.value?.node_type === "access" && dec.value.access.node_type === "access_func" || dec.value?.node_type === "func_call");
-		const dec_value = dec.value;
-		const dec_val_is_string_literal = dec.value?.node_type === "value" && dec_value.value.length >= 2 && dec_value.value.startsWith("\"") && dec_value.value.endsWith("\"");
-		const dec_val_is_heap_string_var = dec.value?.node_type === "value" && !dec_val_is_string_literal && !!status.scoped_declarations.find((d) => d.name === dec_value.value);
-		const was_strdup_string_var = dec.declaration === "var" && !dec.type.is_view && !is_borrowed_string && (dec_val_is_string_literal || dec_val_is_heap_string_var);
-		const is_normalized_join_string = !!status.string_join_owned_vars?.has(dec.name);
-		const dec_struct = status.structs.find((s) => s.name === dec.type.name);
-		const is_class_var = !!dec_struct?.is_class;
-		const trait_class_trait = status.trait_class_locals?.get(dec.name);
-		if (trait_class_trait !== void 0 && !is_destructured_field_access) {
-			if (!commented) {
-				status.code += "\n// Auto-free\n";
-				commented = true;
-			}
-			if (dec.type.is_nullable) status.code += `if (${dec.name}) { ${trait_class_trait}_destroy(${dec.name}); free(${dec.name}); }\n`;
-			else status.code += `${trait_class_trait}_destroy(${dec.name}); free(${dec.name});\n`;
-		}
-		if (!is_destructured_field_access && !is_borrowed_string && (!dec.type.is_static || value_is_heap_string || was_strdup_string_var || is_normalized_join_string) && dec.type.name === "string" && !dec.type.is_array) {
-			if (!commented) {
-				status.code += "\n// Auto-free\n";
-				commented = true;
-			}
-			status.code += `free(${dec.name});\n`;
-		}
-		if (!is_destructured_field_access && is_class_var && !dec.type.is_array) {
-			if (!commented) {
-				status.code += "\n// Auto-free\n";
-				commented = true;
-			}
-			const cls = struct ?? dec_struct;
-			const mono_cls_name = cls ? mono_type_name(dec.type) : void 0;
-			const has_destroy_fn = !!cls?.functions.find((f) => f.name === "#destroy") || !!cls?.is_class;
-			if (cls) {
-				const destroy_call = has_destroy_fn ? `${mono_cls_name}_destroy(${dec.name}); ` : "";
-				if (dec.type.is_nullable) status.code += `if (${dec.name}) { ${destroy_call}free(${dec.name}); }\n`;
-				else status.code += `${destroy_call}free(${dec.name});\n`;
-			} else status.code += `free(${dec.name});\n`;
-		}
-		if (!is_destructured_field_access && !is_class_var && !dec.type.is_array && dec.type.name !== "string") {
-			const mono_name = mono_type_name(dec.type);
-			const struct_type = status.structs.find((s) => s.name === mono_name && !s.is_simple_type && !s.is_generic);
-			if (struct_type && struct_needs_destroy(struct_type, status)) {
-				if (!commented) {
-					status.code += "\n// Auto-free\n";
-					commented = true;
-				}
-				emit_struct_destroys(status, struct_type, dec.name);
-			}
-		}
-		if (!!status.traits.find((t) => t.name === dec.type.name) && !is_destructured_field_access && !dec.type.is_array && dec.value) {
-			const val_type = type_from_value_node$1(dec.value);
-			const concrete = val_type?.name ? status.structs.find((s) => s.name === val_type.name && !s.is_simple_type && !s.is_generic) : void 0;
-			if (concrete && struct_needs_destroy(concrete, status)) {
-				if (!commented) {
-					status.code += "\n// Auto-free\n";
-					commented = true;
-				}
-				emit_struct_destroys(status, concrete, dec.name);
-			}
-		}
-		if (!is_destructured_field_access && !is_class_var && !dec.type.is_array && is_nullable_struct_type(dec.type, status)) {
-			const inner = status.structs.find((s) => s.name === dec.type.name);
-			if (inner && struct_needs_destroy(inner, status)) {
-				if (!commented) {
-					status.code += "\n// Auto-free\n";
-					commented = true;
-				}
-				const body = capture_destroys(status, inner, dec.name, ".");
-				status.code += `if (${has_flag_name(dec.name)}) { ${body} }\n`;
-			}
-		}
-		if (!is_destructured_field_access && dec.type.is_array && status.heap_array_vars?.has(dec.name)) {
-			if (!commented) {
-				status.code += "\n// Auto-free\n";
-				commented = true;
-			}
-			const elem_name = dec.type.name;
-			const elem_is_class = !!status.structs.find((s) => s.name === elem_name)?.is_class;
-			const elem_is_string = elem_name === "string";
-			const elem_c_type = elem_is_class ? `struct ${elem_name}*` : elem_name;
-			if (elem_is_class) {
-				status.code += `for (long _i = 0; _i < ${dec.name}->length; _i++) {\n`;
-				status.code += `\t${elem_c_type}* _data = (${elem_c_type}*)((char*)${dec.name} + sizeof(struct Array_${elem_name}));\n`;
-				status.code += `\t${elem_name}_destroy(_data[_i]); free(_data[_i]);\n`;
-				status.code += `}\n`;
-			} else if (elem_is_string) {
-				status.code += `for (long _i = 0; _i < ${dec.name}->length; _i++) {\n`;
-				status.code += `\tchar** _data = (char**)((char*)${dec.name} + sizeof(struct Array_string));\n`;
-				status.code += `\tfree(_data[_i]);\n`;
-				status.code += `}\n`;
-			}
-			status.code += `free(${dec.name});\n`;
-		}
-		if (!is_destructured_field_access && dec.type.is_array && status.stack_array_vars?.has(dec.name)) {
-			if (!commented) {
-				status.code += "\n// Auto-free\n";
-				commented = true;
-			}
-			const elem_name = dec.type.name;
-			const elem_struct = status.structs.find((s) => s.name === elem_name);
-			const elem_is_class = !!elem_struct?.is_class;
-			const elem_is_string = elem_name === "string";
-			const elem_struct_type = status.structs.find((s) => s.name === elem_name && !s.is_simple_type && !s.is_generic);
-			const arr_len = status.stack_array_lengths?.get(dec.name) ?? "0";
-			if (elem_is_string) status.code += `for (long _i = 0; _i < ${arr_len}; _i++) { free(${dec.name}[_i]); }\n`;
-			else if (elem_is_class) {
-				if (has_destroy(elem_struct)) status.code += `for (long _i = 0; _i < ${arr_len}; _i++) { if (${dec.name}[_i]) { ${elem_name}_destroy(${dec.name}[_i]); free(${dec.name}[_i]); } }\n`;
-				else status.code += `for (long _i = 0; _i < ${arr_len}; _i++) { free(${dec.name}[_i]); }\n`;
-			} else if (elem_struct_type && struct_needs_destroy(elem_struct_type, status)) {
-				status.code += `for (long _i = 0; _i < ${arr_len}; _i++) {\n`;
-				emit_struct_destroys(status, elem_struct_type, `${dec.name}[_i]`);
-				status.code += `}\n`;
-			}
-		}
-	}
+	if (!base_type?.name) return void 0;
+	return (status.structs.find((s) => s.name === base_type.name && !s.is_simple_type)?.fields.find((f) => f.name === field_name))?.type;
 }
-/** Name-based variant of struct_needs_destroy for callers without the StructNode. */
-function struct_needs_destroy_by_name(name, status) {
-	const struct = status.structs.find((s) => s.name === name && !s.is_simple_type && !s.is_generic);
-	if (!struct) return false;
-	return struct_needs_destroy(struct, status);
+function emit_string_length(target, status) {
+	if (is_owned_heap_temp(target, status)) {
+		const id = status.label_counter = (status.label_counter ?? 0) + 1;
+		const tmp = `_slen_${id}`;
+		status.code += `({ char* ${tmp} = `;
+		build_node(target, status);
+		status.code += `; long _slr_${id} = (long)strlen(${tmp}); free(${tmp}); _slr_${id}; })`;
+		return;
+	}
+	status.code += "((long)strlen(";
+	build_node(target, status);
+	status.code += "))";
 }
 /**
-* Emit destroy calls for a struct variable at scope exit. Calls the struct's
-* own `#destroy` first (if any), then walks each field: class-typed fields
-* are destroyed + freed (pointer); nested struct fields are recursively
-* destroyed via their own `#destroy`. Mirrors aarch64's
-* `emit_destroy_for_decl` + `emit_field_destroys`.
+* Resolve the type of an access-chain expression by walking through the
+* monomorphized structs (field types and method return types). Used when a
+* cached node type is stale (a generic type param like "T" that wasn't
+* substituted because it belonged to a nested generic, not the enclosing one).
 */
-function emit_struct_destroys(status, struct, var_expr) {
-	if (has_destroy(struct)) status.code += `${struct.name}_destroy(&${var_expr});\n`;
-	for (const field of struct.fields) {
-		if (field.type.is_ref) continue;
-		const field_struct = resolve_struct_type(field.type, status);
-		if (!field_struct) continue;
-		const field_expr = `${var_expr}.${field.name}`;
-		if (field_struct.is_class) {
-			if (has_destroy(field_struct)) status.code += `if (${field_expr}) { ${field_struct.name}_destroy(${field_expr}); free(${field_expr}); }\n`;
-		} else if (is_nullable_struct_type(field.type, status)) {
-			if (struct_needs_destroy(field_struct, status)) {
-				const body = capture_destroys(status, field_struct, field_expr, ".");
-				status.code += `if (${field_expr}_has) { ${body} }\n`;
-			}
-		} else emit_struct_destroys(status, field_struct, field_expr);
+function resolve_access_type(node, status) {
+	const inner = node.access;
+	if (inner.node_type === "access_func") {
+		const access_func = inner;
+		let base_type = resolve_receiver_type(node.target, status);
+		if (!base_type?.name) return null;
+		const mono_name = mono_type_name(base_type);
+		const struct = status.structs.find((s) => s.name === mono_name && !s.is_generic) || status.structs.find((s) => s.name === base_type.name);
+		if (!struct) return null;
+		return struct.functions.find((f) => f.name === access_func.name || f.name === `#${access_func.name}`)?.return_type || null;
 	}
+	if (inner.node_type !== "access_field") return null;
+	const field_name = inner.name;
+	let base_type = resolve_receiver_type(node.target, status);
+	if (!base_type?.name) return null;
+	const struct = status.structs.find((s) => s.name === base_type.name);
+	if (!struct) return null;
+	return struct.fields.find((f) => f.name === field_name)?.type || null;
 }
-/**
-* Capture the destroy calls for a struct value as a single line (no trailing
-* newline) so it can be embedded inside an `if (...) { ... }` guard. Uses
-* `accessor` (`.` or `->`) for nested field expressions — `.` for by-value
-* locals/fields, `->` when the container is a class pointer.
-*/
-function capture_destroys(status, struct, var_expr, accessor) {
-	const before = status.code.length;
-	if (has_destroy(struct)) status.code += `${struct.name}_destroy(&${var_expr}); `;
-	for (const field of struct.fields) {
-		if (field.type.is_ref) continue;
-		const field_struct = resolve_struct_type(field.type, status);
-		if (!field_struct) continue;
-		const field_expr = `${var_expr}${accessor}${field.name}`;
-		if (field_struct.is_class) {
-			if (has_destroy(field_struct)) status.code += `if (${field_expr}) { ${field_struct.name}_destroy(${field_expr}); free(${field_expr}); } `;
-		} else if (is_nullable_struct_type(field.type, status)) {
-			if (struct_needs_destroy(field_struct, status)) {
-				const inner_before = status.code.length;
-				capture_destroys(status, field_struct, field_expr, accessor);
-				const inner_body = status.code.substring(inner_before).trim();
-				status.code = status.code.substring(0, inner_before);
-				status.code += `if (${field_expr}_has) { ${inner_body} } `;
-			}
-		} else capture_destroys(status, field_struct, field_expr, accessor);
+function resolve_receiver_type(node, status) {
+	if (node.node_type === "value") {
+		const name = node.value;
+		const vtype = node.type;
+		if (vtype?.name && status.structs.find((s) => s.name === vtype.name)) return vtype;
+		if (name === "self" && status.current_struct) return new Type(status.current_struct.name);
+		return vtype?.name ? vtype : null;
 	}
-	const captured = status.code.substring(before).replace(/\s+/g, " ").trim();
-	status.code = status.code.substring(0, before);
-	return captured;
+	if (node.node_type === "access") {
+		const resolved = resolve_access_type(node, status);
+		if (resolved) return resolved;
+		return type_from_value_node$1(node);
+	}
+	return null;
+}
+//#endregion
+//#region ../src/build_c/build_array_values_node.ts
+function build_array_values_node(node, status) {
+	status.code += `{`;
+	const elem_is_string = node.type?.name === "string";
+	node.values.forEach((value, i) => {
+		if (i > 0) status.code += ", ";
+		if (elem_is_string && value.node_type === "value" && value.value.length >= 2 && value.value.startsWith("\"") && value.value.endsWith("\"")) {
+			status.code += `nomen_strdup_wrap(`;
+			build_node(value, status);
+			status.code += `)`;
+		} else build_node(value, status);
+	});
+	status.code += `}`;
 }
 //#endregion
 //#region ../src/build_c/build_assignment_node.ts
+let string_field_counter = 0;
 function build_assignment_node(node, status) {
 	if (node.left_value.node_type === "access") {
 		const accessNode = node.left_value;
@@ -13009,26 +13590,53 @@ function build_assignment_node(node, status) {
 				status.code = status.code.substring(0, before_len);
 				if (field_type?.is_nullable) status.code += `if (${field_access}) { ${field_struct.name}_destroy(${field_access}); free(${field_access}); }\n`;
 				else status.code += `${field_struct.name}_destroy(${field_access}); free(${field_access});\n`;
-				if (node.right_value.node_type === "value") {
-					const rhs_name = node.right_value.value;
-					const rhs_idx = status.scoped_declarations.findIndex((d) => d.name === rhs_name);
-					if (rhs_idx !== -1) status.scoped_declarations.splice(rhs_idx, 1);
-				}
+				if (node.right_value.node_type === "value") splice_decl_from_c_scopes(status, node.right_value.value);
+			}
+		}
+	}
+	if (!node.operator && node.left_value.node_type === "access" && node.left_value.access.node_type === "access_field" && node.left_value.access.type?.name === "string" && !node.left_value.access.type?.is_ref && !node.left_value.access.type?.is_array) {
+		const access_lhs = node.left_value;
+		const field_access_node = access_lhs.access;
+		let target_type = type_from_value_node$1(access_lhs.target);
+		if (!target_type?.name && access_lhs.target.node_type === "value" && access_lhs.target.value === "self" && status.current_struct) target_type = new Type(status.current_struct.name);
+		const target_struct = target_type?.name ? status.structs.find((s) => s.name === target_type.name && !s.is_simple_type) : null;
+		const target_var = access_lhs.target.node_type === "value" ? access_lhs.target.value : "";
+		const self_target = target_var === "self";
+		const tracked_key = `${target_var}.${field_access_node.name}`;
+		const old_was_heap = !!target_struct?.is_class || !!status.heap_string_fields?.has(tracked_key);
+		if (target_struct && target_var && (!self_target || target_struct.is_class)) {
+			const fresh_heap = is_owned_heap_temp(node.right_value, status);
+			const before_len = status.code.length;
+			build_node(node.left_value, status);
+			const field_access = status.code.substring(before_len);
+			status.code = status.code.substring(0, before_len);
+			const temp = `_nomen_strfield_${string_field_counter++}`;
+			status.code += `{\nchar* ${temp} = `;
+			if (fresh_heap) build_node(node.right_value, status);
+			else {
+				status.code += `strdup(`;
+				build_node(node.right_value, status);
+				status.code += `)`;
+			}
+			status.code += `;\n`;
+			if (old_was_heap) status.code += `free(${field_access});\n`;
+			status.code += `${field_access} = ${temp};\n}\n`;
+			if (!target_struct.is_class) {
+				if (!status.heap_string_fields) status.heap_string_fields = /* @__PURE__ */ new Set();
+				status.heap_string_fields.add(tracked_key);
 			}
+			return;
 		}
 	}
 	if (!node.operator && node.left_value.node_type === "value" && is_string_borrow(node.right_value)) {
 		const lhs_name = node.left_value.value;
-		const lhs_decl = status.scoped_declarations.find((d) => d.name === lhs_name);
-		if ((lhs_decl?.type || status.variable_types?.get(lhs_name))?.name === "string") {
+		const lhs_hit = find_decl_in_c_scopes(status, lhs_name);
+		if (((lhs_hit ? lhs_hit.frame[lhs_hit.index] : void 0)?.type || status.variable_types?.get(lhs_name))?.name === "string") {
 			const was_borrow = !!status.string_borrow_vars?.has(lhs_name);
 			if (!status.string_borrow_vars) status.string_borrow_vars = /* @__PURE__ */ new Set();
 			status.string_borrow_vars.add(lhs_name);
 			if (!was_borrow) {
-				if (lhs_decl) {
-					const idx = status.scoped_declarations.indexOf(lhs_decl);
-					if (idx !== -1) status.scoped_declarations.splice(idx, 1);
-				}
+				if (lhs_hit) lhs_hit.frame.splice(lhs_hit.index, 1);
 				status.code += `free(${lhs_name});\n`;
 			}
 		}
@@ -13113,21 +13721,15 @@ function build_assignment_node(node, status) {
 			}
 			if (rhs_is_bare_value) {
 				if (lhs_is_class) {
-					if (!node.swap) {
-						const rhs_name = rhs.value;
-						const rhs_idx = status.scoped_declarations.findIndex((d) => d.name === rhs_name);
-						if (rhs_idx !== -1) status.scoped_declarations.splice(rhs_idx, 1);
-					}
-				} else if (lhs_decl) {
-					const idx = status.scoped_declarations.indexOf(lhs_decl);
-					if (idx !== -1) status.scoped_declarations.splice(idx, 1);
-				}
+					if (!node.swap) splice_decl_from_c_scopes(status, rhs.value);
+				} else if (lhs_decl) splice_decl_from_c_scopes(status, lhs_name);
 			}
 		}
 	}
 	if (!node.operator && node.left_value.node_type === "value") {
 		const lhs_name = node.left_value.value;
-		const lhs_decl = status.scoped_declarations.find((d) => d.name === lhs_name);
+		const lhs_hit = find_decl_in_c_scopes(status, lhs_name);
+		const lhs_decl = lhs_hit ? lhs_hit.frame[lhs_hit.index] : void 0;
 		if (lhs_decl) {
 			const lhs_struct = lhs_decl.type?.name ? status.structs.find((s) => s.name === lhs_decl.type.name && !s.is_simple_type && !s.is_class) : null;
 			const lhs_mono = lhs_decl.type ? mono_type_name(lhs_decl.type) : void 0;
@@ -13137,9 +13739,7 @@ function build_assignment_node(node, status) {
 				if (rhs.node_type === "value" && rhs.is_moved) {
 					const mov_struct_type = lhs_mono_struct ?? lhs_struct;
 					if (mov_struct_type && struct_needs_destroy_by_name(mov_struct_type.name, status)) emit_struct_destroys(status, mov_struct_type, lhs_name);
-					const rhs_name = rhs.value;
-					const rhs_idx = status.scoped_declarations.findIndex((d) => d.name === rhs_name);
-					if (rhs_idx !== -1) status.scoped_declarations.splice(rhs_idx, 1);
+					splice_decl_from_c_scopes(status, rhs.value);
 				} else {
 					const struct_type = lhs_mono_struct ?? lhs_struct;
 					const needs_destroy = struct_type ? struct_needs_destroy_by_name(struct_type.name, status) : false;
@@ -13148,12 +13748,8 @@ function build_assignment_node(node, status) {
 						if (needs_destroy) emit_struct_destroys(status, struct_type, lhs_name);
 					} else if (is_self_method_call(node, lhs_name)) {} else if (!rhs_references_var(node, lhs_name)) {
 						if (needs_destroy) emit_struct_destroys(status, struct_type, lhs_name);
-						const idx = status.scoped_declarations.indexOf(lhs_decl);
-						if (idx !== -1) status.scoped_declarations.splice(idx, 1);
-					} else {
-						const idx = status.scoped_declarations.indexOf(lhs_decl);
-						if (idx !== -1) status.scoped_declarations.splice(idx, 1);
-					}
+						if (lhs_hit) lhs_hit.frame.splice(lhs_hit.index, 1);
+					} else if (lhs_hit) lhs_hit.frame.splice(lhs_hit.index, 1);
 				}
 			}
 		}
@@ -13450,53 +14046,6 @@ function embedded_value_struct(type, status) {
 	return s;
 }
 //#endregion
-//#region ../src/build_c/utils/c_scope.ts
-/**
-* Begin a new C scope frame: allocate a fresh declarations array, push it onto
-* c_scope_stack, and make it the active scoped_declarations. Returns the frame
-* so the caller can assign it to status.scoped_declarations (mirroring the
-* existing save/restore idiom). Pair with leave_c_scope at scope exit.
-*/
-function enter_c_scope(status) {
-	const frame = [];
-	if (!status.c_scope_stack) status.c_scope_stack = [];
-	status.c_scope_stack.push(frame);
-	return frame;
-}
-/** Pop the current scope frame from c_scope_stack (scope-exit counterpart to enter_c_scope). */
-function leave_c_scope(status) {
-	status.c_scope_stack?.pop();
-}
-/**
-* Mark the current top frame as a loop body, so break/continue know how far up
-* the scope stack to reclaim. Call AFTER entering the loop body scope.
-*/
-function push_c_loop_frame(status) {
-	if (!status.c_scope_stack?.length) return;
-	if (!status.c_loop_frame_depth) status.c_loop_frame_depth = [];
-	status.c_loop_frame_depth.push(status.c_scope_stack.length - 1);
-}
-function pop_c_loop_frame(status) {
-	status.c_loop_frame_depth?.pop();
-}
-/**
-* Reclaim declarations from every frame between the current scope and the
-* innermost loop's body frame (inclusive), then return the loop body index.
-* Used by break/continue: the freed declarations' scope-exit auto_free either
-* runs on the (mutually exclusive) non-jump path or is dead code after the
-* jump, so this never double-frees. The innermost frame is cleared afterwards
-* so its dead post-jump auto_free emits nothing.
-*/
-function reclaim_to_loop_body(status) {
-	const stack = status.c_scope_stack;
-	const loopDepth = status.c_loop_frame_depth;
-	if (!stack?.length || !loopDepth?.length) return void 0;
-	const loopBodyIdx = loopDepth[loopDepth.length - 1];
-	for (let i = stack.length - 1; i >= loopBodyIdx; i--) free_scoped_declarations(status, stack[i]);
-	stack[stack.length - 1].length = 0;
-	return loopBodyIdx;
-}
-//#endregion
 //#region ../src/build_c/utils/owning_buffer_specialize.ts
 /**
 * Detect whether a monomorphized struct is a `Buffer_<T>` whose element type
@@ -13859,7 +14408,11 @@ function build_struct_node(node, status) {
 			status.code += `${object_name}${accessor}${field.name} = *${field.name};\n`;
 			status.code += `${object_name}${accessor}${has_flag_name(field.name)} = ${has_flag_name(field.name)};\n`;
 		} else {
+			const field_is_class_string = is_class && field.type.name === "string" && !field.type.is_array && !field.type.is_ref;
+			const value_is_fresh_heap = !!field.value && is_owned_heap_temp(field.value, status);
+			const wrap_strdup = field_is_class_string && !value_is_fresh_heap;
 			status.code += `${object_name}${accessor}${field.name} = `;
+			if (wrap_strdup) status.code += `strdup(`;
 			if (field.value) build_node(field.value, status);
 			else {
 				const field_struct = status.structs.find((s) => s.name === mono_struct_name(field.type, status) && !s.is_simple_type);
@@ -13867,6 +14420,7 @@ function build_struct_node(node, status) {
 				if (field_struct && !field_struct.is_class || field_trait) status.code += `*`;
 				status.code += field.name;
 			}
+			if (wrap_strdup) status.code += `)`;
 			status.code += ";\n";
 		}
 		for (let traitName of node.traits) {
@@ -13875,7 +14429,10 @@ function build_struct_node(node, status) {
 				status.code += `${object_name}${accessor}${field.name}`;
 				if (field.value) {
 					status.code += " = ";
+					const wrap = is_class && field.type.name === "string" && !field.type.is_array && !field.type.is_ref && !is_owned_heap_temp(field.value, status);
+					if (wrap) status.code += "strdup(";
 					build_node(field.value, status);
+					if (wrap) status.code += ")";
 				}
 				status.code += ";\n";
 			}
@@ -13971,6 +14528,14 @@ function build_struct_functions(node, status, skip_init = false) {
 				} else status.function_ref_params.add(pname);
 			}
 		}
+		for (const param of func.params) {
+			if (param.is_self_param) continue;
+			const param_struct = status.structs.find((s) => s.name === param.type.name);
+			if (param.is_moved && param_struct?.is_class && !moved_param_is_consumed(func, param.name)) {
+				const pname = c_function_name(param.name);
+				status.scoped_declarations.push(new DeclarationNode(param.start, "private", "mov", pname, param.type));
+			}
+		}
 		const func_start = status.code.length;
 		let return_type = func.return_type.name || "void";
 		if (return_type !== node.name && node.name.startsWith(return_type + "_")) return_type = node.name;
@@ -14013,6 +14578,10 @@ function build_struct_functions(node, status, skip_init = false) {
 		}
 		const owning_elem = owning_buffer_element(node, status);
 		if (!(owning_elem && emit_owning_buffer_body(func.name, owning_elem, status) || owning_buffer_is_string_elem(node) && emit_owning_buffer_string_body(func.name, status))) for (let child of func.statements) build_node(child, status, true);
+		if (func.name === "#destroy" && node.is_class) for (const field of node.fields) {
+			if (field.type.is_ref || field.type.is_array) continue;
+			if (field.type.name === "string") status.code += `free(self->${field.name});\n`;
+		}
 		build_auto_free(status);
 		status.code += `}\n`;
 		status.function_ref_params = old_ref_params;
@@ -14048,7 +14617,7 @@ function build_auto_destroy(node, status) {
 	status.code += `${sig}\n{\n`;
 	for (const field of node.fields) {
 		if (field.type.is_ref) continue;
-		if (field.type.name === "string" && !field.type.is_array && !node.is_class) {
+		if (field.type.name === "string" && !field.type.is_array) {
 			status.code += `free(self->${field.name});\n`;
 			continue;
 		}
@@ -14232,7 +14801,7 @@ function build_function_node(node, status) {
 					status.ref_class_param_types.set(pname, param.type);
 				}
 			} else if (!status.heap_array_vars?.has(pname)) status.function_ref_params.add(pname);
-			if (param.is_moved && param_struct?.is_class && node.name !== "main" && !param_is_consumed(node, param.name)) {
+			if (param.is_moved && param_struct?.is_class && node.name !== "main" && !moved_param_is_consumed(node, param.name)) {
 				const decl = new DeclarationNode(param.start, "private", "mov", pname, param.type);
 				status.scoped_declarations.push(decl);
 			}
@@ -14288,34 +14857,6 @@ function emit_nested_declarations(node, status) {
 	for (let child of block.statements) if (is_struct_node(child)) build_struct_node(child, status);
 	for (let child of block.statements) if (is_function_node(child)) build_function_node(child, status);
 }
-function param_is_consumed(root, name) {
-	let consumed = false;
-	const refs_name = (n) => !!n && n.node_type === "value" && n.value === name;
-	const walk = (n) => {
-		if (!n || typeof n !== "object" || consumed) return;
-		if (n.node_type === "func_call") {
-			for (const p of n.params ?? []) if (refs_name(p)) consumed = true;
-		}
-		if (n.node_type === "access") {
-			if (n.access?.node_type === "access_func" && refs_name(n.target)) consumed = true;
-			for (const p of n.access?.params ?? []) if (refs_name(p)) consumed = true;
-		}
-		if (n.node_type === "array") {
-			for (const v of n.values ?? []) if (refs_name(v)) consumed = true;
-		}
-		if (n.node_type === "return" && refs_name(n.value)) consumed = true;
-		if (n.node_type === "assign" && refs_name(n.right_value)) consumed = true;
-		if (n.node_type === "declare" && refs_name(n.value)) consumed = true;
-		for (const key of Object.keys(n)) {
-			if (key === "node_type") continue;
-			const v = n[key];
-			if (Array.isArray(v)) for (const item of v) walk(item);
-			else if (v && typeof v === "object") walk(v);
-		}
-	};
-	for (const stmt of root.statements ?? []) walk(stmt);
-	return consumed;
-}
 //#endregion
 //#region ../src/build_c/utils/emit_allocations.ts
 /**
@@ -14818,7 +15359,8 @@ function build_declaration_node(node, status) {
 			return;
 		}
 		const val_is_owned_return = node.value?.node_type === "access" && node.value.access.node_type === "access_func" && !!node.value.access.owned_return;
-		const val_is_class_alias = is_class_type && (node.value?.node_type === "value" && !!status.class_vars?.has(node.value.value) || node.value?.node_type === "access" && !val_is_owned_return);
+		const val_is_borrowing_call = node.value?.node_type === "func_call" && !!status.borrow_returning_functions?.has(node.value.name);
+		const val_is_class_alias = is_class_type && (node.value?.node_type === "value" && !!status.class_vars?.has(node.value.value) || val_is_borrowing_call || node.value?.node_type === "access" && !val_is_owned_return);
 		const val_is_string_literal = node.value?.node_type === "value" && node.value.value.length >= 2 && node.value.value.startsWith("\"") && node.value.value.endsWith("\"");
 		const is_borrow_only_string = node.type.name === "string" && val_is_string_literal && (node.declaration === "const" || node.declaration === "var" && !!status.c_borrow_only_strings?.has(safe_name));
 		if (is_borrow_only_string) {
@@ -14846,11 +15388,7 @@ function build_declaration_node(node, status) {
 				}
 			}
 		}
-		if (node.value?.node_type === "value" && node.value.is_moved && !is_class_type) {
-			const src_name = node.value.value;
-			const src_idx = status.scoped_declarations.findIndex((d) => d.name === src_name);
-			if (src_idx !== -1) status.scoped_declarations.splice(src_idx, 1);
-		}
+		if (node.value?.node_type === "value" && node.value.is_moved && !is_class_type) splice_decl_from_c_scopes(status, node.value.value);
 		if (node.type?.name) {
 			if (!status.variable_types) status.variable_types = /* @__PURE__ */ new Map();
 			status.variable_types.set(safe_name, node.type);
@@ -15299,9 +15837,20 @@ function build_function_call_node(node, status) {
 		const param = node.params[idx];
 		if (param?.node_type === "value") {
 			const vname = param.value;
-			const di = status.scoped_declarations.findIndex((d) => d.name === vname);
-			if ((di !== -1 ? status.scoped_declarations[di].type?.name : param.type?.name) === "string") continue;
-			if (di !== -1) status.scoped_declarations.splice(di, 1);
+			const decl_hit = find_decl_in_c_scopes(status, vname);
+			const tname = decl_hit?.frame[decl_hit.index].type?.name ?? param.type?.name;
+			if (tname === "string") continue;
+			const decl_struct = decl_hit ? status.structs.find((s) => s.name === tname && !s.is_simple_type) : void 0;
+			const is_value_struct = !!decl_struct && !decl_struct.is_class;
+			if (decl_hit) decl_hit.frame.splice(decl_hit.index, 1);
+			if (is_value_struct) {
+				const prefix = `${vname}.`;
+				for (const key of Array.from(status.heap_string_fields ?? [])) if (key.startsWith(prefix)) {
+					if (!status.pending_string_releases) status.pending_string_releases = [];
+					status.pending_string_releases.push(`free(${key});`);
+					status.heap_string_fields.delete(key);
+				}
+			}
 			if (!status.moved) status.moved = /* @__PURE__ */ new Set();
 			status.moved.add(vname);
 		}
@@ -15341,6 +15890,52 @@ function emit_nullable_arg_flag(arg, status) {
 	status.code += `1`;
 }
 //#endregion
+//#region ../src/build_c/utils/build_condition.ts
+/**
+* Build a controlling expression (an if/while/for condition or a switch-case
+* comparison) and emit it without redundant fully-wrapping outer parentheses.
+* The codegen wraps every binary operation in parens (build_default_binary),
+* so emitting the condition verbatim would read `if ((a == b))`, which clang
+* flags as -Wparentheses-equality ("equality comparison with extraneous
+* parentheses").
+*/
+function build_condition(node, status) {
+	const before = status.code.length;
+	build_node(node, status);
+	status.code = status.code.substring(0, before) + strip_outer_parens(status.code.substring(before));
+}
+/**
+* Strip outer paren layers that wrap the ENTIRE expression (the opening paren
+* matches only the final character). A layer is removed only when the inner
+* text does not start with `{` — a GCC/clang statement-expression
+* `({ ... })` must keep its wrapper to stay a valid expression. Parens
+* inside string/char literals can only make the scan conservative (they
+* unbalance the depth count, so nothing is stripped), never incorrect.
+*/
+function strip_outer_parens(expr) {
+	let code = expr.trim();
+	while (code.length > 1 && code.startsWith("(") && code.endsWith(")")) {
+		let depth = 0;
+		let wraps_whole = true;
+		for (let i = 0; i < code.length; i++) {
+			const ch = code[i];
+			if (ch === "(") depth++;
+			else if (ch === ")") {
+				depth--;
+				if (depth === 0 && i < code.length - 1) {
+					wraps_whole = false;
+					break;
+				}
+			}
+		}
+		if (!wraps_whole || depth !== 0) break;
+		const inner = code.slice(1, -1).trim();
+		if (inner.startsWith("{")) break;
+		code = inner;
+	}
+	return code;
+}
+//#endregion
 //#region ../src/build_c/build_if_else_node.ts
 function build_if_else_node(node, status) {
 	const old_scoped_declarations = status.scoped_declarations;
@@ -15349,7 +15944,7 @@ function build_if_else_node(node, status) {
 	status.deferred_frees = [];
 	emit_allocations(node.condition, status);
 	status.code += `if (`;
-	build_node(node.condition, status);
+	build_condition(node.condition, status);
 	status.code += `) {\n`;
 	if (node.if_branch) {
 		build_block_node(node.if_branch, status);
@@ -15493,7 +16088,7 @@ function build_return_node(node, status) {
 	const ret_is_null = returns_nullable_struct && (!node.value || node.value.node_type === "value" && node.value.value === "null");
 	if (returns_nullable_struct) {
 		if (ret_is_null) {
-			build_auto_free(status);
+			reclaim_all_c_scopes(status);
 			status.code += `*${ret_has} = 0;\n`;
 			status.code += `return (struct ${status.function_return_type.name}){0};\n`;
 			return;
@@ -15501,7 +16096,7 @@ function build_return_node(node, status) {
 		status.code += `*${ret_has} = 1;\n`;
 	}
 	if (!node.value) {
-		build_auto_free(status);
+		reclaim_all_c_scopes(status);
 		if (status.return_assign) status.code += `${status.return_assign} = 0;\n`;
 		else if (status.current_function_name?.toLocaleLowerCase() === "main") status.code += `return 0;\n`;
 		else status.code += `return;\n`;
@@ -15532,8 +16127,18 @@ function build_return_node(node, status) {
 	if (node.value.node_type === "value") {
 		const value = node.value.value;
 		returned_value_decl = find_decl_across_scopes(value, status);
-		let di = status.scoped_declarations.indexOf(returned_value_decl);
-		if (di !== -1) status.scoped_declarations.splice(di, 1);
+		const frames = [status.scoped_declarations, ...status.c_scope_stack ?? []];
+		for (const frame of frames) {
+			const di = frame.indexOf(returned_value_decl);
+			if (di !== -1) {
+				frame.splice(di, 1);
+				break;
+			}
+		}
+		if (status.heap_string_fields?.size) {
+			const prefix = `${value}.`;
+			for (const key of Array.from(status.heap_string_fields)) if (key.startsWith(prefix)) status.heap_string_fields.delete(key);
+		}
 	}
 	if (ret_type?.is_array && return_array_var && return_array_len > 0) {
 		const elem_name = ret_type.name;
@@ -15543,7 +16148,7 @@ function build_return_node(node, status) {
 		status.code += `_return_val->length = ${return_array_len};\n`;
 		status.code += `${elem_c_type}* _return_data = (${elem_c_type}*)((char*)_return_val + sizeof(struct ${array_struct}));\n`;
 		status.code += `for (long _i = 0; _i < ${return_array_len}; _i++) _return_data[_i] = ${return_array_var}[_i];\n`;
-		build_auto_free(status);
+		reclaim_all_c_scopes(status);
 		status.code += `return _return_val;\n`;
 		return;
 	}
@@ -15553,7 +16158,7 @@ function build_return_node(node, status) {
 		status.code += `${old_return_assign} = `;
 		build_node(node.value, status);
 		status.code += `;\n`;
-		build_auto_free(status);
+		reclaim_all_c_scopes(status);
 	} else {
 		emit_allocations(node.value, status);
 		const ret_type = status.function_return_type || node.type;
@@ -15574,7 +16179,7 @@ function build_return_node(node, status) {
 			build_node(node.value, status);
 			status.join_needs_owned_string = old_join_owned;
 			status.return_assign = old_return_assign;
-			build_auto_free(status);
+			reclaim_all_c_scopes(status);
 			if (string_join) status.code += any_branch_owned ? `return _return_val;\n` : `return strdup(_return_val);\n`;
 			else status.code += `return _return_val;\n`;
 			return;
@@ -15622,7 +16227,7 @@ function build_return_node(node, status) {
 		if (returns_borrowed_string || returns_string_literal || returns_borrow_var) status.code += `)`;
 		status.code += `;\n`;
 		if (node.value.node_type === "func_call" && node.value.field_overrides?.length) emit_field_overrides("_return_val", node.value, build_node, status, "", ";\n");
-		build_auto_free(status);
+		reclaim_all_c_scopes(status);
 		status.code += `return _return_val;\n`;
 	}
 }
@@ -15752,6 +16357,7 @@ function build_switch_node(node, status) {
 		}
 		cond_code = cond_code.trim();
 		while (cond_code.startsWith("(") && !cond_code.endsWith(")")) cond_code = cond_code.substring(1).trim();
+		cond_code = strip_outer_parens(cond_code);
 		if (decls.length > 0) status.code += decls.join("\n") + "\n";
 		const prefix = status.code.endsWith("} else ") ? "" : "";
 		status.code += `${prefix}if (${cond_code}) {\n`;
@@ -15828,13 +16434,13 @@ function build_while_loop_node(node, status) {
 	emit_allocations(node.condition, status);
 	if (node.update) {
 		status.code += `for (; `;
-		build_node(node.condition, status);
+		build_condition(node.condition, status);
 		status.code += `; `;
 		build_node(node.update, status);
 		status.code += `) {\n`;
 	} else {
 		status.code += `while (`;
-		build_node(node.condition, status);
+		build_condition(node.condition, status);
 		status.code += `) {\n`;
 	}
 	build_block_node(node, status);
@@ -15980,6 +16586,95 @@ function build_node(node, status, with_semicolon = false) {
 	}
 	if (with_semicolon) {
 		if (!status.code.endsWith("}\n")) status.code += ";\n";
+		if (status.pending_string_releases?.length) {
+			status.code += status.pending_string_releases.join("\n") + "\n";
+			status.pending_string_releases.length = 0;
+		}
+	}
+}
+//#endregion
+//#region ../src/build_common/scan_borrow_returns.ts
+/**
+* Functions (and methods) whose CLASS-typed return value is a BORROWED
+* reference — e.g. `func box_at = (List<Box> xs, int i, out Box) { var Box
+* got = xs.at(j); return mov got }` hands back the container's element, not a
+* fresh instance. A caller-side declaration initialized from such a call must
+* NOT be destroy-tracked (the callee's owner frees it) — mirroring the
+* syntactic borrow rules at declaration sites (field access / non-`mov out`
+* method call).
+*
+* Syntactic, build-time: a return of a local whose initializer is a field
+* access or a non-owned-return method call (`.at()`, `.first()`, …) marks the
+* enclosing function. Mixed functions (some returns fresh, some borrowed) are
+* classified as borrowing — never freeing is safe (worst case a leak), while
+* the opposite risks a double-free.
+*/
+function scan_borrow_returning_functions(root) {
+	const statements = root.statements ?? [];
+	const class_type_names = /* @__PURE__ */ new Set();
+	const result = /* @__PURE__ */ new Set();
+	walk(statements, (n) => {
+		if (n.node_type === "struct" && n.is_class) class_type_names.add(n.name);
+	}, true, true);
+	walk(statements, (n) => {
+		if (n.node_type === "struct") for (const f of n.functions ?? []) scan_func(f, n.name, result, class_type_names);
+		else if (n.node_type === "func") scan_func(n, void 0, result, class_type_names);
+	});
+	return result;
+}
+/**
+* Visit every AST node reachable from `value` — through arrays AND
+* single-node properties (an `if` node's branch blocks are node objects, not
+* statement arrays) — skipping `parent`/`scope` back-references. By default
+* does NOT descend INTO nested `func`/`struct`/`trait` declarations (a
+* function's own body must not leak into its enclosing function's
+* classification); `descend_boundaries` walks them too (used by the
+* class-name gather, which must see classes declared anywhere, including
+* inside the synthetic wrapper `main`).
+*/
+function walk(value, cb, top = true, descend_boundaries = false) {
+	if (!value || typeof value !== "object") return;
+	if (Array.isArray(value)) {
+		for (const item of value) walk(item, cb, false, descend_boundaries);
+		return;
+	}
+	const n = value;
+	const is_boundary = (n.node_type === "func" || n.node_type === "struct" || n.node_type === "trait") && !top;
+	if (typeof n.node_type === "string") cb(n);
+	if (is_boundary && !descend_boundaries) return;
+	for (const key of Object.keys(value)) {
+		if (key === "parent" || key === "scope" || key === "node_type") continue;
+		walk(value[key], cb, false, descend_boundaries);
+	}
+}
+function scan_func(func, struct_name, result, class_type_names) {
+	walk(func.statements ?? [], (n) => {
+		if (n.node_type === "func") scan_func(n, void 0, result, class_type_names);
+		else if (n.node_type === "struct") for (const f of n.functions ?? []) scan_func(f, n.name, result, class_type_names);
+	});
+	if (!func.return_type?.name || !class_type_names.has(func.return_type.name)) return;
+	const borrowed_locals = /* @__PURE__ */ new Set();
+	let returns_borrowed = false;
+	walk(func.statements ?? [], (n) => {
+		if (n.node_type === "declare") {
+			const decl = n;
+			if (!decl.type?.name || !class_type_names.has(decl.type.name)) return;
+			const value = decl.value;
+			if (!value || value.node_type !== "access") return;
+			const access = value;
+			if (access.access.node_type === "access_field") borrowed_locals.add(decl.name);
+			else if (access.access.node_type === "access_func") {
+				if (!access.access.owned_return) borrowed_locals.add(decl.name);
+			}
+		} else if (n.node_type === "return") {
+			const value = n.value;
+			if (value && value.node_type === "value" && borrowed_locals.has(value.value)) returns_borrowed = true;
+		}
+	});
+	if (returns_borrowed) {
+		const sanitized = func.name.replace(/#/g, "");
+		const label = struct_name ? `${struct_name}_${sanitized}` : sanitized;
+		result.add(label);
 	}
 }
 //#endregion
@@ -16024,6 +16719,7 @@ function build(root, options = {}) {
 		reset_inline_counter();
 		reset_decl_const_counters();
 		status.heap_returning_functions = scan_heap_returning_functions(root);
+		status.borrow_returning_functions = scan_borrow_returning_functions(root);
 		status.inline_functions = scan_inline_candidates(root);
 		status.heap_returning_functions.add("int_to_string");
 		status.heap_returning_functions.add("uint_to_string");
@@ -16135,9 +16831,13 @@ function build(root, options = {}) {
 		}
 		if (options.audit) {
 			status.code = status.code.replaceAll("bl _malloc\n", "bl _nomen_malloc_wrap\n");
+			status.code = status.code.replaceAll("bl _calloc\n", "bl _nomen_calloc_wrap\n");
+			status.code = status.code.replaceAll("bl _realloc\n", "bl _nomen_realloc_wrap\n");
+			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");
 		}
 	} else {
+		status.borrow_returning_functions = scan_borrow_returning_functions(root);
 		set_c_typedef_mangling(build_needs_objc(root, status.platform));
 		build_node(root, status);
 		status.code = `typedef struct { void* ptr; long len; } nomen_view;\n` + status.code;
@@ -24367,7 +25067,9 @@ function check_return_node(ret, status) {
 		}
 	}
 	if (func && borrow_depth_of(ret.value, status) !== void 0) {
-		if (!(!!func.return_type?.is_view && borrow_owner_of(ret.value, status) === "self")) add_error(status, `cannot return a borrowed reference — use 'mov' (with swap) to transfer ownership`, ret.value.start);
+		const safe_view_from_self = !!func.return_type?.is_view && borrow_owner_of(ret.value, status) === "self";
+		const explicit_mov = !!get_inner_value_node(ret.value)?.is_moved;
+		if (!safe_view_from_self && !explicit_mov) add_error(status, `cannot return a borrowed reference — use 'mov' (with swap) to transfer ownership`, ret.value.start);
 	}
 	if (func) {
 		if (func.return_type.name) {
@@ -28012,7 +28714,7 @@ function compile_audit_runtime(config, input_path, buildDir) {
 	return audit_obj;
 }
 function watchPath(p, config, mode, program_args) {
-	chokidar.watch(p).on("all", (event, filePath) => {
+	chokidar_default.watch(p).on("all", (event, filePath) => {
 		if (shouldProcessFile(filePath)) processFile(filePath, config, mode, program_args);
 	});
 }