nomen-lang 0.6.5 → 0.6.6

package/dist/index.mjs

@@ -7546,7 +7546,7 @@ function scan_self_string_field_writes(struct, method) {
 	const scan_method = (func) => {
 		if (visited.has(func.name)) return;
 		visited.add(func.name);
-		walk$3(func.statements ?? [], (n) => {
+		walk$4(func.statements ?? [], (n) => {
 			if (n.node_type === "assign") {
 				const lhs = n.left_value;
 				if (lhs?.node_type !== "access") return;
@@ -7590,10 +7590,10 @@ function drop_self_written_string_field_records(status, receiver_name, fields) {
 *  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$3(value, cb) {
+function walk$4(value, cb) {
 	if (!value || typeof value !== "object") return;
 	if (Array.isArray(value)) {
-		for (const item of value) walk$3(item, cb);
+		for (const item of value) walk$4(item, cb);
 		return;
 	}
 	const n = value;
@@ -7602,7 +7602,177 @@ function walk$3(value, cb) {
 	if (is_boundary) return;
 	for (const key of Object.keys(value)) {
 		if (key === "parent" || key === "scope" || key === "node_type") continue;
-		walk$3(value[key], cb);
+		walk$4(value[key], cb);
+	}
+}
+//#endregion
+//#region ../src/build_common/has_string_fields.ts
+/**
+* Whether any field (recursively, through nested owning value structs)
+* is an owned `string`. Shared by BOTH backends' owning-Buffer element
+* specialization (the slot deep-copies strdup'd strings, so a
+* string-field element is owning even when `struct_needs_destroy`
+* ignores string-only locals) — the C comment in
+* owning_buffer_specialize records the divergence this once caused.
+* `ref` and `view T` fields are skipped: a ref aliases the caller's
+* storage and a view's byte copy owns nothing.
+*/
+function has_string_fields(node, status) {
+	for (const field of node.fields) {
+		if (field.type.is_ref) continue;
+		if (field.type.is_view) continue;
+		if (field.type.name === "string" && !field.type.is_array) return true;
+		const field_struct = status.structs.find((s) => s.name === field.type.name && !s.is_simple_type && !s.is_generic);
+		if (field_struct && !field_struct.is_class && has_string_fields(field_struct, status)) return true;
+	}
+	return false;
+}
+/**
+* The DIRECT `string` fields of a value struct (nested struct fields are not
+* descended into — nested string fields are outside the per-field ownership
+* tracking everywhere else too). Used by the return-boundary normalization:
+* the returned struct's unrecorded fields are strdup'd so the value the
+* caller receives is uniformly heap-owned.
+*/
+function direct_string_fields(node) {
+	return node.fields.filter((f) => !f.type.is_ref && !f.type.is_view && !f.type.is_array && f.type.name === "string");
+}
+//#endregion
+//#region ../src/build_common/scan_ref_string_writes.ts
+/**
+* The plain `string` fields of `func`'s `ref` value-struct parameters that the
+* function stores through with a DIRECT top-level statement — transitively
+* through top-level calls that forward the same param as their own `ref`
+* argument (callees resolved via the checker's `resolved_function` stamps).
+*
+* Both backends' string-field store paths strdup every non-heap RHS into an
+* owned copy before storing (a field is never a borrow once stored), so a
+* definitely-executed store leaves the field heap-owned. That is the fact a
+* CALL SITE transfers onto the caller's `heap_string_fields` records (the
+* add-direction mirror of `drop_self_written_string_field_records`): the
+* callee's own records are scope-local and die at return, so without the
+* transfer the stored copy leaks.
+*
+* Only DIRECT statements qualify: a store nested in a branch/loop may not
+* execute, and a record over the pre-call value would free it at the caller's
+* scope exit (possibly rodata — an invalid free). Memoized on the function
+* node; forwarding cycles are cut by a visited set (the cycle member's own
+* contribution is skipped, bounded-leak).
+*/
+function scan_ref_param_string_field_writes(func, structs) {
+	const stamp = func;
+	if (stamp._ref_param_string_field_writes) return stamp._ref_param_string_field_writes;
+	const result = /* @__PURE__ */ new Map();
+	stamp._ref_param_string_field_writes = result;
+	const tracked = /* @__PURE__ */ new Map();
+	for (const param of func.params ?? []) {
+		if (param.is_self_param) continue;
+		if (!(param.is_ref || param.type.is_ref)) continue;
+		if (param.type.is_array || param.type.is_view) continue;
+		const fields = ref_param_writable_fields(param.type.name, structs);
+		if (fields.size) tracked.set(param.name, fields);
+	}
+	if (tracked.size) scan_function(func, tracked, structs, result, /* @__PURE__ */ new Set());
+	return result;
+}
+/** The writable plain string fields of the value struct `type_name` resolves
+*  to, or the empty set (non-struct, class, or no string fields). */
+function ref_param_writable_fields(type_name, structs) {
+	if (!type_name) return /* @__PURE__ */ new Set();
+	const struct = structs.find((s) => s.name === type_name && !s.is_simple_type && !s.is_class);
+	if (!struct) return /* @__PURE__ */ new Set();
+	return new Set(direct_string_fields(struct).map((f) => f.name));
+}
+function scan_function(func, tracked, structs, result, visiting) {
+	visiting.add(func);
+	for (const stmt of func.statements ?? []) {
+		if (stmt.node_type === "assign") {
+			const lhs = stmt.left_value;
+			if (lhs?.node_type === "access") {
+				const access = lhs;
+				if (access.access.node_type === "access_field" && access.target.node_type === "value") {
+					const name = access.target.value ?? "";
+					const fields = tracked.get(name);
+					const field = access.access.name ?? "";
+					if (fields?.has(field)) {
+						if (!result.has(name)) result.set(name, /* @__PURE__ */ new Set());
+						result.get(name).add(field);
+					}
+				}
+			}
+			continue;
+		}
+		const call = ref_forward_call(stmt);
+		if (!call) continue;
+		const [callee, args] = call;
+		const non_self_params = (callee.params ?? []).filter((p) => !p.is_self_param);
+		for (let i = 0; i < args.length && i < non_self_params.length; i++) {
+			const arg = args[i];
+			if (arg?.node_type !== "value") continue;
+			const arg_name = arg.value ?? "";
+			const my_fields = tracked.get(arg_name);
+			if (!my_fields) continue;
+			const callee_param = non_self_params[i];
+			if (!(callee_param.is_ref || callee_param.type.is_ref)) continue;
+			if (visiting.has(callee)) continue;
+			const callee_writes = scan_ref_param_string_field_writes(callee, structs).get(callee_param.name);
+			if (!callee_writes?.size) continue;
+			if (!result.has(arg_name)) result.set(arg_name, /* @__PURE__ */ new Set());
+			const mine = result.get(arg_name);
+			for (const field of callee_writes) if (my_fields.has(field)) mine.add(field);
+		}
+	}
+	visiting.delete(func);
+}
+/**
+* The forwarded-call shape of a top-level statement: a resolved free-function
+* call or method call, with its argument list (the receiver is NOT included).
+*/
+function ref_forward_call(stmt) {
+	if (stmt.node_type === "func_call") {
+		const call = stmt;
+		if (!call.resolved_function) return void 0;
+		return [call.resolved_function, call.params ?? []];
+	}
+	if (stmt.node_type === "access") {
+		const access = stmt;
+		if (access.access.node_type !== "access_func") return void 0;
+		const func_node = access.access.resolved_function;
+		if (!func_node) return void 0;
+		return [func_node, access.access.params ?? []];
+	}
+}
+//#endregion
+//#region ../src/build_common/transfer_ref_param_records.ts
+/**
+* The add-direction mirror of drop_self_written_string_field_records: at a
+* call site whose callee takes a `ref` value-struct parameter, the callee's
+* string-field stores write through to the CALLER's variable — but the
+* callee's heap_string_fields records are scope-local and die at return, so
+* the stored copy would leak. Transfer the callee's definitely-executed
+* stores (scan_ref_param_string_field_writes) onto the caller's records for
+* the argument variable, making the caller's scope exit free them.
+*
+* `arg_is_trackable_local` must report true only for variables whose storage
+* THIS function's scope exit owns — a plain local. A `ref` param of the
+* enclosing function forwards caller storage, so a record here would free the
+* ORIGINAL caller's field at the wrong scope's exit.
+*/
+function transfer_ref_param_field_records(callee, args, status, arg_is_trackable_local) {
+	const writes = scan_ref_param_string_field_writes(callee, status.structs);
+	if (!writes.size) return;
+	const non_self_params = (callee.params ?? []).filter((p) => !p.is_self_param);
+	for (let i = 0; i < args.length && i < non_self_params.length; i++) {
+		const param = non_self_params[i];
+		if (!(param.is_ref || param.type.is_ref)) continue;
+		const fields = writes.get(param.name);
+		if (!fields?.size) continue;
+		const arg = args[i];
+		if (arg?.node_type !== "value") continue;
+		const name = arg.value;
+		if (!name || !arg_is_trackable_local(name)) continue;
+		if (!status.heap_string_fields) status.heap_string_fields = /* @__PURE__ */ new Set();
+		for (const field of fields) status.heap_string_fields.add(`${name}.${field}`);
 	}
 }
 //#endregion
@@ -7943,13 +8113,14 @@ function emit_field_overrides(var_name, value, build, status, declaration_termin
 	const overrides = overrides_of(value);
 	if (!overrides.length) return;
 	status.code += declaration_terminator;
-	const carrier_type = var_name.startsWith("_return_val") ? void 0 : value.type;
+	const carrier_type = var_name.startsWith("_return_val") || var_name.startsWith("_temp_") ? void 0 : value.type;
 	for (const override of overrides) {
 		const target = new ValueNode(override.value.start, var_name);
 		if (carrier_type) target.type = carrier_type;
 		const access_field = new AccessFieldNode(override.value.start, override.name, override.type);
 		const access = new AccessNode(override.value.start, target, access_field);
 		const assign = new AssignmentNode(override.value.start, access, override.value);
+		if (!carrier_type) assign.raw_field_store = true;
 		status.code += "\n";
 		status.c_field_override_depth = (status.c_field_override_depth ?? 0) + 1;
 		build(assign, status);
@@ -8073,38 +8244,6 @@ function hoist_field_overrides(value, build, status, declaration_terminator = ""
 	carrier._fov_hoisted = true;
 }
 //#endregion
-//#region ../src/build_common/has_string_fields.ts
-/**
-* Whether any field (recursively, through nested owning value structs)
-* is an owned `string`. Shared by BOTH backends' owning-Buffer element
-* specialization (the slot deep-copies strdup'd strings, so a
-* string-field element is owning even when `struct_needs_destroy`
-* ignores string-only locals) — the C comment in
-* owning_buffer_specialize records the divergence this once caused.
-* `ref` and `view T` fields are skipped: a ref aliases the caller's
-* storage and a view's byte copy owns nothing.
-*/
-function has_string_fields(node, status) {
-	for (const field of node.fields) {
-		if (field.type.is_ref) continue;
-		if (field.type.is_view) continue;
-		if (field.type.name === "string" && !field.type.is_array) return true;
-		const field_struct = status.structs.find((s) => s.name === field.type.name && !s.is_simple_type && !s.is_generic);
-		if (field_struct && !field_struct.is_class && has_string_fields(field_struct, status)) return true;
-	}
-	return false;
-}
-/**
-* The DIRECT `string` fields of a value struct (nested struct fields are not
-* descended into — nested string fields are outside the per-field ownership
-* tracking everywhere else too). Used by the return-boundary normalization:
-* the returned struct's unrecorded fields are strdup'd so the value the
-* caller receives is uniformly heap-owned.
-*/
-function direct_string_fields(node) {
-	return node.fields.filter((f) => !f.type.is_ref && !f.type.is_view && !f.type.is_array && f.type.name === "string");
-}
-//#endregion
 //#region ../src/build_common/string_return_analysis.ts
 const EMPTY_SET = /* @__PURE__ */ new Set();
 /**
@@ -8468,6 +8607,11 @@ function is_owned_string_branch_value(node, table) {
 */
 function is_normalized_struct_call(value, status) {
 	if (!value) return false;
+	if (value.node_type === "anon_struct") {
+		const base = value.base;
+		if (!base) return false;
+		value = base;
+	}
 	if (value.node_type === "func_call") {
 		const call = value;
 		return !!status.normalized_struct_returners?.has(call.name);
@@ -8511,6 +8655,175 @@ function record_call_init_string_fields(node, status) {
 	for (const field of fields) status.heap_string_fields.add(`${node.name}.${field.name}`);
 }
 //#endregion
+//#region ../src/build_common/init_computed_seeds.ts
+function is_plain_string_field(field) {
+	return field.type.name === "string" && !field.type.is_ref && !field.type.is_array && !field.type.is_view;
+}
+/** The `(field, rhs)` of a `self.<field> = <rhs>` write, or undefined. */
+function self_string_field_write(node, string_fields) {
+	if (node.node_type !== "assign") return void 0;
+	const lhs = node.left_value;
+	if (lhs?.node_type !== "access") return void 0;
+	const access = lhs;
+	if (access.access.node_type !== "access_field") return void 0;
+	const target = access.target;
+	if (target?.node_type !== "value" || target.value !== "self") return void 0;
+	const field = access.access.name ?? "";
+	if (!string_fields.has(field)) return void 0;
+	return {
+		field,
+		rhs: node.right_value
+	};
+}
+/** Visit every AST node reachable from `value` — through arrays AND
+*  single-node properties — skipping `parent`/`scope` back-references and NOT
+*  descending INTO nested `func`/`struct`/`trait` declarations. */
+function walk$3(value, cb) {
+	if (!value || typeof value !== "object") return;
+	if (Array.isArray(value)) {
+		for (const item of value) walk$3(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$3(value[key], cb);
+	}
+}
+function collect_init_string_writes(struct_node, init) {
+	const string_fields = new Set(struct_node.fields.filter(is_plain_string_field).map((f) => f.name));
+	const top_level = /* @__PURE__ */ new Map();
+	const nested = /* @__PURE__ */ new Map();
+	const add = (m, field, rhs) => {
+		const list = m.get(field);
+		if (list) list.push(rhs);
+		else m.set(field, [rhs]);
+	};
+	for (const stmt of init.statements ?? []) {
+		const write = self_string_field_write(stmt, string_fields);
+		if (write) {
+			add(top_level, write.field, write.rhs);
+			continue;
+		}
+		walk$3(stmt, (n) => {
+			const nested_write = self_string_field_write(n, string_fields);
+			if (nested_write) add(nested, nested_write.field, nested_write.rhs);
+		});
+	}
+	return {
+		top_level,
+		nested
+	};
+}
+/**
+* The plain string fields of `struct_node` that its custom `#init` COMPUTES as
+* a definitely-heap-owning value: for EVERY `#init` overload, the field is
+* either written at least once as a DIRECT body statement with every write
+* (direct or nested) passing `is_owned_heap` — or never written and its
+* DEFAULT also passes `is_owned_heap` (the overload leaves the default in
+* place). A param-alias seed (`self.a = s`) never qualifies: the seed borrows
+* the caller's argument temp, so it must never be recorded or freed.
+*
+* Binding sites record qualifying fields (scope exit frees the computed seed;
+* a displaced store reclaims it); override sites treat them as displaced (the
+* raw override store orphans the computed buffer). A param-alias seed or a
+* conditional computed write over a rodata default leaves a path holding a
+* non-heap value — such fields stay unqualified (bounded leak on the write
+* path, never an invalid free).
+*/
+function init_computed_heap_string_fields(struct_node, is_owned_heap) {
+	const result = /* @__PURE__ */ new Set();
+	const inits = struct_node.functions.filter((f) => f.name === "#init" && f.has_body);
+	if (!inits.length) return result;
+	for (const field of struct_node.fields) {
+		if (!is_plain_string_field(field)) continue;
+		const default_is_heap = !!field.value && is_owned_heap(field.value);
+		let written_somewhere = false;
+		let qualifies = true;
+		for (const init of inits) {
+			const writes = collect_init_string_writes(struct_node, init);
+			const direct = writes.top_level.get(field.name) ?? [];
+			const all = [...direct, ...writes.nested.get(field.name) ?? []];
+			if (all.length === 0) {
+				if (!default_is_heap) {
+					qualifies = false;
+					break;
+				}
+				continue;
+			}
+			written_somewhere = true;
+			if (!all.every((expr) => is_owned_heap(expr))) {
+				qualifies = false;
+				break;
+			}
+			if (direct.length === 0 && !default_is_heap) {
+				qualifies = false;
+				break;
+			}
+		}
+		if (qualifies && written_somewhere) result.add(field.name);
+	}
+	return result;
+}
+/**
+* The write-site half: does THIS custom-`#init` write to `self.<field>`
+* displace a heap-owning DEFAULT seed that must be reclaimed ahead of the
+* store? True only for the field's first write in the body (the displaced
+* value is then statically the default — later writes displace values whose
+* ownership the init cannot know, and keep the status quo). Marks the field
+* reclaimed on true so a second write never frees what the first stored.
+*
+* Sound even for conditional first writes: the free rides in the same branch
+* as the store, and the displaced value is still the default at that point.
+*/
+function claim_init_default_seed_reclaim(status, field_name, is_owned_heap) {
+	if (status.current_function?.name !== "#init" || !status.current_struct) return false;
+	if (status.init_default_reclaimed_fields?.has(field_name)) return false;
+	const field = status.current_struct.fields.find((f) => f.name === field_name);
+	if (!field || !field.value || !is_plain_string_field(field)) return false;
+	if (!is_owned_heap(field.value)) return false;
+	if (!status.init_default_reclaimed_fields) status.init_default_reclaimed_fields = /* @__PURE__ */ new Set();
+	status.init_default_reclaimed_fields.add(field_name);
+	return true;
+}
+//#endregion
+//#region ../src/build_common/ctor_heap_default_fields.ts
+/**
+* Record the string fields of `struct_node` whose value after construction
+* owns heap (per the backend's `is_owned_heap_temp`): either the DEFAULT is a
+* non-literal heap expression the constructor evaluates fresh at every
+* construction, or a custom `#init` COMPUTES the field's value
+* (`init_computed_heap_string_fields` — every direct `self.<field> = <expr>`
+* write stores a heap-owning expression, which also displaces the default).
+* Recording at the ctor-binding site makes scope exit free the seeded value,
+* and a displaced store (an override, a reassignment) reclaim it via the
+* record's old_was_heap check.
+*
+* `is_owned_heap` classifies the seed EXPRESSION per backend: both treat a
+* string-typed `op` as fresh heap; for calls the C backend's blanket strdup
+* makes every non-borrow string return owned, while the aarch64 backend
+* requires the heap-returning classification (a literal-returning user
+* function leaves rodata in the field — never recorded, never freed).
+*
+* `skip` names fields whose seed is reclaimed elsewhere (the C backend's
+* explicit displaced free ahead of an override store). Value structs only —
+* a class's string fields are always heap and freed by its destroy.
+*/
+function record_ctor_heap_default_fields(var_name, struct_node, status, is_owned_heap, skip) {
+	const computed = init_computed_heap_string_fields(struct_node, is_owned_heap);
+	for (const field of struct_node.fields) {
+		if (field.type.name !== "string" || field.type.is_array) continue;
+		if (field.type.is_ref || field.type.is_view) continue;
+		if (skip?.has(field.name)) continue;
+		if (!(!!field.value && is_owned_heap(field.value)) && !computed.has(field.name)) continue;
+		if (!status.heap_string_fields) status.heap_string_fields = /* @__PURE__ */ new Set();
+		status.heap_string_fields.add(`${var_name}.${field.name}`);
+	}
+}
+//#endregion
 //#region ../src/nodes/child_nodes.ts
 /** Whether `value` is an AST node (carries a string `node_type`). */
 function is_ast_node(value) {
@@ -8853,6 +9166,7 @@ function scan_function_literal_element_moves(func) {
 	return count;
 }
 function walk_stmt(walk, node) {
+	if (node.allocations?.length) for (const alloc of node.allocations) walk_stmt(walk, alloc);
 	switch (node.node_type) {
 		case "declare": {
 			const decl = node;
@@ -14891,10 +15205,21 @@ function emit_string_field_strdups_at(status, struct_name, base_reg, base_offset
 		const off = base_offset + get_field_offset(struct_name, field.name, status);
 		emit_asm(status, `str ${base_reg}, [sp, #-16]!\n`);
 		emit_string_pair_load_at(status, base_reg, off);
-		emit_strdup_string(status);
-		emit_asm(status, `mov x13, x0\n`);
-		emit_asm(status, `ldr ${base_reg}, [sp], #16\n`);
-		emit_pair_store_to(status, base_reg, off, "x13", "x1");
+		if (field.type.is_nullable) {
+			const skip_label = `.Lskip_nullable_strdup_${status.label_counter = (status.label_counter ?? 0) + 1}`;
+			emit_asm(status, `mov x13, x0\n`);
+			emit_asm(status, `cbz x0, ${skip_label}\n`);
+			emit_strdup_string(status);
+			emit_asm(status, `mov x13, x0\n`);
+			emit_asm(status, `${skip_label}:\n`);
+			emit_asm(status, `ldr ${base_reg}, [sp], #16\n`);
+			emit_pair_store_to(status, base_reg, off, "x13", "x1");
+		} else {
+			emit_strdup_string(status);
+			emit_asm(status, `mov x13, x0\n`);
+			emit_asm(status, `ldr ${base_reg}, [sp], #16\n`);
+			emit_pair_store_to(status, base_reg, off, "x13", "x1");
+		}
 	}
 }
 //#endregion
@@ -19441,6 +19766,12 @@ function plan_nir_registers(func, nir, options) {
 			});
 		}
 	}
+	const loop_carry_regs = /* @__PURE__ */ new Set();
+	for (const [key, f] of facts) {
+		if (!f.loop_blocked) continue;
+		const reg = allocs.get(key);
+		if (reg) loop_carry_regs.add(reg);
+	}
 	return {
 		allocs,
 		callee_saved,
@@ -19449,7 +19780,8 @@ function plan_nir_registers(func, nir, options) {
 		source_keys,
 		sites: site_allocs,
 		pairs: slp_pairs,
-		region_free
+		region_free,
+		loop_carry_regs
 	};
 }
 /**
@@ -19510,6 +19842,7 @@ function seed_function_allocations(func, status, options) {
 	}]));
 	if (status.nir_region_free.size === 0) status.nir_region_free = void 0;
 	status.region_preseed = void 0;
+	status.nir_loop_carry_regs = plan.loop_carry_regs.size > 0 ? plan.loop_carry_regs : void 0;
 	for (const param of func.params) {
 		const reg = plan.allocs.get(param.name);
 		if (!reg || !reg.startsWith("x")) continue;
@@ -19633,6 +19966,8 @@ function build_function_node$1(node, status) {
 	status.heap_class_arrays = void 0;
 	const old_heap_array_vars = status.heap_array_vars;
 	status.heap_array_vars = void 0;
+	const old_heap_string_fields = status.heap_string_fields;
+	status.heap_string_fields = void 0;
 	const old_heap_cleanup_stack = status.heap_cleanup_stack;
 	status.heap_cleanup_stack = void 0;
 	const old_trait_class_frames = status.trait_class_frames;
@@ -19860,11 +20195,13 @@ function build_function_node$1(node, status) {
 			}]));
 			if (status.nir_region_free.size === 0) status.nir_region_free = void 0;
 			status.region_preseed = void 0;
+			status.nir_loop_carry_regs = plan.loop_carry_regs.size > 0 ? plan.loop_carry_regs : void 0;
 		} else {
 			fn_allocs = plan_function_promotions(node, plan_nir);
 			status.nir_site_allocs = void 0;
 			status.nir_region_free = void 0;
 			status.region_preseed = void 0;
+			status.nir_loop_carry_regs = void 0;
 		}
 	} else status.nir_site_allocs = void 0;
 	status.register_allocations = fn_allocs && fn_allocs.size > 0 ? fn_allocs : void 0;
@@ -20245,6 +20582,7 @@ function build_function_node$1(node, status) {
 	}
 	status.scoped_declarations = old_scoped_declarations;
 	status.moved = old_moved;
+	status.heap_string_fields = old_heap_string_fields;
 	status.heap_strings = old_heap_strings;
 	status.heap_string_arrays = old_heap_string_arrays;
 	status.heap_owned_string_arrays = old_heap_owned_string_arrays;
@@ -20358,6 +20696,41 @@ function init_nullable_field_default(node, field, base_reg, status) {
 	emit_asm(status, `str x9, [${base_reg}, #${has_offset}]\n`);
 	return true;
 }
+/**
+* Initialize a field whose default is a non-literal EXPRESSION (a string op
+* like `"de" + "fault"`, a call returning a non-struct, a grouped expr, …):
+* evaluate it and store the result into the field slot. x0 carries the
+* result — a fat string as the (x0, x1) pair, a by-value struct as the sret
+* temp's address. A class's plain string field is strdup'd when the result
+* is not itself fresh heap (the field is freed unconditionally at destroy);
+* a value struct's heap-owning default is stored raw — the ctor-binding
+* sites record it (record_ctor_heap_default_fields) so scope exit frees it.
+*/
+function init_expr_field_default(node, field, offset, base_reg, status) {
+	build_node(field.value, status);
+	ensure_newline(status);
+	const t = field.type;
+	if (t.name === "string" && !t.is_ref && !t.is_view && !t.is_array) {
+		if (node.is_class && !status.last_result_is_heap) emit_strdup_string(status);
+		emit_pair_store_to(status, base_reg, offset, "x0", "x1");
+		return;
+	}
+	const field_struct = status.structs.find((s) => s.name === t.name && !s.is_simple_type);
+	if (field_struct?.is_class) {
+		emit_typed_store(status, "x0", base_reg, offset, 8);
+		return;
+	}
+	if (field_struct) {
+		const field_size = get_struct_size(t.name, status);
+		const words = Math.ceil(field_size / 8);
+		for (let w = 0; w < words; w++) {
+			emit_asm(status, `ldr x9, [x0, #${w * 8}]\n`);
+			emit_asm(status, `str x9, [${base_reg}, #${offset + w * 8}]\n`);
+		}
+		return;
+	}
+	emit_typed_store(status, "x0", base_reg, offset, get_type_size(t, status));
+}
 /** Store the scalar in x0 into `[base_reg + offset]` at its natural width. */
 function emit_scalar_store_from_x0(offset, type, base_reg, status) {
 	const name = type.name;
@@ -20783,19 +21156,16 @@ function build_init_function(node, status) {
 				}
 			}
 			emit_typed_store(status, "x1", "x19", offset, get_type_size(field.type, status));
-		} else if (field.value.node_type === "func_call") {
-			const field_struct = status.structs.find((s) => s.name === field.type.name && !s.is_simple_type);
-			if (field_struct) {
-				build_node(field.value, status);
-				ensure_newline(status);
-				if (field_struct.is_class) emit_typed_store(status, "x0", "x19", offset, 8);
-				else {
-					const field_size = get_struct_size(field.type.name, status);
-					const words = Math.ceil(field_size / 8);
-					for (let w = 0; w < words; w++) {
-						emit_asm(status, `ldr x9, [x0, #${w * 8}]\n`);
-						emit_asm(status, `str x9, [x19, #${offset + w * 8}]\n`);
-					}
+		} else if (field.value.node_type === "func_call" && status.structs.find((s) => s.name === field.type.name && !s.is_simple_type)) {
+			build_node(field.value, status);
+			ensure_newline(status);
+			if (status.structs.find((s) => s.name === field.type.name && !s.is_simple_type).is_class) emit_typed_store(status, "x0", "x19", offset, 8);
+			else {
+				const field_size = get_struct_size(field.type.name, status);
+				const words = Math.ceil(field_size / 8);
+				for (let w = 0; w < words; w++) {
+					emit_asm(status, `ldr x9, [x0, #${w * 8}]\n`);
+					emit_asm(status, `str x9, [x19, #${offset + w * 8}]\n`);
 				}
 			}
 		} else if (field.value.node_type === "func" && field.type.name === "func") {
@@ -20806,7 +21176,7 @@ function build_init_function(node, status) {
 			ensure_newline(status);
 			emit_descriptor_address(status, "x1", materialize_lambda_descriptor_a64(field.value, status));
 			emit_typed_store(status, "x1", "x19", offset, 8);
-		}
+		} else init_expr_field_default(node, field, offset, "x19", status);
 	}
 	for (const trait_name of node.traits) {
 		const trait = status.traits.find((t) => t.name === trait_name);
@@ -21026,6 +21396,10 @@ function build_custom_init_function(node, func, status) {
 	status.current_function = func;
 	const old_init_assigned_fields = status.init_assigned_fields;
 	status.init_assigned_fields = /* @__PURE__ */ new Set();
+	const old_init_default_reclaimed = status.init_default_reclaimed_fields;
+	status.init_default_reclaimed_fields = /* @__PURE__ */ new Set();
+	const old_init_heap_string_fields = status.heap_string_fields;
+	status.heap_string_fields = void 0;
 	emit_asm(status, `str xzr, [x19]\n`);
 	if (node.traits.length > 0) {
 		emit_asm(status, `adrp x9, _${node.name}_traits@PAGE\n`);
@@ -21083,22 +21457,19 @@ function build_custom_init_function(node, func, status) {
 				}
 			}
 			emit_typed_store(status, "x1", "x19", offset, get_type_size(field.type, status));
-		} else if (field.value.node_type === "func_call") {
-			const field_struct = status.structs.find((s) => s.name === field.type.name && !s.is_simple_type);
-			if (field_struct) {
-				build_node(field.value, status);
-				ensure_newline(status);
-				if (field_struct.is_class) emit_typed_store(status, "x0", "x19", offset, 8);
-				else {
-					const field_size = get_struct_size(field.type.name, status);
-					const words = Math.ceil(field_size / 8);
-					for (let w = 0; w < words; w++) {
-						emit_asm(status, `ldr x9, [x0, #${w * 8}]\n`);
-						emit_asm(status, `str x9, [x19, #${offset + w * 8}]\n`);
-					}
+		} else if (field.value.node_type === "func_call" && status.structs.find((s) => s.name === field.type.name && !s.is_simple_type)) {
+			build_node(field.value, status);
+			ensure_newline(status);
+			if (status.structs.find((s) => s.name === field.type.name && !s.is_simple_type).is_class) emit_typed_store(status, "x0", "x19", offset, 8);
+			else {
+				const field_size = get_struct_size(field.type.name, status);
+				const words = Math.ceil(field_size / 8);
+				for (let w = 0; w < words; w++) {
+					emit_asm(status, `ldr x9, [x0, #${w * 8}]\n`);
+					emit_asm(status, `str x9, [x19, #${offset + w * 8}]\n`);
 				}
 			}
-		}
+		} else init_expr_field_default(node, field, offset, "x19", status);
 	}
 	status.buffer_data_cache = void 0;
 	status.array_ptr_cache = void 0;
@@ -21108,6 +21479,8 @@ function build_custom_init_function(node, func, status) {
 		status.raw_param_reloads = old_raw_param_reloads;
 		status.current_function = old_current_function;
 		status.init_assigned_fields = old_init_assigned_fields;
+		status.init_default_reclaimed_fields = old_init_default_reclaimed;
+		status.heap_string_fields = old_init_heap_string_fields;
 	}
 	const init_claims = status.callee_saved_regs_used;
 	const init_loop_regs = init_claims ? [...init_claims].sort() : [];
@@ -21814,6 +22187,8 @@ function collect_allocations(node, options) {
 		case "func_call": {
 			const call = node;
 			for (const param of call.params) result.push(...collect_allocations(param, options));
+			const base = node.base;
+			if (base) result.push(...collect_allocations(base, options));
 			break;
 		}
 		case "access": {
@@ -21861,6 +22236,12 @@ function collect_allocations(node, options) {
 			result.push(...collect_allocations(range.right_value, options));
 			break;
 		}
+		case "anon_struct": {
+			const anon = node;
+			if (anon.base) result.push(...collect_allocations(anon.base, options));
+			for (const field of anon.fields) result.push(...collect_allocations(field.value, options));
+			break;
+		}
 		case "array": {
 			const arr = node;
 			for (const val of arr.values) result.push(...collect_allocations(val, options));
@@ -23893,6 +24274,8 @@ function build_declaration_node$1(node, status, nir_init, nir_swap) {
 					if (outgoing > 0) emit_asm(status, `add sp, sp, #${outgoing}\n`);
 					if (func_call.move_param_indices?.length) for (const idx of func_call.move_param_indices) mark_moved_if_struct(func_call.params[idx], status);
 					build_swap_params(func_call, status);
+					const ctor_struct = status.structs.find((s) => s.name === func_call.name && !s.is_simple_type && !s.is_class);
+					if (ctor_struct) record_ctor_heap_default_fields(node.name, ctor_struct, status, (seed) => is_owned_heap_temp(seed, status));
 				} else if (status.structs.find((s) => s.name === (func_call.type?.name ?? func_call.name) && !s.is_simple_type && !s.is_class) && status.function_return_label) {
 					const old_buffer = status.struct_return_buffer;
 					const old_buffer_var = status.struct_return_buffer_var;
@@ -24770,14 +25153,18 @@ const INT_CALLER_SAVED_EXT = [
 function can_share_claimed_register(status, name, reg) {
 	const shared = status.nir_alloc_shared;
 	if (!shared || !status.register_allocations) return false;
+	if (!shared.source_keys.has(name)) return false;
 	if (status.region_pinned?.get(reg)) return false;
-	const cand_keys = shared.source_keys.get(name) ?? [name];
+	if (status.nir_loop_carry_regs?.has(reg)) return false;
+	const cand_keys = shared.source_keys.get(name);
 	let occupants = 0;
 	for (const [occupant, occupant_reg] of status.register_allocations) {
 		if (occupant_reg !== reg || occupant === name) continue;
 		occupants++;
 		if (shared.pinned.has(occupant)) return false;
-		for (const occ_key of shared.source_keys.get(occupant) ?? [occupant]) for (const cand_key of cand_keys) if (shared.adj.get(cand_key)?.has(occ_key)) return false;
+		const occ_keys = shared.source_keys.get(occupant);
+		if (!occ_keys) return false;
+		for (const occ_key of occ_keys) for (const cand_key of cand_keys) if (shared.adj.get(cand_key)?.has(occ_key)) return false;
 	}
 	return occupants > 0;
 }
@@ -24954,6 +25341,7 @@ function promote_loop_locals(status, scoped_declarations, sources, options) {
 	else used_x.add(r);
 	if (status.nir_caller_saved_claimed) for (const r of status.nir_caller_saved_claimed) used_x.add(r);
 	if (status.region_pinned) for (const r of status.region_pinned.keys()) used_x.add(r);
+	const loop_carry_regs = status.nir_loop_carry_regs;
 	const site_regs = /* @__PURE__ */ new Set();
 	if (status.nir_site_allocs) for (const s of status.nir_site_allocs.values()) site_regs.add(s.reg);
 	const float_pool = options?.call_free === true ? [...FLOAT_CALLEE_SAVED, ...FLOAT_CALLER_SAVED_EXT] : FLOAT_CALLEE_SAVED;
@@ -24977,6 +25365,10 @@ function promote_loop_locals(status, scoped_declarations, sources, options) {
 						d_idx++;
 						continue;
 					}
+					if (loop_carry_regs?.has(reg0) || loop_carry_regs?.has(reg1)) {
+						d_idx++;
+						continue;
+					}
 					if (used_d.has(reg0)) {
 						if (!can_share_claimed_register(status, v.name, reg0)) {
 							d_idx++;
@@ -25024,6 +25416,10 @@ function promote_loop_locals(status, scoped_declarations, sources, options) {
 					d_idx++;
 					continue;
 				}
+				if (loop_carry_regs?.has(float_pool[d_idx])) {
+					d_idx++;
+					continue;
+				}
 				if (!used_d.has(float_pool[d_idx])) break;
 				if (can_share_claimed_register(status, v.name, float_pool[d_idx])) break;
 				d_idx++;
@@ -25046,6 +25442,10 @@ function promote_loop_locals(status, scoped_declarations, sources, options) {
 					x_idx++;
 					continue;
 				}
+				if (loop_carry_regs?.has(x_pool[x_idx])) {
+					x_idx++;
+					continue;
+				}
 				if (!used_x.has(x_pool[x_idx])) break;
 				if (can_share_claimed_register(status, v.name, x_pool[x_idx])) break;
 				x_idx++;
@@ -25357,23 +25757,33 @@ function build_if_else_node$1(node, status, nir) {
 	ensure_newline(status);
 	const pre_cache = status.buffer_data_cache;
 	const pre_array_cache = status.array_ptr_cache;
+	const pre_heap_string_fields = status.heap_string_fields;
 	if (node.else_branch) {
 		const then_frame = enter_scope_frame(status);
 		status.buffer_data_cache = new Map(pre_cache);
 		status.array_ptr_cache = new Map(pre_array_cache);
+		status.heap_string_fields = new Set(pre_heap_string_fields ?? []);
 		build_block_with_cursor$1(node.if_branch, nir?.then_branch, status);
+		const then_fields = status.heap_string_fields;
 		exit_scope_frame(status, then_frame);
 		emit_asm(status, `b end_${label}\n`);
 		emit_asm(status, `else_${label}:\n`);
 		const else_frame = enter_scope_frame(status);
 		status.buffer_data_cache = new Map(pre_cache);
 		status.array_ptr_cache = new Map(pre_array_cache);
+		status.heap_string_fields = new Set(pre_heap_string_fields ?? []);
 		build_block_with_cursor$1(node.else_branch, nir?.else_branch, status);
+		const else_fields = status.heap_string_fields;
 		exit_scope_frame(status, else_frame);
+		const merged = new Set(pre_heap_string_fields ?? []);
+		for (const key of then_fields ?? []) merged.add(key);
+		for (const key of else_fields ?? []) merged.add(key);
+		status.heap_string_fields = merged;
 	} else if (node.if_branch) {
 		const then_frame = enter_scope_frame(status);
 		status.buffer_data_cache = new Map(pre_cache);
 		status.array_ptr_cache = new Map(pre_array_cache);
+		status.heap_string_fields = new Set(pre_heap_string_fields ?? []);
 		build_block_with_cursor$1(node.if_branch, nir?.then_branch, status);
 		exit_scope_frame(status, then_frame);
 	}
@@ -25541,6 +25951,95 @@ function ctor_return_owned_string_fields(return_struct, call, heap_strings) {
 	}
 	return skip;
 }
+/** The OVERRIDE value of a string field, when the field is overridden. */
+function override_value_for_field(overrides, field_name) {
+	return overrides?.find((o) => o.name === field_name)?.value;
+}
+/**
+* The skip set for an OVERRIDE return (`return [ .. <base>, f = v, ... ]` in
+* its checked forms: a ctor call with `field_overrides`, or a base-bearing
+* anonymous struct literal). The overrides were applied to the return temp
+* BEFORE this analysis runs, so an overridden field holds the OVERRIDE
+* value's pair: it stays raw only when that value owns heap (a transferred
+* heap local, a fresh non-borrow expression). A non-overridden field keeps
+* the base's value: with `base_uniformly_owned` (a forwarded registered
+* normalizing base) it transfers raw; otherwise it follows `base_skip` (the
+* plain constructor-argument ownership analysis).
+*/
+function override_return_string_fields(return_struct, overrides, heap_strings, opts) {
+	const skip = /* @__PURE__ */ new Set();
+	for (const field of direct_string_fields(return_struct)) {
+		const override = override_value_for_field(overrides, field.name);
+		if (override) {
+			if (tuple_return_owned_element(override, heap_strings)) skip.add(field.name);
+		} else if (opts.base_uniformly_owned || opts.base_skip?.has(field.name)) skip.add(field.name);
+	}
+	return skip;
+}
+/**
+* The overridden string fields whose CONSTRUCTOR-SEEDED value owns heap and
+* is therefore displaced un-freed by a raw override store: a non-literal
+* default expression (the auto-constructor evaluates it fresh per
+* construction — `var string a = "de" + "fault"` allocates) is owned by the
+* constructed struct alone, so an override replacing the field orphans the
+* buffer unless it is reclaimed ahead of the store. Literal defaults are
+* rodata (never freed) and value-node defaults are consts/borrows (not
+* owned); a custom `#init`'s `self.<field> = <param>` seeds alias the
+* caller's argument temps in the common case, but a COMPUTED seed
+* (`self.a = s + "!"`, classified by `is_init_seed_heap`) owns heap — those
+* fields are displaced too.
+*/
+function override_displaced_string_fields(struct_node, overrides, is_init_seed_heap) {
+	if (!overrides?.length) return [];
+	const computed = init_computed_heap_string_fields(struct_node, is_init_seed_heap);
+	const displaced = [];
+	for (const override of overrides) {
+		const field = struct_node.fields.find((f) => f.name === override.name);
+		if (!field) continue;
+		if (field.type.name !== "string" || field.type.is_array || field.type.is_view) continue;
+		if (computed.has(override.name)) {
+			displaced.push(override.name);
+			continue;
+		}
+		const seed = field.value;
+		if (!seed || seed.node_type === "value") continue;
+		if (is_string_borrow(seed)) continue;
+		displaced.push(override.name);
+	}
+	return displaced;
+}
+/**
+* The aarch64 counterpart of override_displaced_string_fields: the
+* overridden string fields whose ctor-seeded value is a non-literal
+* expression that produced a HEAP value — a non-literal DEFAULT, or a
+* custom `#init`'s computed seed (`init_computed_heap_string_fields` under
+* the same `is_owned_heap` classifier). The extra `is_owned_heap` check
+* (the aarch64 is_owned_heap_temp) matters because the aarch64 backend does
+* NOT strdup every string return: a literal-returning user function leaves
+* RODATA in the seeded field, which must never be freed. Used at the
+* expression-temp override boundaries (no heap_string_fields records exist
+* there, so the stores stay raw and the seed needs an explicit reclaim).
+*/
+function ctor_heap_displaced_string_fields(struct_node, overrides, is_owned_heap) {
+	if (!overrides?.length) return [];
+	const computed = init_computed_heap_string_fields(struct_node, is_owned_heap);
+	const displaced = [];
+	for (const override of overrides) {
+		const field = struct_node.fields.find((f) => f.name === override.name);
+		if (!field) continue;
+		if (field.type.name !== "string" || field.type.is_array || field.type.is_view) continue;
+		if (computed.has(override.name)) {
+			displaced.push(override.name);
+			continue;
+		}
+		const seed = field.value;
+		if (!seed || seed.node_type === "value") continue;
+		if (is_string_borrow(seed)) continue;
+		if (!is_owned_heap(seed)) continue;
+		displaced.push(override.name);
+	}
+	return displaced;
+}
 //#endregion
 //#region ../src/build_aarch64/build_return_node.ts
 let temp_counter$1 = 0;
@@ -25723,7 +26222,7 @@ function build_return_node$1(node, status, nir_value) {
 		if (node.value?.node_type === "anon_struct") {
 			const anon = node.value;
 			const struct_size = get_struct_size(anon.type.name, status);
-			const temp_name = `_anon_ret_${temp_counter$1++}`;
+			const temp_name = `_return_val_anon_${temp_counter$1++}`;
 			const offset = allocate_stack_space(status, struct_size);
 			status.stack_offsets.set(temp_name, offset);
 			if (!status.variable_types) status.variable_types = /* @__PURE__ */ new Map();
@@ -25733,6 +26232,14 @@ function build_return_node$1(node, status, nir_value) {
 			emit_var_address(status, "x1", temp_name);
 			emit_struct_copy("x0", "x1", 0, struct_size, status);
 			if (anon.base.is_moved) mark_moved_if_struct(anon.base, status);
+			if (anon.base.node_type === "func_call" && is_normalized_struct_call(anon.base, status)) {
+				const base_struct = status.structs.find((s) => s.name === anon.type.name && !s.is_simple_type && !s.is_class);
+				if (base_struct) for (const field of direct_string_fields(base_struct)) {
+					if (!anon.fields.some((o) => o.name === field.name)) continue;
+					emit_asm(status, `ldp x0, x1, [x29, #${offset + get_field_offset(base_struct.name, field.name, status)}]\n`);
+					emit_asm(status, `bl _nomen_free_wrap\n`);
+				}
+			}
 			emit_field_overrides(temp_name, anon, build_node, status);
 			emit_var_address(status, "x0", temp_name);
 		} else {
@@ -25768,7 +26275,7 @@ function build_return_node$1(node, status, nir_value) {
 			if (!is_str_lit && !is_numeric && raw_value !== "null" && !status.heap_strings?.has(raw_value)) needs_borrow_strdup = true;
 		} else if (is_container_borrow_access(node.value)) needs_borrow_strdup = true;
 		else if (node.value.node_type === "access" && node.value.access.node_type === "access_field") needs_borrow_strdup = true;
-		else if (status.current_function_is_closure && (node.value.node_type === "func_call" || node.value.node_type === "access" && node.value.access.node_type === "access_func") && !status.last_result_is_heap && !is_container_borrow_access(node.value)) needs_borrow_strdup = true;
+		else if ((node.value.node_type === "func_call" || node.value.node_type === "access" && node.value.access.node_type === "access_func") && !status.last_result_is_heap && !is_container_borrow_access(node.value)) needs_borrow_strdup = true;
 		else if ((node.value.node_type === "match" || node.value.node_type === "switch") && !return_join_owned_string) needs_borrow_strdup = true;
 	}
 	if (needs_borrow_strdup) {
@@ -25777,6 +26284,15 @@ function build_return_node$1(node, status, nir_value) {
 		ensure_newline(status);
 		status.last_result_is_heap = true;
 	}
+	if (!needs_borrow_strdup && current_return_is_string(status) && !is_container_borrow_access(node.value) && (node.value.node_type === "func_call" || node.value.node_type === "access" && node.value.access.node_type === "access_func") && !status.last_result_is_heap && status.heap_string_fields?.size) {
+		emit_strdup_string(status);
+		ensure_newline(status);
+		status.last_result_is_heap = true;
+		if (borrow_fn_name) {
+			status.heap_returning_functions?.add(borrow_fn_name);
+			if (borrow_mangled !== void 0) status.heap_returning_functions?.add(borrow_mangled);
+		}
+	}
 	if (node.value.node_type === "access" && node.value.access.node_type === "access_func" && node.value.access.name === "move" && current_return_is_string(status)) status.last_result_is_heap = true;
 	if (status.last_result_is_heap && current_return_is_string(status)) {
 		if (!status.heap_returning_functions) status.heap_returning_functions = /* @__PURE__ */ new Set();
@@ -25837,10 +26353,19 @@ function build_return_node$1(node, status, nir_value) {
 					}
 					emit_string_field_strdups_at(status, ret_struct.name, "x8", 0, skip_fields);
 				}
-				if (node.value?.node_type === "func_call" && node.value.name === ret_struct.name && !ret_struct.name.startsWith("_") && !node.value.field_overrides?.length) {
-					const skip_fields = ctor_return_owned_string_fields(ret_struct, node.value, status.heap_strings);
+				if (node.value?.node_type === "func_call" && node.value.name === ret_struct.name && !ret_struct.name.startsWith("_")) {
+					const call = node.value;
+					const skip_fields = call.field_overrides?.length ? override_return_string_fields(ret_struct, call.field_overrides, status.heap_strings, { base_skip: ctor_return_owned_string_fields(ret_struct, call, status.heap_strings) }) : ctor_return_owned_string_fields(ret_struct, call, status.heap_strings);
 					emit_string_field_strdups_at(status, ret_struct.name, "x8", 0, skip_fields);
 				}
+				{
+					const anon = node.value?.node_type === "anon_struct" ? node.value : void 0;
+					const forwarded_base = node.value?.node_type === "func_call" && node.value.field_overrides?.length ? node.value : anon?.base && anon.base.node_type === "func_call" ? anon.base : void 0;
+					if (forwarded_base && node.value.name !== ret_struct.name && is_normalized_struct_call(forwarded_base, status)) {
+						const skip_fields = override_return_string_fields(ret_struct, anon ? anon.fields : node.value.field_overrides, status.heap_strings, { base_uniformly_owned: true });
+						emit_string_field_strdups_at(status, ret_struct.name, "x8", 0, skip_fields);
+					}
+				}
 				if (node.value?.node_type === "func_call" && String(node.value.name ?? "").startsWith("_Tuple_") && node.value.type?.name?.startsWith("_Tuple_")) {
 					const tuple_call = node.value;
 					const skip_fields = /* @__PURE__ */ new Set();
@@ -25943,6 +26468,8 @@ function build_switch_node$1(node, status, nir) {
 	const old_scoped_declarations = enter_scope_frame(status);
 	const pre_cache = status.buffer_data_cache;
 	const pre_array_cache = status.array_ptr_cache;
+	const pre_heap_string_fields = status.heap_string_fields;
+	const case_field_sets = [];
 	for (let i = 0; i < node.cases.length; i++) {
 		status.scoped_declarations = [];
 		build_node(node.cases[i].condition, status);
@@ -25951,7 +26478,9 @@ function build_switch_node$1(node, status, nir) {
 		else emit_asm(status, `beq end_switch_${label}\n`);
 		status.buffer_data_cache = new Map(pre_cache);
 		status.array_ptr_cache = new Map(pre_array_cache);
+		status.heap_string_fields = new Set(pre_heap_string_fields ?? []);
 		build_block_with_cursor$1(node.cases[i].branch, nir?.arms[i]?.branch, status);
+		case_field_sets.push(status.heap_string_fields);
 		emit_asm(status, `b end_switch_${label}\n`);
 		emit_asm(status, `sw_next_${label}_${i}:\n`);
 	}
@@ -25959,8 +26488,15 @@ function build_switch_node$1(node, status, nir) {
 		status.scoped_declarations = [];
 		status.buffer_data_cache = new Map(pre_cache);
 		status.array_ptr_cache = new Map(pre_array_cache);
+		status.heap_string_fields = new Set(pre_heap_string_fields ?? []);
 		build_block_with_cursor$1(node.else_branch, nir?.otherwise ?? void 0, status);
+		case_field_sets.push(status.heap_string_fields);
 	}
+	if (case_field_sets.length > 1) {
+		const merged = new Set(pre_heap_string_fields ?? []);
+		for (const set of case_field_sets) for (const key of set) merged.add(key);
+		status.heap_string_fields = merged;
+	} else if (case_field_sets.length === 1) status.heap_string_fields = case_field_sets[0];
 	status.buffer_data_cache = pre_cache;
 	status.array_ptr_cache = pre_array_cache;
 	emit_asm(status, `end_switch_${label}:\n`);
@@ -29628,6 +30164,12 @@ function build_function_call_node$1(node, status) {
 			if (build_inline_function(inline_candidate, status)) return;
 		}
 		emit_asm(status, `bl ${func_name}\n`);
+		{
+			const callee = node.resolved_function;
+			if (callee && !callee.params?.some((p) => p.is_self_param)) transfer_ref_param_field_records(callee, node.params, status, (name) => {
+				return !!status.scoped_declarations?.some((d) => d.name === name) && !is_local_ref_var(name, status);
+			});
+		}
 		if (is_float_type$1(node.type.name)) emit_asm(status, `fmov x0, d0\n`);
 		if (outgoing_size > 0) emit_asm(status, `add sp, sp, #${outgoing_size}\n`);
 		if (status.buffer_data_cache) {
@@ -29678,6 +30220,11 @@ function build_function_call_node$1(node, status) {
 		const offset = status.stack_offsets.get(temp_addr);
 		emit_asm(status, `add x0, x29, #${offset}\n`);
 		if (node.field_overrides?.length) {
+			const ctor_struct = status.structs.find((s) => s.name === node.name && !s.is_simple_type && !s.is_class);
+			if (ctor_struct) for (const fname of ctor_heap_displaced_string_fields(ctor_struct, node.field_overrides, (seed) => is_owned_heap_temp(seed, status))) {
+				emit_asm(status, `ldr x0, [x29, #${offset + get_field_offset(ctor_struct.name, fname, status)}]\n`);
+				emit_free(status);
+			}
 			emit_field_overrides(temp_addr, node, build_node, status);
 			emit_asm(status, `add x0, x29, #${offset}\n`);
 		}
@@ -30659,9 +31206,9 @@ function build_operation_node$1(node, status) {
 		if (left_type?.is_nullable && left_type.name === "string") {
 			status.code += `({ nomen_string _nss_${ns_tmp_counter} = `;
 			build_node$1(node.left_value, status);
-			status.code += `; _nss_${ns_tmp_counter}.ptr ? _nss_${ns_tmp_counter} : `;
+			status.code += `; _nss_${ns_tmp_counter}.ptr ? nomen_str_dup(_nss_${ns_tmp_counter}) : nomen_str_dup(`;
 			build_node$1(node.right_value, status);
-			status.code += `; })`;
+			status.code += `); })`;
 			ns_tmp_counter++;
 		} else if (is_nullable_scalar_type(left_type)) {
 			if (node.left_value.node_type === "func_call" && is_nullable_scalar_type(node.left_value.type)) {
@@ -32665,7 +33212,7 @@ function build_assignment_node$1(node, status, nir_rhs, nir_swap) {
 		status.code += `;\n`;
 		return;
 	}
-	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) {
+	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 && !node.raw_field_store) {
 		const access_lhs = node.left_value;
 		const field_access_node = access_lhs.access;
 		let target_type = type_from_value_node$1(access_lhs.target);
@@ -32953,7 +33500,10 @@ function build_assignment_node$1(node, status, nir_rhs, nir_swap) {
 					const needs_destroy = struct_type ? struct_needs_destroy_by_name(struct_type.name, status) : false;
 					const rhs_is_free_factory = node.right_value.node_type === "func_call" && !rhs_references_var(node, lhs_name);
 					if (is_fresh_constructor(node, status) || rhs_is_free_factory) {
-						if (struct_type) release_recorded_string_fields(status, struct_type, lhs_name);
+						if (struct_type) {
+							release_recorded_string_fields(status, struct_type, lhs_name);
+							if (node.right_value.node_type === "func_call" && node.right_value.name === struct_type.name) record_ctor_heap_default_fields(lhs_name, struct_type, status, (seed) => is_owned_heap_temp$1(seed, status), new Set(node.right_value.field_overrides?.map((o) => o.name) ?? []));
+						}
 						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);
@@ -32998,6 +33548,12 @@ function build_assignment_node$1(node, status, nir_rhs, nir_swap) {
 			}
 		}
 	}
+	if (!node.operator && node.left_value.node_type === "access" && node.left_value.access.node_type === "access_field" && node.left_value.target.node_type === "value" && node.left_value.target.value === "self" && status.current_function?.name === "#init" && claim_init_default_seed_reclaim(status, node.left_value.access.name, (expr) => is_owned_heap_temp$1(expr, status))) {
+		const saved_seed_len = begin_code_scratch(status);
+		build_node$1(node.left_value, status);
+		const seed_access = end_code_scratch(status, saved_seed_len);
+		status.code += `free(${seed_access}.ptr);\n`;
+	}
 	build_node$1(node.left_value, status);
 	if (node.operator) status.code += ` ${node.operator.slice(0, -1)}= `;
 	else status.code += " = ";
@@ -33006,7 +33562,15 @@ function build_assignment_node$1(node, status, nir_rhs, nir_swap) {
 	else emit_rhs_value$1(node.right_value, nir_rhs, status);
 	if (node.left_value.node_type === "value" && has_field_overrides(node.right_value)) {
 		const lname = node.left_value.value;
-		emit_field_overrides(lname, node.right_value, build_node$1, status, ";\n", ";\n");
+		const rhs_call = node.right_value.node_type === "func_call" ? node.right_value : void 0;
+		if (rhs_call?.field_overrides?.length && rhs_call.name === rhs_call.type?.name) {
+			const override_struct = status.structs.find((s) => s.name === rhs_call.name && !s.is_simple_type && !s.is_class);
+			if (override_struct) {
+				status.code += `;\n`;
+				for (const name of override_displaced_string_fields(override_struct, rhs_call.field_overrides, (expr) => is_owned_heap_temp$1(expr, status))) status.code += `free(${lname}.${name}.ptr);\n`;
+			}
+		}
+		emit_field_overrides(lname, node.right_value, build_node$1, status, rhs_call?.field_overrides?.length && rhs_call.name === rhs_call.type?.name ? "" : ";\n", ";\n");
 	}
 	if (node.swap) {
 		status.code += `;\n`;
@@ -33913,8 +34477,20 @@ function build_declaration_node(node, status, nir_init, nir_swap) {
 				status.code += `${field_access} = `;
 				emit_swap_value$1(node.swap, nir_swap, status);
 			}
-			if (has_field_overrides(node.value)) emit_field_overrides(safe_name, node.value, build_node$1, status, ";\n", ";\n");
 			record_call_init_string_fields(node, status);
+			const override_ctor_call = node.value?.node_type === "func_call" && node.value.field_overrides?.length && node.type?.name && node.value.name === node.type.name ? node.value : void 0;
+			if (override_ctor_call) {
+				const override_struct = status.structs.find((s) => s.name === node.type.name && !s.is_simple_type && !s.is_class);
+				if (override_struct) {
+					status.code += `;\n`;
+					for (const name of override_displaced_string_fields(override_struct, override_ctor_call.field_overrides, (expr) => is_owned_heap_temp$1(expr, status))) status.code += `free(${safe_name}.${name}.ptr);\n`;
+				}
+			}
+			if (node.value?.node_type === "func_call" && node.value.name === node.type?.name && !is_normalized_struct_call(node.value, status)) {
+				const ctor_struct = status.structs.find((s) => s.name === node.type.name && !s.is_simple_type && !s.is_class);
+				if (ctor_struct) record_ctor_heap_default_fields(safe_name, ctor_struct, status, (seed) => is_owned_heap_temp$1(seed, status), new Set(node.value.field_overrides?.map((o) => o.name) ?? []));
+			}
+			if (has_field_overrides(node.value)) emit_field_overrides(safe_name, node.value, build_node$1, status, override_ctor_call ? "" : ";\n", ";\n");
 		}
 	}
 }
@@ -34207,21 +34783,32 @@ function build_if_else_node(node, status, nir) {
 	status.scoped_declarations = enter_c_scope(status);
 	const old_deferred_frees = status.deferred_frees;
 	status.deferred_frees = [];
+	const pre_heap_string_fields = status.heap_string_fields;
 	emit_allocations(node.condition, status);
 	status.code += `if (`;
 	build_condition(node.condition, status);
 	status.code += `) {\n`;
+	let then_fields;
 	if (node.if_branch) {
 		build_block_with_cursor(node.if_branch, nir?.then_branch, status);
 		build_auto_free(status);
 	}
+	then_fields = status.heap_string_fields;
 	leave_c_scope(status);
 	if (node.else_branch) {
 		status.scoped_declarations = enter_c_scope(status);
 		status.deferred_frees = [];
+		status.heap_string_fields = pre_heap_string_fields;
 		status.code += `} else {\n`;
 		build_block_with_cursor(node.else_branch, nir?.else_branch, status);
 		build_auto_free(status);
+		const else_fields = status.heap_string_fields;
+		if (else_fields !== then_fields) {
+			const merged = new Set(pre_heap_string_fields ?? []);
+			for (const key of then_fields ?? []) merged.add(key);
+			for (const key of else_fields ?? []) merged.add(key);
+			status.heap_string_fields = merged;
+		}
 		leave_c_scope(status);
 	}
 	status.code += `}\n`;
@@ -34558,14 +35145,31 @@ function build_return_node(node, status, nir_value) {
 		if (!returns_string_zero && !returns_struct_zero && !returns_view_value && (returns_borrowed_string || returns_string_literal || returns_borrow_var)) status.code += `)`;
 		status.code += `;\n`;
 		if (node.value.node_type === "access" && node.value.access?.node_type === "access_field" && !returns_string_zero && !returns_struct_zero && !returns_view_value && ret_type.name !== "string" && !ret_type.is_view && !ret_type.is_array && status.enums.find((e) => e.name === ret_type.name && e.has_associated_data)) status.code += `_return_val = ${ret_type.name}_copy(_return_val);\n`;
+		const forwarded_override_base = node.value?.node_type === "func_call" && node.value.field_overrides?.length ? node.value : node.value?.node_type === "anon_struct" && node.value.base ? node.value.base : void 0;
+		if (is_struct && !return_is_class && return_struct && forwarded_override_base?.node_type === "func_call" && node.value.name !== return_struct.name && is_normalized_struct_call(forwarded_override_base, status)) {
+			const overrides = node.value.node_type === "func_call" ? node.value.field_overrides : node.value.fields;
+			for (const field of direct_string_fields(return_struct)) {
+				if (!overrides?.some((o) => o.name === field.name)) continue;
+				status.code += `free(_return_val.${field.name}.ptr);\n`;
+			}
+		}
+		if (is_struct && !return_is_class && return_struct && node.value?.node_type === "func_call" && node.value.name === return_struct.name) for (const name of override_displaced_string_fields(return_struct, node.value.field_overrides, (expr) => is_owned_heap_temp$1(expr, status))) status.code += `free(_return_val.${name}.ptr);\n`;
 		if (has_field_overrides(node.value)) emit_field_overrides("_return_val", node.value, build_node$1, status, "", ";\n");
 		const bare_local_return = node.value.node_type === "value" && node.value.value !== "0" && node.value.value !== "null" && !!returned_value_decl;
 		if (is_struct && !return_is_class && !ret_type.is_view && !ret_type.is_array && return_struct && !returns_struct_zero && bare_local_return) for (const field of direct_string_fields(return_struct)) {
 			if (returned_recorded_string_fields?.has(field.name)) continue;
 			status.code += `_return_val.${field.name} = nomen_str_dup(_return_val.${field.name});\n`;
 		}
-		if (is_struct && !return_is_class && !ret_type.is_view && !ret_type.is_array && return_struct && !returns_struct_zero && node.value?.node_type === "func_call" && node.value.name === return_struct.name && !return_struct.name.startsWith("_") && !node.value.field_overrides?.length) {
-			const skip = ctor_return_owned_string_fields(return_struct, node.value, status.heap_strings);
+		if (is_struct && !return_is_class && !ret_type.is_view && !ret_type.is_array && return_struct && !returns_struct_zero && node.value?.node_type === "func_call" && node.value.name === return_struct.name && !return_struct.name.startsWith("_")) {
+			const call = node.value;
+			const skip = call.field_overrides?.length ? override_return_string_fields(return_struct, call.field_overrides, status.heap_strings, { base_skip: ctor_return_owned_string_fields(return_struct, call, status.heap_strings) }) : ctor_return_owned_string_fields(return_struct, call, status.heap_strings);
+			for (const field of direct_string_fields(return_struct)) {
+				if (skip.has(field.name)) continue;
+				status.code += `_return_val.${field.name} = nomen_str_dup(_return_val.${field.name});\n`;
+			}
+		}
+		if (is_struct && !return_is_class && !ret_type.is_view && !ret_type.is_array && return_struct && !returns_struct_zero && forwarded_override_base?.node_type === "func_call" && node.value.name !== return_struct.name && is_normalized_struct_call(forwarded_override_base, status)) {
+			const skip = override_return_string_fields(return_struct, node.value.node_type === "func_call" ? node.value.field_overrides : node.value.fields, status.heap_strings, { base_uniformly_owned: true });
 			for (const field of direct_string_fields(return_struct)) {
 				if (skip.has(field.name)) continue;
 				status.code += `_return_val.${field.name} = nomen_str_dup(_return_val.${field.name});\n`;
@@ -34623,9 +35227,12 @@ function nullable_flag_expr_of_value(value, status) {
 //#region ../src/build_c/build_switch_node.ts
 function build_switch_node(node, status, nir) {
 	const old_scoped_declarations = status.scoped_declarations;
+	const pre_heap_string_fields = status.heap_string_fields;
+	const case_field_sets = [];
 	for (let i = 0; i < node.cases.length; i++) {
 		const c = node.cases[i];
 		status.scoped_declarations = enter_c_scope(status);
+		status.heap_string_fields = pre_heap_string_fields;
 		const saved_code = begin_code_scratch(status);
 		build_node$1(c.condition, status);
 		let cond_code = end_code_scratch(status, saved_code);
@@ -34665,17 +35272,28 @@ function build_switch_node(node, status, nir) {
 		status.code += `if (${cond_code}) {\n`;
 		build_block_with_cursor(c.branch, nir?.arms[i]?.branch, status);
 		build_auto_free(status);
+		case_field_sets.push(status.heap_string_fields);
 		leave_c_scope(status);
 	}
 	if (node.else_branch) {
 		status.code += "} else ";
 		status.scoped_declarations = enter_c_scope(status);
+		status.heap_string_fields = pre_heap_string_fields;
 		status.code += `{\n`;
 		build_block_with_cursor(node.else_branch, nir?.otherwise ?? void 0, status);
 		build_auto_free(status);
+		case_field_sets.push(status.heap_string_fields);
 		status.code += `}\n`;
 		leave_c_scope(status);
 	} else if (node.cases.length > 0) status.code += "}\n";
+	if (case_field_sets.length > 1) {
+		const first = case_field_sets[0];
+		if (!case_field_sets.every((s) => s === first)) {
+			const merged = new Set(pre_heap_string_fields ?? []);
+			for (const set of case_field_sets) for (const key of set ?? []) merged.add(key);
+			status.heap_string_fields = merged;
+		}
+	}
 	status.scoped_declarations = old_scoped_declarations;
 }
 //#endregion
@@ -35458,6 +36076,10 @@ function build_struct_node(node, status) {
 			if (node.traits.length) status.code += `self${accessor}_vt = &_${node.name}_traits;\n`;
 			const old_init_assigned_fields = status.init_assigned_fields;
 			status.init_assigned_fields = /* @__PURE__ */ new Set();
+			const old_init_default_reclaimed = status.init_default_reclaimed_fields;
+			status.init_default_reclaimed_fields = /* @__PURE__ */ new Set();
+			const old_init_heap_string_fields = status.heap_string_fields;
+			status.heap_string_fields = void 0;
 			for (const field of node.fields) if (field.value) {
 				status.init_assigned_fields?.add(`self.${field.name}`);
 				if (field.type.is_view && !field.type.is_array && !is_nullable_struct_type(field.type, status)) {
@@ -35525,6 +36147,8 @@ function build_struct_node(node, status) {
 			status.current_struct = old_current_struct;
 			status.current_function = old_current_function;
 			status.init_assigned_fields = old_init_assigned_fields;
+			status.init_default_reclaimed_fields = old_init_default_reclaimed;
+			status.heap_string_fields = old_init_heap_string_fields;
 			status.function_return_type = old_return_type;
 		}
 		build_struct_functions(node, status, true);
@@ -36441,6 +37065,8 @@ function build_function_node(node, status) {
 	status.heap_strings = /* @__PURE__ */ new Set();
 	const old_owned_string_vars = status.owned_string_vars;
 	status.owned_string_vars = /* @__PURE__ */ new Set();
+	const old_heap_string_fields = status.heap_string_fields;
+	status.heap_string_fields = void 0;
 	const old_heap_array_vars = status.heap_array_vars;
 	status.heap_array_vars = void 0;
 	const old_stack_array_lengths = status.stack_array_lengths;
@@ -36658,6 +37284,7 @@ function build_function_node(node, status) {
 	status.aliased_class_sources = old_aliased_class_sources;
 	status.string_borrow_vars = old_string_borrow_vars;
 	status.moved_string_vars = old_moved_string_vars;
+	status.heap_string_fields = old_heap_string_fields;
 	status.heap_strings = old_heap_strings;
 	status.owned_string_vars = old_owned_string_vars;
 	status.heap_array_vars = old_heap_array_vars;
@@ -37090,6 +37717,12 @@ function build_function_call_node(node, status) {
 		const call_text = end_code_scratch(status, saved_call);
 		status.code += `({ unsigned char _nsd_${wrap_tmp} = 0; ${call_text}; })`;
 	}
+	{
+		const callee = node.resolved_function;
+		if (callee && !callee.params?.some((p) => p.is_self_param)) transfer_ref_param_field_records(callee, node.params, status, (name) => {
+			return !!find_decl_in_c_scopes(status, name) && !status.function_ref_params?.has(name) && !status.ref_class_params?.has(name) && !status.class_vars?.has(name);
+		});
+	}
 	if (node.name.startsWith("_string_interpolate_")) status.interpolate_string_counts.add(node.params.length - 1);
 	if (node.swap_params?.size) for (const [idx, swap_expr] of node.swap_params) {
 		const source = node.params[idx];
@@ -37497,6 +38130,10 @@ function build_access_node$1(node, status) {
 				return;
 			}
 			if (target_type.is_array && access_field.name === "length") {
+				if (node.target.node_type === "value" && !!status.current_function?.params.some((p) => !p.is_self_param && p.name === node.target.value) && target_type.length) {
+					build_node$1(target_type.length, status);
+					return;
+				}
 				const type = c_type(target_type.name);
 				status.code += "(sizeof(";
 				build_node$1(node.target, status);
@@ -37865,6 +38502,10 @@ function build_access_node$1(node, status) {
 						}
 					}
 				}
+				{
+					const ref_method = target_method ?? trait_default_func;
+					if (ref_method) transfer_ref_param_field_records(ref_method, access_func.params ?? [], status, (name) => !!find_decl_in_c_scopes(status, name) && !status.function_ref_params?.has(name) && !status.ref_class_params?.has(name) && !status.class_vars?.has(name));
+				}
 				const method_callee_params = (target_method ?? trait_default_func)?.params?.filter((p) => !p.is_self_param);
 				const lambda_arg_temps = /* @__PURE__ */ new Map();
 				for (let i = 0; i < access_func.params.length; i++) {
@@ -40283,6 +40924,11 @@ function build_assignment_node(node, status, nir_rhs, nir_swap) {
 				emit_var_address(status, "x1", name);
 				emit_struct_copy("x0", "x1", 0, struct_size, status);
 			}
+			if (node.right_value.node_type === "func_call" && !paramReg && !is_local_ref_var(name, status)) {
+				const rhs_call = node.right_value;
+				const rhs_ctor_struct = status.structs.find((s) => s.name === rhs_call.name && !s.is_simple_type && !s.is_class);
+				if (rhs_ctor_struct) record_ctor_heap_default_fields(name, rhs_ctor_struct, status, (seed) => is_owned_heap_temp(seed, status), new Set(rhs_call.field_overrides?.map((o) => o.name) ?? []));
+			}
 			if (has_field_overrides(node.right_value)) emit_field_overrides(name, node.right_value, build_node, status);
 			build_swap(node, status, nir_swap);
 			return;
@@ -40503,12 +41149,13 @@ function build_assignment_node(node, status, nir_rhs, nir_swap) {
 			const move_source = rhs_is_string_var && node.last_use_move && move_on_last_use_enabled() ? rhs_value.value : void 0;
 			const explicit_move_source = !node.swap && !!rhs_value && rhs_value.is_moved && size === 16 && rhs_value.type?.name === "string" && !rhs_value.type?.is_view ? rhs_value.value : void 0;
 			const borrow_needs_dup = !node.swap && size === 16 && is_string_borrow(node.right_value) && !!status.force_heap_strings?.has(name);
+			const move_source_owns_heap = move_source !== void 0 && !!status.heap_strings?.has(move_source);
 			if (rhs_is_view_into_owned) {
 				if (!status.heap_strings) status.heap_strings = /* @__PURE__ */ new Set();
 				status.heap_strings.add(name);
-			} else if (rhs_is_string_var && move_source === void 0 || borrow_needs_dup) emit_strdup_string(status);
+			} else if (rhs_is_string_var && (move_source === void 0 || !move_source_owns_heap) || borrow_needs_dup) emit_strdup_string(status);
 			if (rhs_is_string_var || borrow_needs_dup) {
-				if (move_source !== void 0) status.heap_strings?.delete(move_source);
+				if (move_source !== void 0 && move_source_owns_heap) status.heap_strings?.delete(move_source);
 				if (!status.heap_strings) status.heap_strings = /* @__PURE__ */ new Set();
 				status.heap_strings.add(name);
 			} else if (status.last_result_is_heap) {
@@ -40586,7 +41233,7 @@ function build_assignment_node(node, status, nir_rhs, nir_swap) {
 						emit_asm(status, `str xzr, [x0, #${offset + 8}]\n`);
 					}
 				}
-			} else if (field_is_struct_string(target_type, field_type, status) && !node.operator && (() => {
+			} else if (field_is_struct_string(target_type, field_type, status) && !node.operator && !node.raw_field_store && (() => {
 				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";
@@ -40614,12 +41261,16 @@ function build_assignment_node(node, status, nir_rhs, nir_swap) {
 					ensure_newline(status);
 				}
 				let rhs_is_heap = status.last_result_is_heap;
-				const rhs_value_node = node.right_value.node_type === "value" ? node.right_value : void 0;
-				if (!rhs_is_heap && !rhs_is_null_literal && !!rhs_value_node && typeof rhs_value_node.value === "string" && rhs_value_node.type?.name === "string" && !!status.heap_strings?.has(rhs_value_node.value)) {
-					emit_strdup(status);
+				if (rhs_is_null_literal) {} else if (!rhs_is_heap) {
+					const rhs_type_nullable = !!node.right_value.type?.is_nullable;
+					if (field_type?.is_nullable || rhs_type_nullable) {
+						const skip_dup = `.Lskip_field_dup_${status.label_counter = (status.label_counter ?? 0) + 1}`;
+						emit_asm(status, `cbz x0, ${skip_dup}\n`);
+						emit_strdup(status);
+						emit_asm(status, `${skip_dup}:\n`);
+					} else emit_strdup(status);
 					rhs_is_heap = true;
 				}
-				if (rhs_is_null_literal) {} else if (is_class_target && !rhs_is_heap) emit_strdup(status);
 				mark_moved_if_struct(node.right_value, status);
 				if (field_type?.name === "string") {
 					emit_asm(status, `stp x0, x1, [sp, #-16]!\n`);
@@ -40805,6 +41456,14 @@ function build_assignment_node(node, status, nir_rhs, nir_swap) {
 						get_base_address(access, status, "x0");
 						emit_asm(status, `str x0, [sp, #-16]!\n`);
 					}
+					if (!node.operator && access.target.node_type === "value" && access.target.value === "self" && status.current_function?.name === "#init" && claim_init_default_seed_reclaim(status, field_name, (expr) => is_owned_heap_temp(expr, status))) {
+						if (base_reg !== void 0) emit_asm(status, `ldr x0, [${base_reg}, #${offset}]\n`);
+						else {
+							emit_asm(status, `ldr x0, [sp]\n`);
+							emit_asm(status, `ldr x0, [x0, #${offset}]\n`);
+						}
+						emit_free(status);
+					}
 					emit_rhs_value(node.right_value, nir_rhs, status);
 					ensure_newline(status);
 					mark_moved_if_struct(node.right_value, status);
@@ -44856,7 +45515,10 @@ function build_access_method(node, access_func, 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 (target_method) {
+			drop_self_written_string_field_records(status, node.target.value, scan_self_string_field_writes(target_struct, target_method));
+			transfer_ref_param_field_records(target_method, access_func.params ?? [], status, (name) => !!status.scoped_declarations?.some((d) => d.name === name) && !is_local_ref_var(name, status));
+		}
 	}
 	if (method_name.endsWith("_to_string") && method_name !== "string_to_string") status.last_result_is_heap = true;
 	if (trait_target && trait_func?.return_type?.name === "string" && !trait_func.return_type?.is_view && trait_method_all_conformers_owned(trait_target, access_func.name, status)) status.last_result_is_heap = true;
@@ -45895,10 +46557,14 @@ function gather_normalized_struct_returners(root, status) {
 			if (!return_normalizing.has(fn.name)) continue;
 			const ret_struct = structs.find((st) => st.name === fn.return_type?.name && !st.is_simple_type && !st.is_class);
 			for (const ret of direct_returns(fn)) {
-				const value = ret.value ?? void 0;
+				let value = ret.value ?? void 0;
+				if (value?.node_type === "anon_struct") {
+					const base = value.base;
+					if (base?.node_type === "func_call") value = base;
+				}
 				if (value && value.node_type === "value") continue;
 				if (value && value.node_type === "func_call" && return_normalizing.has(value.name ?? "")) continue;
-				if (value && value.node_type === "func_call" && !!ret_struct && value.name === ret_struct.name && !ret_struct.name.startsWith("_") && !value.field_overrides?.length) continue;
+				if (value && value.node_type === "func_call" && !!ret_struct && !ret_struct.name.startsWith("_") && (value.name === ret_struct.name || !!value.field_overrides?.length && return_normalizing.has(value.name ?? ""))) continue;
 				return_normalizing.delete(fn.name);
 				changed = true;
 				break;
@@ -46130,7 +46796,7 @@ function build(root, options = {}) {
 			status.code = status.code + "\n" + status.c_runtime_defs;
 			status.c_runtime_defs = void 0;
 		}
-		status.code = "typedef struct { void* ptr; long len; } nomen_view;\ntypedef struct { char* ptr; long len; } nomen_string;\n#define nomen_str_lit(s, n) ((nomen_string){ (s), (long)(n) })\n#include <string.h>\n" + (options.audit ? `void *nomen_strdup_wrap(const char *);\n` : "") + "static nomen_string nomen_str_dup(nomen_string s) {\n	nomen_string r = { strdup(s.ptr), s.len };\n	return r;\n}\n" + status.code;
+		status.code = "typedef struct { void* ptr; long len; } nomen_view;\ntypedef struct { char* ptr; long len; } nomen_string;\n#define nomen_str_lit(s, n) ((nomen_string){ (s), (long)(n) })\n#include <string.h>\n" + (options.audit ? `void *nomen_strdup_wrap(const char *);\n` : "") + "static nomen_string nomen_str_dup(nomen_string s) {\n	if (!s.ptr) return s;\n	nomen_string r = { strdup(s.ptr), s.len };\n	return r;\n}\n" + status.code;
 		if (options.audit) {
 			status.code = wrap_c_allocators(status.code);
 			status.headers = "void *nomen_malloc_wrap(unsigned long);\nvoid *nomen_calloc_wrap(unsigned long, unsigned long);\nvoid *nomen_realloc_wrap(void *, unsigned long);\nvoid nomen_free_wrap(void *);\nvoid *nomen_strdup_wrap(const char *);\nvoid nomen_audit_check(void);\n" + wrap_c_allocators(status.headers);
@@ -51469,6 +52135,21 @@ function check_struct_node(struct, status) {
 	status.values.length = values_length_before_fields;
 	rewrite_generic_buffer_fields(struct, status);
 	mark_owning_auto_init_params(struct, status);
+	if (!struct.is_library) for (const field of struct.fields) {
+		if (field.declaration !== "move") continue;
+		if (!field.type.name || field.type.is_ref || field.type.is_view) continue;
+		if (field.type.is_nullable) continue;
+		if (is_class_type$1(field.type.name, status)) continue;
+		if (status.traits.find((t) => t.name === field.type.name)) continue;
+		if (!is_owning_struct_type_requiring_move(new Type(mono_type_name(field.type)), status)) continue;
+		if (!status.warnings) status.warnings = [];
+		status.warnings.push({
+			message: `'move' on field '${field.name}' is redundant: '${type_display(field.type)}' is a value struct — its ownership is derived from the type, so plain 'var' behaves identically`,
+			start: field.start,
+			line: 0,
+			column: 0
+		});
+	}
 	status.types.push(struct.name);
 	status.structs.push(struct);
 	for (let func of struct.functions) {
@@ -51649,6 +52330,11 @@ function signature_matches(struct_func, trait_func, substitution) {
 function types_match(a, b) {
 	return a.name === b.name && !!a.is_ref === !!b.is_ref && !!a.is_view === !!b.is_view && !!a.is_array === !!b.is_array;
 }
+/** The user-visible spelling of a type (`List<int>`, `Map<string, int>`). */
+function type_display(t) {
+	if (!t.type_args?.length) return t.name ?? "?";
+	return `${t.name}<${t.type_args.map(type_display).join(", ")}>`;
+}
 //#endregion
 //#region ../src/check/utils/auto_derive.ts
 function struct_has_function(struct, name) {
@@ -55252,7 +55938,14 @@ function check_function_call(node, status, func, target_type, self_value, self_p
 			const named = status.functions.findLast((f) => f.name === param_value);
 			if (named) param.resolved_function = named;
 		}
-		if (param_type.is_array && param_type.length && !func_param.type.length) func_param.type.length = param_type.length;
+		if (param_type.is_array && param_type.length && !func_param.is_variadic) {
+			if (!func_param.type.length) func_param.type.length = param_type.length;
+			else {
+				const stamped = String(func_param.type.length.value);
+				const incoming = String(param_type.length.value);
+				if (stamped !== incoming) add_error(status, `Call passes ${incoming} elements to array parameter '${func_param.name}' whose compile-time length is ${stamped} — the raw array ABI carries no runtime length, so one parameter serves one compile-time length; use Array<${func_param.type.name}> for varying lengths`, param.start);
+			}
+		}
 		let arg_value;
 		if (param.node_type === "value") {
 			const vn = param;
@@ -56603,7 +57296,7 @@ function check_as_array_or_inferred_tuple(array, status, forced_tuple_types) {
 		array.type.is_array = true;
 		array.type.is_nullable = old_expected.is_nullable;
 		array.type.type_args = old_expected.type_args;
-		array.type.length = old_expected.length;
+		if (!old_expected.length || String(old_expected.length.value) === String(array.values.length)) array.type.length = old_expected.length;
 	} else if (!array.type.name) {
 		const first_type = value_types[0];
 		if (first_type) {
@@ -57954,6 +58647,11 @@ function check_switch_node(switch_node, status) {
 	let branch_statuses = [];
 	for (let switch_case of switch_node.cases) {
 		check_node(switch_case.condition, status);
+		if (status.allocations.length) {
+			switch_case.condition.allocations ??= [];
+			switch_case.condition.allocations.push(...status.allocations);
+			status.allocations.length = 0;
+		}
 		const condition_type = type_from_value_node(switch_case.condition, status);
 		if (!is_bool_condition(condition_type)) add_error(status, `Switch case condition must be a bool, not ${type_name(condition_type)}`, switch_case.condition.start);
 		let case_status = clone_status(status);