nomen-lang 0.6.5 → 0.6.7

package/dist/index.mjs

@@ -7147,14 +7147,37 @@ function call_result_type(node) {
 * so `null == 0` conflates them. Nullable `string` (in-band fat zero) and
 * nullable `func`/class values (null pointer) keep their in-band null and
 * are NOT nullable scalars.
+*
+* The same holds for a nullable SIMPLE enum (`Color?`) or bitset
+* (`Permissions?`): the in-band zero (the first case's tag 0 / an empty
+* bitset) is a real value, so `null` needs the companion flag. Enum-with-data
+* and generic template enums are NOT nullable scalars — the checker rejects
+* `?` on enums with associated data, so every nullable enum that reaches the
+* backends is simple.
 */
-/** True if `type` is a nullable built-in scalar (`bool?`, `int?`, `float?`, …). */
-function is_nullable_scalar_type(type) {
+/** True if the TYPE NAME is a built-in scalar, simple enum, or bitset — the
+*  shapes that get the `<slot>_has` flag when nullable. */
+function is_nullable_scalar_name(name, tables) {
+	if (!name) return false;
+	const info = get_built_in_type(name);
+	if (info) return info.kind !== "string" && info.kind !== "func";
+	const enum_node = tables.enums.findLast((e) => (e.name === name || e.source_name === name) && !e.is_generic);
+	if (enum_node) return !enum_node.has_associated_data;
+	return tables.bitsets.some((b) => b.name === name || b.source_name === name);
+}
+/** True if `type` is a nullable built-in scalar, simple enum, or bitset. */
+function is_nullable_scalar_type(type, tables) {
 	if (!type?.is_nullable) return false;
 	if (type.is_array || type.is_ref || type.storage_kind === "view") return false;
 	if (type.is_pointer) return false;
-	const info = type.name ? get_built_in_type(type.name) : void 0;
-	return !!info && info.kind !== "string" && info.kind !== "func";
+	return is_nullable_scalar_name(type.name, tables);
+}
+/** True if `type` is a nullable struct (see nullable_struct.ts) or nullable scalar. */
+function is_nullable_flagged_type(type, status) {
+	if (!type?.is_nullable) return false;
+	if (type.name === "string") return false;
+	if (type.name === "func") return false;
+	return is_nullable_scalar_type(type, status) || !!status.structs.find((s) => s.name === type.name && !s.is_class && !s.is_simple_type);
 }
 //#endregion
 //#region ../src/build_common/nullable_struct.ts
@@ -7546,7 +7569,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 +7613,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 +7625,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
@@ -7914,7 +8107,7 @@ var AssignmentNode = class extends BaseNode {
 		super("assign", start);
 		this.left_value = left_value;
 		this.right_value = right_value;
-		this.operator = operator;
+		this.operator = operator === "=" ? void 0 : operator;
 	}
 };
 //#endregion
@@ -7943,13 +8136,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 +8267,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 +8630,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 +8678,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 +9189,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;
@@ -11697,7 +12034,7 @@ function get_struct_size(name, status) {
 		size = align_to(size, get_type_alignment(field.type, status));
 		size += get_type_size(field.type, status);
 		if (is_nullable_struct_type(field.type, status)) size += 8;
-		else if (is_nullable_scalar_type(field.type)) size += 1;
+		else if (is_nullable_scalar_type(field.type, status)) size += 1;
 	}
 	size = align_to(size, 8);
 	return size;
@@ -11749,7 +12086,7 @@ function get_field_offset_of_fields(fields, field_name, status) {
 		if (field.name === field_name) return offset;
 		offset += get_type_size(field.type, status);
 		if (is_nullable_struct_type(field.type, status)) offset += 8;
-		else if (is_nullable_scalar_type(field.type)) offset += 1;
+		else if (is_nullable_scalar_type(field.type, status)) offset += 1;
 	}
 	return offset;
 }
@@ -14891,10 +15228,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
@@ -17404,7 +17752,7 @@ function owning_buffer_element_aarch64(node, status) {
 	const elem_name = node.name.substring(7);
 	const elem = status.structs.find((s) => s.name === elem_name && !s.is_simple_type && !s.is_generic);
 	if (!elem || elem.is_class) return void 0;
-	if (!has_string_fields(elem, status)) return void 0;
+	if (!has_string_fields(elem, status) && !struct_needs_destroy(elem, status)) return void 0;
 	return elem;
 }
 /**
@@ -17550,6 +17898,75 @@ function collect_string_fields(elem, status, base_offset = 0) {
 	return result;
 }
 /**
+* Collect the (offset, size) pairs of every owned CONTAINER field (`List<T>`/
+* `Buffer<T>`/… mono with a `#destroy`) the element's teardown would reclaim.
+* The owning store_T/replace_T memcpy the source's bytes into the slot, so
+* zeroing these fields of the SOURCE completes the ownership transfer: the
+* slot is the sole owner and the source's own teardown (when it still runs)
+* finds zeroed fields. Nested value struct fields recurse so their container
+* leaves are zeroed at their own flat offsets; their string fields are
+* untouched (the slot owns the strdup'd copies via collect_string_fields).
+* Mirrors the C backend's `emit_transfer_owning_fields`. `view T`/nullable
+* fields are skipped; class/enum payload fields are left alone (recorded in
+* FOLLOWUP.md).
+*/
+function collect_transfer_fields(elem, status, base_offset = 0) {
+	const result = [];
+	let offset = 8;
+	for (const field of elem.fields) {
+		const size = get_type_size(field.type, status);
+		if (!field.type.is_ref && !field.type.is_view && !field.type.is_array && !field.type.is_nullable) {
+			const field_struct = resolve_struct_type(field.type, status);
+			if (field_struct && !field_struct.is_class) {
+				if (has_destroy(field_struct)) result.push({
+					offset: base_offset + offset,
+					size
+				});
+				else if (struct_needs_destroy(field_struct, status)) result.push(...collect_transfer_fields(field_struct, status, base_offset + offset));
+			}
+		}
+		offset += size;
+	}
+	return result;
+}
+/**
+* Emit `memset(&src.field, 0, size)` for every owned field collected by
+* `collect_transfer_fields`. `src` is the register holding the SOURCE struct
+* address (x2 inline / x21 standalone for store_T). Clobbers x0-x2.
+*/
+function emit_transfer_owning_fields$1(status, src, fields) {
+	for (const { offset, size } of fields) {
+		emit_asm(status, `add x0, ${src}, #${offset}\n`);
+		emit_asm(status, `mov x1, #0\n`);
+		emit_asm(status, `mov x2, #${size}\n`);
+		emit_asm(status, `bl _memset\n`);
+	}
+}
+/**
+* Emit the deep-copy half of owning load_T into the sret buffer (x8): for
+* each `List<T>` field whose mono has a `copy` method, replace the
+* shallow-copied field with `<List_T>_copy(&slot.field)` (sret → the sret
+* buffer's field; self == x8 is safe — the copy reads its input before the
+* final result write). Mirrors the C backend's `emit_load_deep_copy_fields`.
+* `sret` is the register holding the returned struct's address; `slot` holds
+* the source slot's address (the copy reads from the slot, writes to sret).
+*/
+function emit_load_deep_copy_fields$1(elem, status, sret, slot) {
+	let offset = 8;
+	for (const field of elem.fields) {
+		const size = get_type_size(field.type, status);
+		if (!field.type.is_ref && !field.type.is_view && !field.type.is_array && !field.type.is_nullable && field.type.name !== "string") {
+			const field_struct = resolve_struct_type(field.type, status);
+			if (field_struct && !field_struct.is_class && field_struct.name.startsWith("List_") && struct_needs_destroy(field_struct, status) && field_struct.functions.find((f) => f.name === "copy")) {
+				emit_asm(status, `add x8, ${sret}, #${offset}\n`);
+				emit_asm(status, `add x0, ${slot}, #${offset}\n`);
+				emit_asm(status, `bl ${field_struct.name}_copy\n`);
+			}
+		}
+		offset += size;
+	}
+}
+/**
 * Emit `slot.field = strdup(src.field)` guarded against a NULL source field
 * (e.g. JsonTree's "no text" sentinel): a NULL field is copied as NULL —
 * strdup(NULL) would crash. `src`/`dst` are the register names holding the
@@ -17587,6 +18004,10 @@ function emit_owning_buffer_inline_aarch64(struct_node, func_name, status) {
 			emit_owning_shift_T(elem, status, "x0");
 			return true;
 		}
+		if (func_name === "load") {
+			emit_owning_load_T(elem, status, "x0");
+			return true;
+		}
 		return false;
 	}
 	const enum_elem = owning_buffer_enum_element_aarch64(struct_node, status);
@@ -17648,7 +18069,7 @@ function emit_owning_buffer_inline_aarch64(struct_node, func_name, status) {
 function emit_owning_buffer_standalone_aarch64(node, func_name, status) {
 	const elem = owning_buffer_element_aarch64(node, status);
 	if (elem) {
-		if (func_name !== "store" && func_name !== "replace" && func_name !== "shift" && func_name !== "modify") return false;
+		if (func_name !== "store" && func_name !== "replace" && func_name !== "shift" && func_name !== "modify" && func_name !== "load") return false;
 		emit_owning_standalone_struct(elem, func_name, status);
 		return true;
 	}
@@ -17707,6 +18128,7 @@ function emit_owning_buffer_standalone_aarch64(node, func_name, status) {
 function emit_owning_standalone_struct(elem, func_name, status) {
 	const T_SIZE = get_struct_size(elem.name, status);
 	const string_fields = collect_string_fields(elem, status);
+	const transfer_fields = collect_transfer_fields(elem, status);
 	if (func_name === "shift") {
 		emit_owning_shift_T(elem, status, "x19");
 		return true;
@@ -17715,6 +18137,23 @@ function emit_owning_standalone_struct(elem, func_name, status) {
 		emit_owning_modify_T(elem, status, T_SIZE, string_fields);
 		return true;
 	}
+	if (func_name === "load") {
+		emit_asm(status, `stp x20, x21, [sp, #-16]!\n`);
+		emit_asm(status, `stp x22, x23, [sp, #-16]!\n`);
+		emit_asm(status, `ldr x20, [x19, #8]\n`);
+		emit_asm(status, `mov x9, #${T_SIZE}\n`);
+		emit_asm(status, `madd x21, x1, x9, x20\n`);
+		emit_asm(status, `mov x22, x8\n`);
+		emit_asm(status, `mov x0, x22\n`);
+		emit_asm(status, `mov x1, x21\n`);
+		emit_asm(status, `mov x2, x9\n`);
+		emit_asm(status, `bl _memcpy\n`);
+		emit_load_deep_copy_fields$1(elem, status, "x22", "x21");
+		emit_asm(status, `mov x0, x22\n`);
+		emit_asm(status, `ldp x22, x23, [sp], #16\n`);
+		emit_asm(status, `ldp x20, x21, [sp], #16\n`);
+		return true;
+	}
 	emit_asm(status, `stp x20, x21, [sp, #-16]!\n`);
 	emit_asm(status, `str x22, [sp, #-16]!\n`);
 	emit_asm(status, `ldr x20, [x19, #8]\n`);
@@ -17752,6 +18191,7 @@ function emit_owning_standalone_struct(elem, func_name, status) {
 		}
 		if (string_fields.length) emit_asm(status, `add sp, sp, #${Math.ceil(string_fields.length * 8 / 16) * 16}\n`);
 	} else for (const { offset: foff } of string_fields) emit_strdup_field(status, "x21", "x20", foff, status.label_counter = (status.label_counter ?? 0) + 1);
+	emit_transfer_owning_fields$1(status, "x21", transfer_fields);
 	emit_asm(status, `ldr x22, [sp], #16\n`);
 	emit_asm(status, `ldp x20, x21, [sp], #16\n`);
 	return true;
@@ -17953,9 +18393,35 @@ function emit_owning_shift_T(elem, status, self_reg) {
 	emit_asm(status, `ldr x22, [sp], #16\n`);
 	emit_asm(status, `ldp x20, x21, [sp], #16\n`);
 }
+/**
+* Specialized owning-value-struct load_T (inline context: x0 = self, x1 = i,
+* x8 = sret). The caller's scope-exit destroy ALWAYS reclaims a struct
+* local's container fields, so the returned copy must own independent
+* containers — a shallow return would double-free the slot's buffer at the
+* caller's teardown. String fields stay borrowed (struct-local teardown only
+* frees RECORDED heap strings, so a strdup here would leak).
+*/
+function emit_owning_load_T(elem, status, self_reg) {
+	const T_SIZE = get_struct_size(elem.name, status);
+	emit_asm(status, `stp x20, x21, [sp, #-16]!\n`);
+	emit_asm(status, `stp x22, x23, [sp, #-16]!\n`);
+	emit_asm(status, `ldr x20, [${self_reg}, #8]\n`);
+	emit_asm(status, `mov x9, #${T_SIZE}\n`);
+	emit_asm(status, `madd x21, x1, x9, x20\n`);
+	emit_asm(status, `mov x22, x8\n`);
+	emit_asm(status, `mov x0, x22\n`);
+	emit_asm(status, `mov x1, x21\n`);
+	emit_asm(status, `mov x2, x9\n`);
+	emit_asm(status, `bl _memcpy\n`);
+	emit_load_deep_copy_fields$1(elem, status, "x22", "x21");
+	emit_asm(status, `mov x0, x22\n`);
+	emit_asm(status, `ldp x22, x23, [sp], #16\n`);
+	emit_asm(status, `ldp x20, x21, [sp], #16\n`);
+}
 function emit_owning_store_T(elem, status) {
 	const T_SIZE = get_struct_size(elem.name, status);
 	const string_fields = collect_string_fields(elem, status);
+	const transfer_fields = collect_transfer_fields(elem, status);
 	emit_asm(status, `stp x20, x21, [sp, #-16]!\n`);
 	emit_asm(status, `str x22, [sp, #-16]!\n`);
 	emit_asm(status, `ldr x20, [x0, #8]\n`);
@@ -17987,12 +18453,14 @@ function emit_owning_store_T(elem, status) {
 		emit_asm(status, `${lbl}:\n`);
 	}
 	if (string_fields.length) emit_asm(status, `add sp, sp, #${Math.ceil(string_fields.length * 8 / 16) * 16}\n`);
+	emit_transfer_owning_fields$1(status, "x21", transfer_fields);
 	emit_asm(status, `ldr x22, [sp], #16\n`);
 	emit_asm(status, `ldp x20, x21, [sp], #16\n`);
 }
 function emit_owning_replace_T(elem, status) {
 	const T_SIZE = get_struct_size(elem.name, status);
 	const string_fields = collect_string_fields(elem, status);
+	const transfer_fields = collect_transfer_fields(elem, status);
 	emit_asm(status, `stp x20, x21, [sp, #-16]!\n`);
 	emit_asm(status, `str x22, [sp, #-16]!\n`);
 	emit_asm(status, `ldr x20, [x0, #8]\n`);
@@ -18007,6 +18475,7 @@ function emit_owning_replace_T(elem, status) {
 	emit_asm(status, `mov x2, x22\n`);
 	emit_asm(status, `bl _memcpy\n`);
 	for (const { offset: foff } of string_fields) emit_strdup_field(status, "x21", "x20", foff, status.label_counter = (status.label_counter ?? 0) + 1);
+	emit_transfer_owning_fields$1(status, "x21", transfer_fields);
 	emit_asm(status, `ldr x22, [sp], #16\n`);
 	emit_asm(status, `ldp x20, x21, [sp], #16\n`);
 }
@@ -19441,6 +19910,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 +19924,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 +19986,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 +20110,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;
@@ -19661,7 +20140,7 @@ function build_function_node$1(node, status) {
 	status.code = "";
 	node.return_type = resolve_mono_type(node.return_type, status);
 	const return_struct = !node.return_type.is_view && !node.return_type.is_array && (!!status.structs.find((s) => s.name === node.return_type.name && !s.is_simple_type && !s.is_class) || get_enum_sret_size(node.return_type.name, status) !== void 0);
-	const nullable_scalar_ret = is_nullable_scalar_type(node.return_type) && !node.return_type.is_ref;
+	const nullable_scalar_ret = is_nullable_scalar_type(node.return_type, status) && !node.return_type.is_ref;
 	const uses_sret = return_struct || nullable_scalar_ret;
 	if (uses_sret) status.struct_return_buffer = "x8";
 	status.function_return_type = node.return_type;
@@ -19748,7 +20227,7 @@ function build_function_node$1(node, status) {
 				first_pass_slot += 2;
 				continue;
 			}
-			if (is_nullable_scalar_type(param.type)) {
+			if (is_nullable_scalar_type(param.type, status)) {
 				first_pass_slot += 2;
 				continue;
 			}
@@ -19860,11 +20339,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;
@@ -19913,7 +20394,7 @@ function build_function_node$1(node, status) {
 				param_idx += 2;
 				continue;
 			}
-			if (is_nullable_scalar_type(param.type) && !param.type.is_ref && !param.type.is_array) {
+			if (is_nullable_scalar_type(param.type, status) && !param.type.is_ref && !param.type.is_array) {
 				const size = aarch64_size(param.type.name);
 				const offset = allocate_stack_space(status, size, size);
 				status.stack_offsets.set(param.name, offset);
@@ -20245,6 +20726,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;
@@ -20328,7 +20810,7 @@ function init_enum_shorthand_field_default(node, field, base_reg, status) {
 * struct base register (`x0` for auto-init, `x19` for custom-init).
 */
 function init_nullable_field_default(node, field, base_reg, status) {
-	const scalar_nullable = is_nullable_scalar_type(field.type);
+	const scalar_nullable = is_nullable_scalar_type(field.type, status);
 	if (!is_nullable_struct_type(field.type, status) && !scalar_nullable) return false;
 	if (!field.value) return false;
 	const offset = get_field_offset(node.name, field.name, status);
@@ -20358,6 +20840,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;
@@ -20635,7 +21152,7 @@ function build_init_function(node, status) {
 		const slot = ctor_slot;
 		const field_is_view = !!field.type.is_view && !field.type.is_array;
 		const field_is_fat_string = field.type.name === "string" && !field.type.is_view && !field.type.is_ref && !field.type.is_array;
-		const field_is_nullable_scalar = is_nullable_scalar_type(field.type);
+		const field_is_nullable_scalar = is_nullable_scalar_type(field.type, status);
 		if (field_is_view || field_is_fat_string || field_is_nullable_scalar) ctor_slot += 2;
 		else ctor_slot += 1;
 		let src_reg;
@@ -20783,19 +21300,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 +21320,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);
@@ -20816,9 +21330,9 @@ function build_init_function(node, status) {
 			if (node.fields.find((nf) => nf.name === field.name)) continue;
 			const offset = get_field_offset(node.name, field.name, status);
 			const val = field.value.node_type === "value" ? field.value.value : void 0;
-			if (val === "null" && (is_nullable_scalar_type(field.type) || is_nullable_struct_type(field.type, status))) {
+			if (val === "null" && (is_nullable_scalar_type(field.type, status) || is_nullable_struct_type(field.type, status))) {
 				const has_off = get_field_has_offset(node.name, field.name, status);
-				if (is_nullable_scalar_type(field.type)) emit_asm(status, `strb wzr, [x19, #${has_off}]\n`);
+				if (is_nullable_scalar_type(field.type, status)) emit_asm(status, `strb wzr, [x19, #${has_off}]\n`);
 				else emit_asm(status, `str xzr, [x19, #${has_off}]\n`);
 				continue;
 			}
@@ -20959,7 +21473,7 @@ function build_custom_init_function(node, func, status) {
 			param_idx += 2;
 			continue;
 		}
-		if (is_nullable_scalar_type(param.type) && !param.type.is_ref && !param.type.is_array) {
+		if (is_nullable_scalar_type(param.type, status) && !param.type.is_ref && !param.type.is_array) {
 			const size = aarch64_size(param.type.name);
 			const offset = allocate_stack_space(status, size, size);
 			status.stack_offsets.set(param.name, offset);
@@ -21026,6 +21540,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 +21601,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 +21623,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() : [];
@@ -21247,7 +21764,7 @@ function build_struct_functions$1(node, status) {
 		status.function_view_params = /* @__PURE__ */ new Set();
 		status.struct_return_buffer = void 0;
 		const return_struct = !func.return_type?.is_array && (!!status.structs.find((s) => s.name === func.return_type?.name && !s.is_simple_type && !s.is_class) || get_enum_sret_size(func.return_type?.name, status) !== void 0);
-		const nullable_scalar_ret = !!func.return_type && is_nullable_scalar_type(func.return_type) && !func.return_type.is_ref;
+		const nullable_scalar_ret = !!func.return_type && is_nullable_scalar_type(func.return_type, status) && !func.return_type.is_ref;
 		const uses_sret = return_struct || nullable_scalar_ret;
 		let return_buffer_stack_offset;
 		status.current_function_name = func.name;
@@ -21274,7 +21791,7 @@ function build_struct_functions$1(node, status) {
 				slot_idx += 2;
 				continue;
 			}
-			if (is_nullable_scalar_type(param.type) && !param.type.is_ref) {
+			if (is_nullable_scalar_type(param.type, status) && !param.type.is_ref) {
 				if (param.declaration === "var") status.function_param_vars.add(param.name);
 				slot_idx += 2;
 				continue;
@@ -21357,7 +21874,7 @@ function build_struct_functions$1(node, status) {
 				second_slot_idx += 2;
 				continue;
 			}
-			if (is_nullable_scalar_type(param.type) && !param.type.is_ref) {
+			if (is_nullable_scalar_type(param.type, status) && !param.type.is_ref) {
 				const size = aarch64_size(param.type.name);
 				const offset = allocate_stack_space(status, size, size);
 				status.stack_offsets.set(param.name, offset);
@@ -21814,6 +22331,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 +22380,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));
@@ -22808,11 +23333,11 @@ function build_constructor_params(fc, param_regs, status) {
 		let nullable_scalar = false;
 		if (fc.nullable_param_indices?.includes(i)) {
 			const cp = ctor_callee_params?.[i];
-			if (cp && is_nullable_scalar_type(cp.type)) nullable_scalar = true;
-			else if (is_nullable_scalar_type(p.type)) nullable_scalar = true;
+			if (cp && is_nullable_scalar_type(cp.type, status)) nullable_scalar = true;
+			else if (is_nullable_scalar_type(p.type, status)) nullable_scalar = true;
 			else if (!cp) {
 				const field = (status.structs.find((s) => s.name === fc.name && !s.is_simple_type)?.fields.filter((f) => f.value == null))?.[i];
-				if (field && is_nullable_scalar_type(field.type)) nullable_scalar = true;
+				if (field && is_nullable_scalar_type(field.type, status)) nullable_scalar = true;
 			}
 		}
 		const is_pair = pt === "string" || lit || is_view || nullable_scalar;
@@ -22839,7 +23364,7 @@ function build_constructor_params(fc, param_regs, status) {
 			if (arg.node_type === "value" && arg.value === "null") {
 				emit_asm(status, `mov x0, #0\n`);
 				emit_asm(status, `mov x1, #0\n`);
-			} else if (arg.node_type === "value" && is_nullable_scalar_type(arg.type)) {
+			} else if (arg.node_type === "value" && is_nullable_scalar_type(arg.type, status)) {
 				const vname = arg.value;
 				emit_var_load(status, "x0", vname, aarch64_size(arg.type.name));
 				emit_var_load(status, "x1", has_flag_name(vname), 8);
@@ -23229,7 +23754,7 @@ function build_declaration_node$1(node, status, nir_init, nir_swap) {
 		emit_var_store(status, "x0", node.name, 8);
 		return;
 	}
-	if (is_nullable_scalar_type(node.type)) {
+	if (is_nullable_scalar_type(node.type, status)) {
 		if (status.function_return_label) {
 			const offset = allocate_stack_space(status, 16, 16);
 			status.stack_offsets.set(node.name, offset);
@@ -23240,14 +23765,23 @@ function build_declaration_node$1(node, status, nir_init, nir_swap) {
 			}
 			const init_value = node.value;
 			const init_type = call_result_type(init_value) ?? type_from_value_node$1(init_value);
-			const value_is_nullable_call = init_value.node_type === "func_call" && is_nullable_scalar_type(init_type);
-			if (init_value.node_type === "access" && is_nullable_scalar_type(init_type)) {
+			const value_is_nullable_call = init_value.node_type === "func_call" && is_nullable_scalar_type(init_type, status);
+			const value_is_nullable_method = init_value.node_type === "access" && init_value.access.node_type === "access_func" && is_nullable_scalar_type(init_type, status);
+			const value_is_nullable_field = init_value.node_type === "access" && init_value.access.node_type === "access_field" && is_nullable_scalar_type(init_type, status);
+			if (value_is_nullable_method) {
 				emit_init_value$1(init_value, nir_init, status);
 				ensure_newline(status);
 				emit_asm(status, `ldr x9, [x0]\n`);
 				emit_asm(status, `str x9, [x29, #${offset}]\n`);
 				emit_asm(status, `ldr x9, [x0, #8]\n`);
 				emit_asm(status, `str x9, [x29, #${offset + 8}]\n`);
+			} else if (value_is_nullable_field) {
+				emit_init_value$1(init_value, nir_init, status);
+				ensure_newline(status);
+				emit_var_store(status, "x0", node.name, 8);
+				load_nullable_has(init_value, "x9", status);
+				ensure_newline(status);
+				emit_asm(status, `str x9, [x29, #${offset + 8}]\n`);
 			} else if (value_is_nullable_call) {
 				const old_buffer = status.struct_return_buffer;
 				const old_buffer_var = status.struct_return_buffer_var;
@@ -23269,8 +23803,13 @@ function build_declaration_node$1(node, status, nir_init, nir_swap) {
 			}
 			return;
 		}
-		emit_data(status, `${node.name}: .space 16\n`);
-		status.stack_offsets.set(has_flag_name(node.name), -1);
+		const global_is_null = !node.value || node.value.node_type === "value" && node.value.value === "null";
+		if (global_is_null) emit_data(status, `${node.name}: .space 8\n`);
+		else {
+			emit_data(status, `${node.name}: ${aarch64_type(node.type.name)} ${get_raw_value$1(node.value, status)}\n`);
+			if (aarch64_size(node.type.name) < 8) emit_data(status, `.p2align 3\n`);
+		}
+		emit_data(status, `${has_flag_name(node.name)}: .quad ${global_is_null ? 0 : 1}\n`);
 		return;
 	}
 	const directive = aarch64_type(node.type.name);
@@ -23893,6 +24432,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 +25311,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 +25499,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 +25523,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 +25574,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 +25600,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 +25915,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 +26109,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;
@@ -25616,7 +26273,7 @@ function build_return_node$1(node, status, nir_value) {
 	hoist_field_overrides(node.value, build_node, status);
 	if (node.from_inline) return;
 	const returns_nullable_struct = is_nullable_struct_type(status.function_return_type, status);
-	const returns_nullable_scalar = is_nullable_scalar_type(status.function_return_type);
+	const returns_nullable_scalar = is_nullable_scalar_type(status.function_return_type, status);
 	if ((returns_nullable_struct || returns_nullable_scalar) && (!node.value || node.value.node_type === "value" && node.value.value === "null")) {
 		if (status.return_buffer_stack_offset !== void 0) {
 			const struct_size = get_struct_size(status.function_return_type.name, status);
@@ -25723,7 +26380,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 +26390,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 +26433,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 +26442,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();
@@ -25789,7 +26463,7 @@ function build_return_node$1(node, status, nir_value) {
 		if (status.return_buffer_stack_offset !== void 0) emit_asm(status, `ldr x8, [x29, #${status.return_buffer_stack_offset}]\n`);
 		emit_typed_store(status, "x0", "x8", 0, aarch64_size(status.function_return_type.name));
 		const value_type = node.value ? type_from_value_node$1(node.value) : void 0;
-		if (node.value && value_type?.is_nullable && is_nullable_scalar_type(value_type)) {
+		if (node.value && value_type?.is_nullable && is_nullable_scalar_type(value_type, status)) {
 			load_nullable_has(node.value, "x9", status);
 			ensure_newline(status);
 			emit_asm(status, `str x9, [x8, #8]\n`);
@@ -25837,10 +26511,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 +26626,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 +26636,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 +26646,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`);
@@ -29399,7 +30093,7 @@ function build_function_call_node$1(node, status) {
 				if (!node.nullable_param_indices?.includes(i)) continue;
 				const arg_type = node.params[i].type;
 				const callee_param = node.resolved_function?.params?.[i];
-				if (is_nullable_scalar_type(arg_type) || callee_param && is_nullable_scalar_type(callee_param.type)) nullable_scalar_arg_set.add(i);
+				if (is_nullable_scalar_type(arg_type, status) || callee_param && is_nullable_scalar_type(callee_param.type, status)) nullable_scalar_arg_set.add(i);
 			}
 			const arg_slot = [];
 			let total_slots = 0;
@@ -29497,7 +30191,7 @@ function build_function_call_node$1(node, status) {
 					if (arg.node_type === "value" && arg.value === "null") {
 						emit_asm(status, `mov x0, #0\n`);
 						emit_asm(status, `mov x1, #0\n`);
-					} else if (arg.node_type === "value" && is_nullable_scalar_type(arg.type)) {
+					} else if (arg.node_type === "value" && is_nullable_scalar_type(arg.type, status)) {
 						const vname = arg.value;
 						emit_var_load(status, "x0", vname, aarch64_size(param_type.name));
 						emit_var_load(status, "x1", has_flag_name(vname), 8);
@@ -29611,7 +30305,7 @@ function build_function_call_node$1(node, status) {
 		} else if (!is_struct && node.type?.name && !status.call_x8_preset) {
 			const return_struct = status.structs.find((s) => s.name === node.type.name && !s.is_simple_type && !s.is_class);
 			const return_enum_size = get_enum_sret_size(node.type?.name, status);
-			const nullable_scalar_ret = is_nullable_scalar_type(node.type);
+			const nullable_scalar_ret = is_nullable_scalar_type(node.type, status);
 			if (return_struct || return_enum_size !== void 0 || nullable_scalar_ret) {
 				const nullable_ret = is_nullable_struct_type(node.type, status);
 				const struct_size = return_struct ? get_struct_size(node.type.name, status) : nullable_scalar_ret ? 8 : return_enum_size;
@@ -29628,6 +30322,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) {
@@ -29661,7 +30361,7 @@ function build_function_call_node$1(node, status) {
 		if (!is_struct && node.type?.name && !status.call_x8_preset) {
 			const return_struct = status.structs.find((s) => s.name === node.type.name && !s.is_simple_type && !s.is_class);
 			const return_enum_size = get_enum_sret_size(node.type?.name, status);
-			const nullable_scalar_ret = is_nullable_scalar_type(node.type);
+			const nullable_scalar_ret = is_nullable_scalar_type(node.type, status);
 			if (return_struct || return_enum_size !== void 0 || nullable_scalar_ret) {
 				const temp_name = `_call_ret_${temp_counter - 1}`;
 				emit_asm(status, `add x0, x29, #${status.stack_offsets.get(temp_name)}\n`);
@@ -29678,6 +30378,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`);
 		}
@@ -30531,7 +31236,7 @@ function build_struct_body(node, status) {
 		status.code += `];\n`;
 	} else {
 		status.code += `${field_c_type(field.type, status)} ${field.name};\n`;
-		if (is_nullable_struct_type(field.type, status) || is_nullable_scalar_type(field.type)) status.code += `unsigned char ${has_flag_name(field.name)};\n`;
+		if (is_nullable_struct_type(field.type, status) || is_nullable_scalar_type(field.type, status)) status.code += `unsigned char ${has_flag_name(field.name)};\n`;
 	}
 	for (let traitName of node.traits) {
 		const trait = status.traits.find((n) => n.name === traitName);
@@ -30659,12 +31364,12 @@ 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)) {
+		} else if (is_nullable_scalar_type(left_type, status)) {
+			if (node.left_value.node_type === "func_call" && is_nullable_scalar_type(node.left_value.type, status)) {
 				const id = ns_tmp_counter++;
 				const flag = `_nsh_${id}`;
 				const val = `_nsv_${id}`;
@@ -30726,8 +31431,8 @@ function build_operation_node$1(node, status) {
 			else status.code += `((`;
 			build_node$1(nullable_side, status);
 			status.code += `.ptr != 0))`;
-		} else if (is_nullable_scalar_type(type_from_value_node$1(nullable_side)) && type?.is_nullable && type.name !== "string") {
-			if (nullable_side.node_type === "func_call" && is_nullable_scalar_type(nullable_side.type)) {
+		} else if (is_nullable_scalar_type(type_from_value_node$1(nullable_side), status) && type?.is_nullable && type.name !== "string") {
+			if (nullable_side.node_type === "func_call" && is_nullable_scalar_type(nullable_side.type, status)) {
 				const id = ns_tmp_counter++;
 				const flag = `_nsh_${id}`;
 				const val = `_nsv_${id}`;
@@ -30891,7 +31596,7 @@ function is_null_comparison(node) {
 }
 function is_nullable_struct_side(node, status) {
 	const t = type_from_value_node$1(node);
-	return is_nullable_struct_type(t, status) || is_nullable_scalar_type(t);
+	return is_nullable_struct_type(t, status) || is_nullable_scalar_type(t, status);
 }
 /**
 * Build the companion `_has` flag expression for a nullable-struct or
@@ -30909,8 +31614,8 @@ function is_nullable_struct_side(node, status) {
 function build_nullable_has(node, status) {
 	if (node.node_type === "value") {
 		const name = node.value;
-		if (status.function_ref_params?.has(name) && (is_nullable_struct_type(node.type, status) || is_nullable_scalar_type(node.type))) return has_flag_name(name);
-		if (is_nullable_struct_type(node.type, status) || is_nullable_scalar_type(node.type)) return has_flag_name(name);
+		if (status.function_ref_params?.has(name) && (is_nullable_struct_type(node.type, status) || is_nullable_scalar_type(node.type, status))) return has_flag_name(name);
+		if (is_nullable_struct_type(node.type, status) || is_nullable_scalar_type(node.type, status)) return has_flag_name(name);
 	}
 	const saved = begin_code_scratch(status);
 	build_node$1(node, status);
@@ -32575,7 +33280,7 @@ function build_assignment_node$1(node, status, nir_rhs, nir_swap) {
 		if (rhs_is_null) status.code += `${flag} = 0`;
 		else {
 			const call_ret = call_result_type(node.right_value);
-			if (!!call_ret && (is_nullable_struct_type(call_ret, status) || is_nullable_scalar_type(call_ret))) {
+			if (!!call_ret && (is_nullable_struct_type(call_ret, status) || is_nullable_scalar_type(call_ret, status))) {
 				const old = status.current_nullable_call_flag;
 				status.current_nullable_call_flag = flag;
 				status.code += `${lhs_expr} = `;
@@ -32665,7 +33370,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 +33658,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 +33706,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 +33720,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`;
@@ -33028,11 +33750,11 @@ function lhs_nullable_struct_type(node, status) {
 	if (node.left_value.node_type === "value") {
 		const name = node.left_value.value;
 		const t = status.scoped_declarations.find((d) => d.name === name)?.type || status.variable_types?.get(name);
-		return is_nullable_struct_type(t, status) || is_nullable_scalar_type(t);
+		return is_nullable_struct_type(t, status) || is_nullable_scalar_type(t, status);
 	}
 	if (node.left_value.node_type === "access" && node.left_value.access.node_type === "access_field") {
 		const field_type = node.left_value.access.type;
-		return is_nullable_struct_type(field_type, status) || is_nullable_scalar_type(field_type);
+		return is_nullable_struct_type(field_type, status) || is_nullable_scalar_type(field_type, status);
 	}
 	return false;
 }
@@ -33045,7 +33767,7 @@ function lhs_nullable_struct_type(node, status) {
 function nullable_value_flag_expr(value, status) {
 	const t = type_from_value_node$1(value);
 	if (!t?.is_nullable) return void 0;
-	if (!is_nullable_struct_type(t, status) && !is_nullable_scalar_type(t)) return void 0;
+	if (!is_nullable_struct_type(t, status) && !is_nullable_scalar_type(t, status)) return void 0;
 	if (value.node_type === "value") return has_flag_name(value.value);
 	if (value.node_type === "access" && value.access.node_type === "access_field") {
 		const saved = begin_code_scratch(status);
@@ -33776,32 +34498,37 @@ function build_declaration_node(node, status, nir_init, nir_swap) {
 				status.stack_array_lengths.set(safe_name, len_text);
 			}
 		}
-		if (is_nullable_struct_type(node.type, status) || is_nullable_scalar_type(node.type)) {
+		if (is_nullable_struct_type(node.type, status) || is_nullable_scalar_type(node.type, status)) {
 			const flag = has_flag_name(safe_name);
 			const is_null = !node.value || node.value.node_type === "value" && node.value.value === "null";
-			if (!status.current_function && is_nullable_scalar_type(node.type)) {
-				status.code += `;\nunsigned char ${flag} = ${is_null ? 0 : 1}`;
-				if (is_null) return;
-			} else {
-				status.code += `;\nunsigned char ${flag} = 0`;
-				if (node.value && !is_null) {
-					const call_ret = call_result_type(node.value);
-					const value_is_nullable_call = !!call_ret && (is_nullable_struct_type(call_ret, status) || is_nullable_scalar_type(call_ret));
-					status.code += `;\n${safe_name} = `;
-					if (value_is_nullable_call) {
-						const old = status.current_nullable_call_flag;
-						status.current_nullable_call_flag = flag;
-						emit_init_value(node.value, nir_init, status);
-						status.current_nullable_call_flag = old;
-						record_call_init_string_fields(node, status);
-					} else {
-						const rhs_flag = nullable_value_flag_expr(node.value, status);
-						emit_init_value(node.value, nir_init, status);
-						status.code += `;\n${flag} = ${rhs_flag ?? "1"}`;
-					}
+			if (!status.current_function && is_nullable_scalar_type(node.type, status)) {
+				if (is_null) {
+					status.code += `;\nunsigned char ${flag} = 0`;
+					return;
 				}
+				status.code += ` = `;
+				emit_init_value(node.value, nir_init, status);
+				status.code += `;\nunsigned char ${flag} = 1`;
 				return;
 			}
+			status.code += `;\nunsigned char ${flag} = 0`;
+			if (node.value && !is_null) {
+				const call_ret = call_result_type(node.value);
+				const value_is_nullable_call = !!call_ret && (is_nullable_struct_type(call_ret, status) || is_nullable_scalar_type(call_ret, status));
+				status.code += `;\n${safe_name} = `;
+				if (value_is_nullable_call) {
+					const old = status.current_nullable_call_flag;
+					status.current_nullable_call_flag = flag;
+					emit_init_value(node.value, nir_init, status);
+					status.current_nullable_call_flag = old;
+					record_call_init_string_fields(node, status);
+				} else {
+					const rhs_flag = nullable_value_flag_expr(node.value, status);
+					emit_init_value(node.value, nir_init, status);
+					status.code += `;\n${flag} = ${rhs_flag ?? "1"}`;
+				}
+			}
+			return;
 		}
 		if (node.value) {
 			const is_heap_literal_init = node.is_heap_array_literal || node.type.storage_kind === "heap_array" && (node.value.node_type === "array" || node.value.node_type === "range");
@@ -33913,8 +34640,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 +34946,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`;
@@ -34395,7 +35145,7 @@ function build_return_node(node, status, nir_value) {
 			emit_nursery_joins_on_return_c(status);
 			reclaim_all_c_scopes(status);
 			status.code += `*${ret_has} = 0;\n`;
-			if (status.function_return_type && is_nullable_scalar_type(status.function_return_type)) status.code += `return (${c_type(status.function_return_type.name)})0;\n`;
+			if (status.function_return_type && is_nullable_scalar_type(status.function_return_type, status)) status.code += `return (${c_type(status.function_return_type.name)})0;\n`;
 			else status.code += `return (struct ${status.function_return_type.name}){0};\n`;
 			return;
 		}
@@ -34558,14 +35308,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`;
@@ -34611,7 +35378,7 @@ function nullable_flag_expr_of_value(value, status) {
 	if (!value) return void 0;
 	const t = type_from_value_node$1(value);
 	if (!t?.is_nullable) return void 0;
-	if (!(is_nullable_struct_type(t, status) || is_nullable_scalar_type(t))) return void 0;
+	if (!(is_nullable_struct_type(t, status) || is_nullable_scalar_type(t, status))) return void 0;
 	if (value.node_type === "value") return has_flag_name(value.value);
 	if (value.node_type === "access") {
 		const saved = begin_code_scratch(status);
@@ -34623,9 +35390,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 +35435,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
@@ -35039,20 +35820,78 @@ function has_owning_fields(node, status) {
 }
 /**
 * The names of Buffer methods that get specialized for owning value structs.
-* load_T and move_T are NOT specialized: load_T returns a shallow copy (a
-* borrow — the caller's struct local is not destroyed, so no double-free);
-* move_T transfers ownership (the slot is zeroed, the caller takes the
-* pointers).
+* load_T IS specialized when the element has owning container fields (a
+* `List<T>` member): the returned copy must own independent containers, or
+* the caller's scope-exit destroy would free the slot's buffer (double-free
+* at container teardown). String fields stay BORROWED on load (struct-local
+* teardown only frees RECORDED heap strings, so strdup'ing them would leak);
+* container fields have no such borrow convention — a struct local's
+* container fields are ALWAYS destroyed — so they must be deep-copied.
+* move_T is NOT specialized: it transfers ownership (the slot is zeroed, the
+* caller takes the pointers).
 */
 const OWNING_BUFFER_METHODS = /* @__PURE__ */ new Set([
 	"store",
 	"replace",
+	"load",
 	"modify",
 	"shift",
 	"destroy",
 	"#destroy"
 ]);
 /**
+* Emit the transfer half of owning store_T/replace_T: the slot bytes were
+* already memcpy'd from the source, so zeroing each owned CONTAINER field
+* of the SOURCE completes the move — the slot is the sole owner, and the
+* source's own teardown (when it still runs: an unstamped generic-body
+* local) finds zeroed fields and reclaims nothing. Nested value struct
+* fields recurse so their container leaves are zeroed at their own paths;
+* their string fields are untouched (the slot aliases them — the pre-existing
+* nested-string convention). Class/enum payload fields are left alone
+* (recorded in FOLLOWUP.md).
+*/
+function emit_transfer_owning_fields(elem, src, status, prefix = "") {
+	for (const field of elem.fields) {
+		if (field.type.is_ref || field.type.is_view) continue;
+		if (field.type.is_array || field.type.is_nullable) continue;
+		const field_struct = resolve_struct_type(field.type, status);
+		if (!field_struct || field_struct.is_class) continue;
+		const src_field = `${prefix}${src}${arrow(src)}${field.name}`;
+		if (has_destroy(field_struct)) status.code += `memset((void*)&${src_field}, 0, sizeof(${src_field}));\n`;
+		else if (struct_needs_destroy(field_struct, status)) emit_transfer_owning_fields(field_struct, src_field, status, "");
+	}
+}
+/**
+* Emit the deep-copy half of owning load_T: for each field whose type has a
+* monomorphized `copy` helper that yields an independent value (a `List<T>`
+* field — `<List_T>_copy` deep-copies slots per the owning store contract —
+* or an enum-with-data field whose string payloads `<E>_copy` duplicates),
+* overwrite the shallow-copied bytes with an owned copy. Fields without a
+* copyable shape (nested owning user structs, class fields) stay shallow —
+* recorded in FOLLOWUP.md ("remaining shallow container-field shapes").
+*/
+function emit_load_deep_copy_fields(elem, dst, status) {
+	for (const field of elem.fields) {
+		if (field.type.is_ref || field.type.is_view || field.type.is_array) continue;
+		if (field.type.is_nullable) continue;
+		if (field.type.name === "string") continue;
+		const field_struct = resolve_struct_type(field.type, status);
+		if (field_struct && !field_struct.is_class && field_struct.name.startsWith("List_") && struct_needs_destroy(field_struct, status) && field_struct.functions.find((f) => f.name === "copy")) {
+			status.code += `${dst}.${field.name} = ${field_struct.name}_copy(&${dst}.${field.name});\n`;
+			continue;
+		}
+		const field_enum = status.enums.find((e) => e.name === field.type.name && e.has_associated_data);
+		if (field_enum && enum_copy_is_deep(field_enum, status)) status.code += `${dst}.${field.name} = ${field_enum.name}_copy(${dst}.${field.name});\n`;
+	}
+}
+/** Whether `<E>_copy` yields a fully independent value: no case payload is a
+*  class/trait reference (those are shared pointers the copy cannot
+*  duplicate — mirroring owning_buffer_enum_element's gate). */
+function enum_copy_is_deep(elem, status) {
+	for (const c of elem.cases) for (const p of c.params) if (status.structs.find((s) => s.name === p.type.name)?.is_class || status.traits.find((t) => t.name === p.type.name)) return false;
+	return true;
+}
+/**
 * A `Buffer<string>` owns an independent heap copy of each slot (strdup on
 * store_T, free+strdup on replace_T, per-slot free on #destroy). The element
 * is a primitive, so this is a separate path from the value-struct
@@ -35215,6 +36054,13 @@ function emit_owning_buffer_body(func_name, elem, status) {
 		status.code += `struct ${elem.name} _old = _slots[i];\n`;
 		status.code += `_slots[i] = (*val);\n`;
 		emit_deep_copy_fields(elem, "_slots[i]", "val", status, "_old");
+		emit_transfer_owning_fields(elem, "val", status);
+		return true;
+	}
+	if (func_name === "load") {
+		status.code += `struct ${elem.name} _loaded = ((struct ${elem.name} *)(unsigned long long)self->data)[i];\n`;
+		emit_load_deep_copy_fields(elem, "_loaded", status);
+		status.code += `return _loaded;\n`;
 		return true;
 	}
 	if (func_name === "modify") {
@@ -35229,6 +36075,7 @@ function emit_owning_buffer_body(func_name, elem, status) {
 		status.code += `${elem.name}_destroy(&_slots[i]);\n`;
 		status.code += `_slots[i] = (*val);\n`;
 		emit_deep_copy_fields(elem, "_slots[i]", "val", status);
+		emit_transfer_owning_fields(elem, "val", status);
 		return true;
 	}
 	if (func_name === "shift") {
@@ -35255,12 +36102,13 @@ function emit_owning_buffer_body(func_name, elem, status) {
 	return false;
 }
 /**
-* For each string field on the element struct, overwrite the shallow-copied
-* pointer in `dst` with a fresh strdup of `src`'s field. This breaks the
-* pointer aliasing between the source and the slot so each can be destroyed
-* independently. For nested owning value struct fields, recursively call the
-* nested struct's destroy + deep-copy (the nested destroy frees the
-* shallow-copied owned sub-fields, then the deep-copy re-strdup's them).
+* For each DIRECT string field on the element struct, overwrite the
+* shallow-copied pointer in `dst` with a fresh strdup of `src`'s field. This
+* breaks the pointer aliasing between the source and the slot so each can be
+* destroyed independently. Nested value struct fields are NOT walked: their
+* string fields stay aliased (the pre-existing convention — a spliced
+* `move` donor has no teardown, so the slot is the sole owner), and their
+* container leaves are transferred by `emit_transfer_owning_fields`.
 *
 * `old_expr` (optional) is the slot's PRE-copy value expression. When the
 * source field pointer equals the old slot field pointer, the slot already
@@ -35278,12 +36126,6 @@ function emit_deep_copy_fields(elem, dst, src, status, old_expr) {
 			const src_field = `${src}${arrow(src)}${field.name}`;
 			if (old_expr) status.code += `${dst}.${field.name} = (${src_field}.ptr && ${src_field}.ptr != ${old_expr}.${field.name}.ptr) ? nomen_str_dup(${src_field}) : ${src_field};\n`;
 			else status.code += `${dst}.${field.name} = ${src_field}.ptr ? nomen_str_dup(${src_field}) : ${src_field};\n`;
-		} else if (field.type.name && !field.type.is_array) {
-			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 && struct_needs_destroy(field_struct, status)) {
-				status.code += `${field_struct.name}_destroy(&${dst}.${field.name});\n`;
-				emit_deep_copy_fields(field_struct, `${dst}.${field.name}`, `${src}${arrow(src)}${field.name}`, status);
-			}
 		}
 	}
 }
@@ -35431,7 +36273,7 @@ function build_struct_node(node, status) {
 	const ctor_return = is_class ? `struct ${node.name}*` : `struct ${node.name}`;
 	const field_params = node.fields.filter((f) => f.value == null).map((f) => {
 		let decl = c_param_decl(f.type, f.name, status);
-		if (is_nullable_struct_type(f.type, status) || is_nullable_scalar_type(f.type)) decl += `, unsigned char ${has_flag_name(f.name)}`;
+		if (is_nullable_struct_type(f.type, status) || is_nullable_scalar_type(f.type, status)) decl += `, unsigned char ${has_flag_name(f.name)}`;
 		return decl;
 	}).join(", ");
 	const ctor_sig = (init) => {
@@ -35442,7 +36284,7 @@ function build_struct_node(node, status) {
 				is_ref: p.is_ref || p.type.is_ref,
 				declaration: p.declaration
 			});
-			if (!p.is_variadic && (is_nullable_struct_type(p.type, status) || is_nullable_scalar_type(p.type))) decl += `, unsigned char ${has_flag_name(p.name)}`;
+			if (!p.is_variadic && (is_nullable_struct_type(p.type, status) || is_nullable_scalar_type(p.type, status))) decl += `, unsigned char ${has_flag_name(p.name)}`;
 			return decl;
 		}).join(", ");
 		const label = is_overloaded(node, "#init") ? mangled_label(init, node.name) : `${node.name}_init`;
@@ -35458,6 +36300,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)) {
@@ -35466,7 +36312,7 @@ function build_struct_node(node, status) {
 						build_node$1(field.value, status);
 						status.code += `; self${accessor}${field.name} = (nomen_view){ _p.ptr, _p.len }; }\n`;
 					} else status.code += `self${accessor}${field.name} = (nomen_view){0};\n`;
-				} else if (is_nullable_struct_type(field.type, status) || is_nullable_scalar_type(field.type)) {
+				} else if (is_nullable_struct_type(field.type, status) || is_nullable_scalar_type(field.type, status)) {
 					if (field.value.node_type === "value" && field.value.value === "null") status.code += `self${accessor}${has_flag_name(field.name)} = 0;\n`;
 					else {
 						status.code += `self${accessor}${field.name} = `;
@@ -35525,6 +36371,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);
@@ -35542,7 +36390,7 @@ function build_struct_node(node, status) {
 				status.code += `; ${object_name}${accessor}${field.name} = (nomen_view){ _p.ptr, _p.len }; }\n`;
 			} else status.code += `${object_name}${accessor}${field.name} = (nomen_view){0};\n`;
 		} else if (field.type.storage_kind === "stack_array" && field.type.length) status.code += `memcpy(${object_name}${accessor}${field.name}, ${field.name}, sizeof(${object_name}${accessor}${field.name}));\n`;
-		else if ((is_nullable_struct_type(field.type, status) || is_nullable_scalar_type(field.type)) && field.value) {
+		else if ((is_nullable_struct_type(field.type, status) || is_nullable_scalar_type(field.type, status)) && field.value) {
 			if (field.value.node_type === "value" && field.value.value === "null") status.code += `${object_name}${accessor}${has_flag_name(field.name)} = 0;\n`;
 			else {
 				status.code += `${object_name}${accessor}${field.name} = `;
@@ -35552,7 +36400,7 @@ function build_struct_node(node, status) {
 		} else if (is_nullable_struct_type(field.type, 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 if (is_nullable_scalar_type(field.type)) {
+		} else if (is_nullable_scalar_type(field.type, 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 if (!field.type.is_ref && !field.type.is_view && status.enums.find((e) => e.name === field.type.name && e.has_associated_data)) {
@@ -35690,7 +36538,7 @@ function build_struct_functions(node, status, skip_init = false) {
 		status.force_heap_strings = scan_force_heap_strings(func.statements ?? [], status.structs);
 		status.function_return_type = func.return_type;
 		const old_nullable_ret_has = status.nullable_ret_has_param;
-		if (is_nullable_struct_type(func.return_type, status) || is_nullable_scalar_type(func.return_type)) status.nullable_ret_has_param = "_ret_has";
+		if (is_nullable_struct_type(func.return_type, status) || is_nullable_scalar_type(func.return_type, status)) status.nullable_ret_has_param = "_ret_has";
 		else status.nullable_ret_has_param = void 0;
 		const self_param = func.params[0]?.is_self_param ? func.params[0] : null;
 		status.self_is_ref = !!self_param?.is_ref || self_param?.declaration === "var";
@@ -35747,9 +36595,9 @@ function build_struct_functions(node, status, skip_init = false) {
 		for (let i = 0; i < func.params.length; i++) {
 			if (i > 0) status.code += ", ";
 			build_parameter_node(func.params[i], status);
-			if (!func.params[i].is_self_param && (is_nullable_struct_type(func.params[i].type, status) || is_nullable_scalar_type(func.params[i].type))) status.code += `, unsigned char ${has_flag_name(c_function_name(func.params[i].name))}`;
+			if (!func.params[i].is_self_param && (is_nullable_struct_type(func.params[i].type, status) || is_nullable_scalar_type(func.params[i].type, status))) status.code += `, unsigned char ${has_flag_name(c_function_name(func.params[i].name))}`;
 		}
-		if (is_nullable_struct_type(func.return_type, status) || is_nullable_scalar_type(func.return_type)) {
+		if (is_nullable_struct_type(func.return_type, status) || is_nullable_scalar_type(func.return_type, status)) {
 			if (func.params.length > 0) status.code += `, `;
 			status.code += `unsigned char *_ret_has`;
 		}
@@ -36441,6 +37289,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;
@@ -36508,9 +37358,9 @@ function build_function_node(node, status) {
 			first_param = false;
 			if (node.params[i].is_variadic) status.code += `long _${node.params[i].name}_len, `;
 			build_parameter_node(node.params[i], status);
-			if ((is_nullable_struct_type(node.params[i].type, status) || is_nullable_scalar_type(node.params[i].type)) && !node.params[i].is_self_param) status.code += `, unsigned char ${has_flag_name(c_function_name(node.params[i].name))}`;
+			if ((is_nullable_struct_type(node.params[i].type, status) || is_nullable_scalar_type(node.params[i].type, status)) && !node.params[i].is_self_param) status.code += `, unsigned char ${has_flag_name(c_function_name(node.params[i].name))}`;
 		}
-		if (is_nullable_struct_type(node.return_type, status) || is_nullable_scalar_type(node.return_type)) {
+		if (is_nullable_struct_type(node.return_type, status) || is_nullable_scalar_type(node.return_type, status)) {
 			if (!first_param) status.code += ", ";
 			status.code += `unsigned char *_ret_has`;
 		}
@@ -36563,7 +37413,7 @@ function build_function_node(node, status) {
 	const old_variable_types = status.variable_types;
 	status.variable_types = /* @__PURE__ */ new Map();
 	const old_nullable_ret_has = status.nullable_ret_has_param;
-	if (is_nullable_struct_type(node.return_type, status) || is_nullable_scalar_type(node.return_type)) status.nullable_ret_has_param = "_ret_has";
+	if (is_nullable_struct_type(node.return_type, status) || is_nullable_scalar_type(node.return_type, status)) status.nullable_ret_has_param = "_ret_has";
 	else status.nullable_ret_has_param = void 0;
 	const old_function_name = status.current_function_name;
 	status.current_function_name = emission_label(node);
@@ -36658,6 +37508,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;
@@ -36949,7 +37800,7 @@ function build_function_call_node(node, status) {
 	const lambda_ret_c = lambda_arg_temps.size > 0 ? c_return_type(node.type, status) : void 0;
 	const lambda_ret_tmp = lambda_ret_c && lambda_ret_c !== "void" ? next_lambda_ret_temp() : void 0;
 	if (lambda_ret_tmp) status.code += `${lambda_ret_c} ${lambda_ret_tmp} = `;
-	const saved_call = (is_nullable_struct_type(node.type, status) || is_nullable_scalar_type(node.type)) && !status.current_nullable_call_flag ? begin_code_scratch(status) : void 0;
+	const saved_call = (is_nullable_struct_type(node.type, status) || is_nullable_scalar_type(node.type, status)) && !status.current_nullable_call_flag ? begin_code_scratch(status) : void 0;
 	let wrap_tmp;
 	status.code += `${func_name}(${is_closure_callee ? "NULL" : ""}`;
 	if (is_closure_callee && node.params.length > 0) status.code += ", ";
@@ -36990,7 +37841,7 @@ function build_function_call_node(node, status) {
 		}
 		if (node.nullable_param_indices?.includes(i) && node.params[i].node_type === "value" && node.params[i].value === "null") {
 			const callee_null_param_type = callee_params?.[i]?.type ?? param_type;
-			if (is_nullable_scalar_type(callee_null_param_type)) status.code += `0, 0`;
+			if (is_nullable_scalar_type(callee_null_param_type, status)) status.code += `0, 0`;
 			else status.code += `(void *)&(struct ${mono_type_name(callee_null_param_type)}){0}, 0`;
 			continue;
 		}
@@ -37076,7 +37927,7 @@ function build_function_call_node(node, status) {
 			emit_nullable_arg_flag(node.params[i], status);
 		}
 	}
-	if (is_nullable_struct_type(node.type, status) || is_nullable_scalar_type(node.type)) {
+	if (is_nullable_struct_type(node.type, status) || is_nullable_scalar_type(node.type, status)) {
 		const flag_name = status.current_nullable_call_flag;
 		const arg_list_empty = node.params.length === 0 && !is_closure_callee;
 		if (flag_name) status.code += `${arg_list_empty ? "" : ", "}&${flag_name}`;
@@ -37090,6 +37941,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];
@@ -37179,13 +38036,13 @@ function emit_nullable_arg_flag(arg, status) {
 	}
 	if (arg.node_type === "value") {
 		const vn = arg;
-		if (is_nullable_struct_type(vn.type, status) || is_nullable_scalar_type(vn.type)) status.code += `${has_flag_name(vn.value)}`;
+		if (is_nullable_struct_type(vn.type, status) || is_nullable_scalar_type(vn.type, status)) status.code += `${has_flag_name(vn.value)}`;
 		else status.code += `1`;
 		return;
 	}
 	if (arg.node_type === "access" && arg.access.node_type === "access_field") {
 		const t = type_from_value_node$1(arg);
-		if (is_nullable_struct_type(t, status) || is_nullable_scalar_type(t)) {
+		if (is_nullable_struct_type(t, status) || is_nullable_scalar_type(t, status)) {
 			const saved = begin_code_scratch(status);
 			build_node$1(arg, status);
 			const expr = end_code_scratch(status, saved);
@@ -37497,6 +38354,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 +38726,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++) {
@@ -37979,13 +38844,13 @@ function build_access_node$1(node, status) {
 						build_node$1(access_func.params[i], status);
 						status.suppress_dereference = false;
 					}
-					if (target_param && !target_param.is_self_param && (is_nullable_struct_type(target_param.type, status) || is_nullable_scalar_type(target_param.type))) {
+					if (target_param && !target_param.is_self_param && (is_nullable_struct_type(target_param.type, status) || is_nullable_scalar_type(target_param.type, status))) {
 						status.code += `, `;
 						emit_nullable_arg_flag(access_func.params[i], status);
 					}
 				}
 				const method_ret_type = (target_method ?? trait_default_func)?.return_type ?? access_func.type;
-				if (is_nullable_struct_type(method_ret_type, status) || is_nullable_scalar_type(method_ret_type)) {
+				if (is_nullable_struct_type(method_ret_type, status) || is_nullable_scalar_type(method_ret_type, status)) {
 					const flag_name = status.current_nullable_call_flag;
 					status.code += `, `;
 					status.code += flag_name ? `&${flag_name}` : `(unsigned char *)&(unsigned char){0}`;
@@ -39730,11 +40595,11 @@ function is_nullable_struct_assignment(node, status) {
 	if (node.left_value.node_type === "value") {
 		const name = node.left_value.value;
 		const t = status.scoped_declarations.find((d) => d.name === name)?.type || status.variable_types?.get(name);
-		return is_nullable_struct_type(t, status) || is_nullable_scalar_type(t);
+		return is_nullable_struct_type(t, status) || is_nullable_scalar_type(t, status);
 	}
 	if (node.left_value.node_type === "access" && node.left_value.access.node_type === "access_field") {
 		const field_type = node.left_value.access.type;
-		return is_nullable_struct_type(field_type, status) || is_nullable_scalar_type(field_type);
+		return is_nullable_struct_type(field_type, status) || is_nullable_scalar_type(field_type, status);
 	}
 	return false;
 }
@@ -39789,7 +40654,7 @@ function build_nullable_struct_assignment(node, status, nir_rhs) {
 		const flag_name = has_flag_name(name);
 		const decl_type = status.scoped_declarations.find((d) => d.name === name)?.type || status.variable_types?.get(name);
 		const type_name = decl_type?.name || "";
-		const is_scalar = is_nullable_scalar_type(decl_type);
+		const is_scalar = is_nullable_scalar_type(decl_type, status);
 		const scalar_size = is_scalar ? aarch64_size(type_name) : 0;
 		const reclaimable = !(node.right_value.node_type === "value" && node.right_value.value === name) && !!status.heap_string_fields?.size && Array.from(status.heap_string_fields).some((k) => k.startsWith(`${name}.`));
 		if (rhs_is_null) {
@@ -39808,9 +40673,11 @@ function build_nullable_struct_assignment(node, status, nir_rhs) {
 				}
 			}
 		};
-		const value_is_nullable_call = node.right_value.node_type === "func_call" && (is_nullable_struct_type(node.right_value.type, status) || is_nullable_scalar_type(node.right_value.type));
+		const value_is_nullable_call = node.right_value.node_type === "func_call" && (is_nullable_struct_type(node.right_value.type, status) || is_nullable_scalar_type(node.right_value.type, status));
 		const rhs_value_type = call_result_type(node.right_value) ?? type_from_value_node$1(node.right_value);
-		if (node.right_value.node_type === "access" && rhs_value_type?.is_nullable && (is_nullable_struct_type(rhs_value_type, status) || is_nullable_scalar_type(rhs_value_type))) {
+		const value_is_nullable_access = node.right_value.node_type === "access" && rhs_value_type?.is_nullable && (is_nullable_struct_type(rhs_value_type, status) || is_nullable_scalar_type(rhs_value_type, status));
+		const rhs_is_field_read = value_is_nullable_access && is_nullable_scalar_type(rhs_value_type, status) && node.right_value.access.node_type === "access_field";
+		if (value_is_nullable_access && !rhs_is_field_read) {
 			if (reclaimable) emit_recorded_field_reclaim_for_slot(status, name, type_name);
 			retarget_records();
 			emit_rhs_value(node.right_value, nir_rhs, status);
@@ -39827,6 +40694,17 @@ function build_nullable_struct_assignment(node, status, nir_rhs) {
 			emit_var_store(status, "x9", flag_name, 8);
 			return;
 		}
+		if (rhs_is_field_read) {
+			if (reclaimable) emit_recorded_field_reclaim_for_slot(status, name, type_name);
+			retarget_records();
+			emit_rhs_value(node.right_value, nir_rhs, status);
+			ensure_newline(status);
+			emit_var_store(status, "x0", name, scalar_size);
+			load_nullable_has(node.right_value, "x9", status);
+			ensure_newline(status);
+			emit_var_store(status, "x9", flag_name, 8);
+			return;
+		}
 		if (value_is_nullable_call) {
 			if (reclaimable) emit_recorded_field_reclaim_for_slot(status, name, type_name);
 			retarget_records();
@@ -39843,7 +40721,7 @@ function build_nullable_struct_assignment(node, status, nir_rhs) {
 			status.call_x8_preset = old_preset;
 			return;
 		}
-		const rhs_is_nullable_value = !!rhs_value_type?.is_nullable && (is_nullable_struct_type(rhs_value_type, status) || is_nullable_scalar_type(rhs_value_type));
+		const rhs_is_nullable_value = !!rhs_value_type?.is_nullable && (is_nullable_struct_type(rhs_value_type, status) || is_nullable_scalar_type(rhs_value_type, status));
 		let rhs_flag_slot;
 		if (rhs_is_nullable_value) {
 			load_nullable_has(node.right_value, "x9", status);
@@ -39880,7 +40758,7 @@ function build_nullable_struct_assignment(node, status, nir_rhs) {
 	const field_offset = get_field_offset(target_type.name, field_name, status);
 	const has_offset = get_field_has_offset(target_type.name, field_name, status);
 	const struct_size = get_struct_size(type_name, status);
-	const field_is_scalar = is_nullable_scalar_type(field_access.type);
+	const field_is_scalar = is_nullable_scalar_type(field_access.type, status);
 	get_source_address(access.target, status);
 	ensure_newline(status);
 	emit_asm(status, `str x0, [sp, #-16]!\n`);
@@ -39891,7 +40769,7 @@ function build_nullable_struct_assignment(node, status, nir_rhs) {
 		return;
 	}
 	const rhs_t = call_result_type(node.right_value) ?? type_from_value_node$1(node.right_value);
-	const rhs_is_nullable_value = !!rhs_t?.is_nullable && (is_nullable_struct_type(rhs_t, status) || is_nullable_scalar_type(rhs_t));
+	const rhs_is_nullable_value = !!rhs_t?.is_nullable && (is_nullable_struct_type(rhs_t, status) || is_nullable_scalar_type(rhs_t, status));
 	let rhs_flag_slot;
 	if (rhs_is_nullable_value) {
 		load_nullable_has(node.right_value, "x10", status);
@@ -40283,6 +41161,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 +41386,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 +41470,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 +41498,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 +41693,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);
@@ -41698,7 +42594,7 @@ function build_operation_node(node, status) {
 	if (node.op === "??") {
 		const left_t = type_from_value_node$1(node.left_value);
 		const left_is_nullable_struct = is_nullable_struct_type(left_t, status);
-		const left_is_nullable_scalar = is_nullable_scalar_type(left_t);
+		const left_is_nullable_scalar = is_nullable_scalar_type(left_t, status);
 		if (left_is_nullable_scalar && node.left_value.node_type === "func_call") {
 			build_operand(node.left_value, "x0", status);
 			ensure_newline(status);
@@ -41750,11 +42646,11 @@ function build_operation_node(node, status) {
 	if ((node.op === "==" || node.op === "!=") && is_null_literal$1(node.left_value) !== is_null_literal$1(node.right_value)) {
 		const nullable_flagged_side = (n) => {
 			const t = type_from_value_node$1(n);
-			return is_nullable_struct_type(t, status) || is_nullable_scalar_type(t);
+			return is_nullable_struct_type(t, status) || is_nullable_scalar_type(t, status);
 		};
 		const nullable_side = nullable_flagged_side(node.left_value) ? node.left_value : node.right_value;
 		const side_type = type_from_value_node$1(nullable_side);
-		if (is_nullable_struct_type(side_type, status) || is_nullable_scalar_type(side_type)) {
+		if (is_nullable_struct_type(side_type, status) || is_nullable_scalar_type(side_type, status)) {
 			load_nullable_has(nullable_side, "x1", status);
 			ensure_newline(status);
 			emit_asm(status, `cmp x1, #0\n`);
@@ -42272,7 +43168,7 @@ function load_nullable_has(node, target_reg, status) {
 			get_source_address(access.target, status);
 			ensure_newline(status);
 			if (target_reg !== "x0") emit_asm(status, `mov ${target_reg}, x0\n`);
-			const scalar_field = is_nullable_scalar_type(access.access.type);
+			const scalar_field = is_nullable_scalar_type(access.access.type, status);
 			const wreg = target_reg.replace("x", "w");
 			const load_op = scalar_field ? `ldrb ${wreg}` : `ldr ${target_reg}`;
 			if (has_off === 0) emit_asm(status, `${load_op}, [${target_reg}]\n`);
@@ -44474,7 +45370,7 @@ function build_access_method(node, access_func, status) {
 	const access_callee_params = access_callee_method?.params?.filter((p) => !p.is_self_param);
 	const return_struct = !access_func.type.is_view && !access_func.type.is_array && (!!status.structs.find((s) => s.name === access_func.type.name && !s.is_simple_type && !s.is_class) || get_enum_sret_size(access_func.type.name, status) !== void 0);
 	const method_ret_type = access_callee_method?.return_type ?? access_func.type;
-	const nullable_scalar_ret = is_nullable_scalar_type(method_ret_type) && !method_ret_type.is_ref;
+	const nullable_scalar_ret = is_nullable_scalar_type(method_ret_type, status) && !method_ret_type.is_ref;
 	let temp_addr = "";
 	let temp_offset = 0;
 	if (return_struct || nullable_scalar_ret) {
@@ -44594,7 +45490,7 @@ function build_access_method(node, access_func, status) {
 	for (let i = 0; i < access_func.params.length; i++) {
 		if ((access_func.ref_param_indices ?? []).includes(i)) continue;
 		const cp = access_callee_params?.[i];
-		if (cp && is_nullable_scalar_type(cp.type) || is_nullable_scalar_type(access_func.params[i].type)) nullable_scalar_arg_set.add(i);
+		if (cp && is_nullable_scalar_type(cp.type, status) || is_nullable_scalar_type(access_func.params[i].type, status)) nullable_scalar_arg_set.add(i);
 	}
 	const arg_slot = [];
 	let total_arg_slots = 0;
@@ -44649,7 +45545,7 @@ function build_access_method(node, access_func, status) {
 			if (arg.node_type === "value" && arg.value === "null") {
 				emit_asm(status, `mov x0, #0\n`);
 				emit_asm(status, `mov x1, #0\n`);
-			} else if (arg.node_type === "value" && is_nullable_scalar_type(arg.type)) {
+			} else if (arg.node_type === "value" && is_nullable_scalar_type(arg.type, status)) {
 				const vname = arg.value;
 				emit_var_load(status, "x0", vname, aarch64_size(arg.type.name));
 				emit_var_load(status, "x1", has_flag_name(vname), 8);
@@ -44856,7 +45752,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 +46794,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 +47033,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);
@@ -48906,13 +49809,33 @@ function can_class_int_coerce(target, value, status) {
 }
 //#endregion
 //#region ../src/check/utils/check_type_exists.ts
+/**
+* Containers whose elements live in raw T-sized slots (the `#arch` generic
+* bodies size each slot from the type name alone). A flagged-nullable
+* element type (`List<int?>`) has no per-slot null flag there, so `0`/`false`
+* would read back as null — rejected instead of silently misbehaving.
+* Element types with an in-band null (`string?`, class/trait `?`) stay legal.
+*/
+const RAW_ELEMENT_CONTAINERS = /* @__PURE__ */ new Set([
+	"Array",
+	"Buffer",
+	"List",
+	"Set",
+	"Map",
+	"Graph",
+	"LinkedList",
+	"Tree",
+	"Arena"
+]);
 function check_type_exists(type, status, start) {
+	if (type.is_nullable && type.is_array && !type.is_ref && !type.is_pointer && is_nullable_scalar_name(type.name, status)) add_error(status, `Nullable element type '${type.name}?' is not supported in an array: element storage has no per-element null flag`, start);
 	if (type.name === "tuple" && type.tuple_types?.length) {
 		let ok = true;
 		for (const elem of type.tuple_types) if (!check_type_exists(elem, status, start)) ok = false;
 		return ok;
 	}
 	if (type.name === "anon_enum" && type.enum_cases?.length) {
+		if (type.is_nullable && type.enum_cases.some((c) => c.types.length > 0)) add_error(status, `Nullable type '${type_name(type)}' is not supported: enums with associated data have no separate null flag`, start);
 		let ok = true;
 		for (const c of type.enum_cases) for (const t of c.types) if (!check_type_exists(t, status, start)) ok = false;
 		return ok;
@@ -48929,19 +49852,26 @@ function check_type_exists(type, status, start) {
 			}
 		}
 		type.name = declared.name;
+		if (type.is_nullable) {
+			if (status.enums.findLast((e) => (e.name === declared.name || e.source_name === declared.name) && !e.is_generic)?.has_associated_data) add_error(status, `Nullable type '${type_name(type)}' is not supported: enums with associated data have no separate null flag`, start);
+		}
 	} else if (!status.types.includes(type.name)) {
 		add_error(status, `Unknown type: ${type_name(type)}`, start);
 		return false;
 	}
 	if (type.tuple_types) for (const elem of type.tuple_types) check_type_exists(elem, status, start);
-	if (type.type_args) for (const arg of type.type_args) {
-		if (arg.name === "func") {
-			add_error(status, `func types cannot be used as type arguments ('${type.name}<...>')`, start);
-			continue;
+	if (type.type_args) {
+		if (RAW_ELEMENT_CONTAINERS.has(type.name)) {
+			for (const arg of type.type_args) if (is_nullable_flagged_type(arg, status)) add_error(status, `Nullable element type '${type_name(arg)}' is not supported in '${type.name}<...>': container element storage has no per-element null flag`, start);
 		}
-		check_type_exists(arg, status, start);
-	}
-	else {
+		for (const arg of type.type_args) {
+			if (arg.name === "func") {
+				add_error(status, `func types cannot be used as type arguments ('${type.name}<...>')`, start);
+				continue;
+			}
+			check_type_exists(arg, status, start);
+		}
+	} else {
 		const struct = status.structs.findLast((s) => s.name === type.name);
 		if (struct?.is_generic) {
 			if (!struct.type_params.every((tp) => status.type_params.includes(tp))) add_error(status, `Generic type '${type.name}' requires type arguments (expected <${struct.type_params.join(", ")}>)`, start);
@@ -51469,6 +52399,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 +52594,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) {
@@ -51800,20 +52750,57 @@ function build_hash(struct, fields) {
 }
 /**
 * Whether `struct` is eligible for a synthesized `copy` method: a value
-* struct whose only ownership is its DIRECT string fields — the same set
-* the pass-by-value argument convention covers. A struct that additionally
-* owns non-string heap (a resource-releasing `#destroy`, a class field, a
-* nested requiring-move struct) cannot be deep-copied by "byte copy +
-* strdup the strings" — its copy stays unwritten (move/swap remains the
-* escape hatch) — and a struct with no string fields is already soundly
-* byte-copyable, so it needs no method.
+* struct whose every field is independently deep-copyable — direct string
+* fields (strdup'd), scalars/arrays (byte copies), `List<T>` fields whose
+* element is itself deep-copyable (the library `List.copy` deep-copies slots
+* via the owning store contract), and nested copyable structs (recursing
+* through their own `copy`). Class fields, enum-with-data fields (their
+* stores transfer payload ownership), class/trait-carrying `List` elements,
+* and resource-releasing `#destroy`s cannot be deep-copied by synthesis —
+* the copy stays unwritten (move/swap remains the escape hatch) — and a
+* struct with nothing to deep-copy (no string, `List`, or nested-copyable
+* field) is already soundly byte-copyable, so it needs no method.
 */
 function struct_is_copyable(struct, status) {
 	if (struct.is_class || struct.is_generic || struct.is_simple_type) return false;
-	if (direct_string_fields(struct).length === 0) return false;
-	if (struct_owns_non_string_heap(struct, status, /* @__PURE__ */ new Set())) return false;
+	if (struct_owns_resource(struct, status, /* @__PURE__ */ new Set())) return false;
+	if (!struct_needs_copy(struct, status)) return false;
 	return struct_copy_ctor_args(struct) !== null;
 }
+/** Whether any field of `struct` actually needs the synthesized deep copy:
+*  a direct string field, a deep-copyable `List<T>` field, or a nested
+*  copyable struct field. A struct of flat values byte-copies soundly
+*  without a method. */
+function struct_needs_copy(struct, status) {
+	if (direct_string_fields(struct).length > 0) return true;
+	for (const field of struct.fields) {
+		if (field.type.is_ref || field.type.is_view || field.type.is_array) continue;
+		if (field_copy_call(field.type, status)) return true;
+	}
+	return false;
+}
+/**
+* Whether `struct` owns a resource a synthesized copy CANNOT duplicate: a
+* `#destroy` that releases something (a raw block / extern free), or a field
+* whose type has no deep-copy story (a class instance, a `List` of
+* class/trait elements, a nested struct with such a field). Fields that DO
+* have a deep-copy story (strings, nested copyables, copyable `List`s,
+* payload-copyable enums) don't block synthesis. Mirrors the old
+* `struct_owns_non_string_heap` gate but understands container deep copies.
+*/
+function struct_owns_resource(struct, status, visited) {
+	if (visited.has(struct.name)) return false;
+	visited.add(struct.name);
+	const destroy = struct.functions.find((f) => f.name === "#destroy");
+	if (destroy && destroy_releases(destroy)) return true;
+	for (const field of struct.fields) {
+		if (field.type.is_ref || field.type.is_view) continue;
+		if (field.type.name === "string" && !field.type.is_array) continue;
+		if (field.type.is_nullable) return true;
+		if (!field_copyable(field.type, status)) return true;
+	}
+	return false;
+}
 /**
 * How a synthesized `copy` constructs the fresh value: the zero-argument
 * `#init` overload when one exists (auto or user), else the bodyless AUTO
@@ -51829,14 +52816,49 @@ function struct_copy_ctor_args(struct) {
 	if (!auto) return null;
 	return auto.params.filter((p) => !p.is_self_param).map((p) => p.name);
 }
-/** Whether `type` names a struct that has (or will get) a `copy` method.
-*  Order-independent: it re-evaluates the eligibility predicate instead of
-*  looking for an already-synthesized method, so an outer struct nested in
-*  the same pre-pass resolves a later-declared field struct. */
-function field_type_is_copyable(type, status) {
+/** Whether `type` has (or will get) a deep-copy story: a struct with a
+*  synthesized `copy`, a `List<T>` whose element is deep-copyable (the
+*  library `List.copy` deep-copies slots via the owning store contract), or
+*  a primitive / plain (payload-free) enum. Order-independent: it
+*  re-evaluates the eligibility predicate instead of looking for an
+*  already-synthesized method, so an outer struct nested in the same
+*  pre-pass resolves a later-declared field struct. */
+function field_copyable(type, status) {
+	if (!type.name || type.is_array || type.is_ref || type.is_view || type.is_nullable) return false;
+	if (type.name === "List" && type.type_args?.length === 1) return element_copyable(type.type_args[0], status);
+	const nested_struct = status.structs.find((s) => s.name === type.name);
+	if (nested_struct) {
+		if (nested_struct.is_simple_type) return true;
+		return struct_is_copyable(nested_struct, status);
+	}
+	const en = status.enums.find((e) => e.name === type.name);
+	if (en) return !en.has_associated_data;
+	return !status.traits.some((t) => t.name === type.name);
+}
+/** Whether a `List<T>` element type is deep-copyable (see
+*  `field_copyable`). */
+function element_copyable(type, status) {
 	if (!type.name || type.is_array || type.is_ref || type.is_view || type.is_nullable) return false;
+	if (type.name === "string") return true;
+	if (type.name === "List" && type.type_args?.length === 1) return element_copyable(type.type_args[0], status);
 	const nested = status.structs.find((s) => s.name === type.name);
-	return !!nested && struct_is_copyable(nested, status);
+	if (nested) {
+		if (nested.is_simple_type) return true;
+		return !nested.is_class && struct_is_copyable(nested, status);
+	}
+	const en = status.enums.find((e) => e.name === type.name);
+	if (en) return !en.has_associated_data;
+	return !status.traits.some((t) => t.name === type.name);
+}
+/** Whether `build_copy` must route the field through a `.copy()` call (a
+*  nested copyable struct, or a `List<T>` field): everything else byte
+*  copies through plain field assignment (strings strdup via the field-write
+*  path, primitives/plain enums are flat values). */
+function field_copy_call(type, status) {
+	if (!type.name || type.is_array || type.is_ref || type.is_view || type.is_nullable) return false;
+	if (type.name === "List" && type.type_args?.length === 1) return element_copyable(type.type_args[0], status);
+	const nested_struct = status.structs.find((s) => s.name === type.name);
+	return !!nested_struct && !nested_struct.is_simple_type && struct_is_copyable(nested_struct, status);
 }
 /**
 * Synthesize `pub func copy(self) -> Struct` for owning value structs: a
@@ -51852,8 +52874,8 @@ function build_copy(struct, status) {
 	const ctor = new FunctionCallNode(-1, struct.name, new Type(struct.name), ctor_args.map((name) => field_access("self", name)));
 	const statements = [new DeclarationNode(-1, "private", "var", "c", new Type(struct.name), ctor)];
 	for (const field of struct.fields) {
-		const right = field_type_is_copyable(field.type, status) ? method_call(field_access("self", field.name), "copy") : field_access("self", field.name);
-		statements.push(new AssignmentNode(-1, field_access("c", field.name), right, "="));
+		const right = field_copy_call(field.type, status) ? method_call(field_access("self", field.name), "copy") : field_access("self", field.name);
+		statements.push(new AssignmentNode(-1, field_access("c", field.name), right));
 	}
 	statements.push(new ReturnNode(-1, new ValueNode(-1, "c")));
 	return new FunctionNode(-1, "pub", "copy", new Type(struct.name), [self_param(struct)], statements);
@@ -52932,7 +53954,10 @@ function monomorphize(generic_struct, type_args, status) {
 					mono_field.type = constructed;
 				}
 			}
-			substitute_raw_in_node(mono_field.value, substitution, status.structs, void 0, status.traits, status.enums);
+			substitute_raw_in_node(mono_field.value, substitution, status.structs, void 0, status.traits, {
+				enums: status.enums,
+				bitsets: status.bitsets
+			});
 		}
 		mono_field.is_library = field.is_library;
 		mono_field.is_readonly = field.is_readonly;
@@ -52967,7 +53992,10 @@ function monomorphize(generic_struct, type_args, status) {
 	for (const func of generic_struct.functions) {
 		if (func.name === "#init") continue;
 		const cloned = clone_node(func);
-		substitute_raw_types(cloned, substitution, status.structs, status.traits, status.enums);
+		substitute_raw_types(cloned, substitution, status.structs, status.traits, {
+			enums: status.enums,
+			bitsets: status.bitsets
+		});
 		fold_substituted_constant_ifs(cloned.statements);
 		rename_local_labels(cloned, mono_name);
 		const retype_roots = [...cloned.statements, ...cloned.allocations ?? []];
@@ -52980,7 +54008,10 @@ function monomorphize(generic_struct, type_args, status) {
 			param.type = substitute_type(param.type, substitution);
 			substitute_param_signature(param, substitution);
 			if (param.type.type_args?.length) param.type = materialize_generic_enum_type(param.type, status);
-			if (param.constraint) substitute_raw_in_node(param.constraint, substitution, status.structs, void 0, status.traits, status.enums);
+			if (param.constraint) substitute_raw_in_node(param.constraint, substitution, status.structs, void 0, status.traits, {
+				enums: status.enums,
+				bitsets: status.bitsets
+			});
 		}
 		retype_param_references(retype_roots, cloned.params);
 		retype_local_references(retype_roots);
@@ -53008,7 +54039,10 @@ function monomorphize(generic_struct, type_args, status) {
 		if (variadic_init_unsupported(generic_init)) continue;
 		if (!generic_init.statements.some((s) => s.node_type !== "raw")) continue;
 		const cloned = clone_node(generic_init);
-		substitute_raw_types(cloned, substitution, status.structs, status.traits, status.enums);
+		substitute_raw_types(cloned, substitution, status.structs, status.traits, {
+			enums: status.enums,
+			bitsets: status.bitsets
+		});
 		fold_substituted_constant_ifs(cloned.statements);
 		rename_local_labels(cloned, mono_name);
 		cloned.return_type = new Type(mono_name);
@@ -53016,7 +54050,10 @@ function monomorphize(generic_struct, type_args, status) {
 		for (const param of cloned.params) {
 			param.type = substitute_type(param.type, substitution);
 			substitute_param_signature(param, substitution);
-			if (param.constraint) substitute_raw_in_node(param.constraint, substitution, status.structs, void 0, status.traits, status.enums);
+			if (param.constraint) substitute_raw_in_node(param.constraint, substitution, status.structs, void 0, status.traits, {
+				enums: status.enums,
+				bitsets: status.bitsets
+			});
 		}
 		const cloned_self = cloned.params.find((p) => p.is_self_param);
 		if (cloned_self) cloned_self.type = new Type(mono_name);
@@ -53521,7 +54558,7 @@ function derive_annotations_for_access_func(access_node, fc, status) {
 		const p = func.params[i];
 		if (p.is_self_param) continue;
 		if (!p.type?.is_nullable) continue;
-		if (status.structs.find((s) => s.name === p.type.name && !s.is_class) || is_nullable_scalar_type(p.type)) nullable_indices.push(i - (self_offset >= 0 ? self_offset + 1 : 0));
+		if (status.structs.find((s) => s.name === p.type.name && !s.is_class) || is_nullable_scalar_type(p.type, status)) nullable_indices.push(i - (self_offset >= 0 ? self_offset + 1 : 0));
 	}
 	if (nullable_indices.length > 0) fc.nullable_param_indices = nullable_indices;
 	if (func.return_constraint && !fc.return_bounds) {
@@ -53900,7 +54937,7 @@ function fold_substituted_constant_ifs(statements) {
 		statements.splice(i, 1, ...kept);
 	}
 }
-function substitute_raw_types(func, substitution, structs, traits, enums) {
+function substitute_raw_types(func, substitution, structs, traits, tables) {
 	const deref_params = /* @__PURE__ */ new Set();
 	for (const param of func.params) {
 		const resolved = substitution.get(param.type.name);
@@ -53909,7 +54946,7 @@ function substitute_raw_types(func, substitution, structs, traits, enums) {
 		const s = structs.find((x) => x.name === resolved);
 		if (s && !s.is_simple_type && !s.is_class) deref_params.add(param.name);
 	}
-	for (const stmt of func.statements) substitute_raw_in_node(stmt, substitution, structs, deref_params, traits, enums);
+	for (const stmt of func.statements) substitute_raw_in_node(stmt, substitution, structs, deref_params, traits, tables);
 }
 function rename_local_labels(node, prefix) {
 	if (node.node_type === "raw") {
@@ -53942,7 +54979,7 @@ function raw_type_alignment(name) {
 function raw_align_to(offset, alignment) {
 	return Math.ceil(offset / alignment) * alignment;
 }
-function raw_type_size(name, structs, enums) {
+function raw_type_size(name, structs, tables) {
 	switch (name) {
 		case "bool":
 		case "int8":
@@ -53953,13 +54990,13 @@ function raw_type_size(name, structs, enums) {
 		case "int32":
 		case "uint32": return 4;
 	}
-	const enum_node = enums?.find((e) => e.name === name && !e.is_generic);
+	const enum_node = tables.enums.find((e) => e.name === name && !e.is_generic);
 	if (enum_node) {
 		if (!enum_node.has_associated_data) return 8;
 		let max_payload = 0;
 		for (const c of enum_node.cases) {
 			let case_size = 0;
-			for (const p of c.params) case_size += raw_type_size(p.type.name, structs, enums);
+			for (const p of c.params) case_size += raw_type_size(p.type.name, structs, tables);
 			max_payload = Math.max(max_payload, case_size);
 		}
 		return 8 + Math.ceil(max_payload / 8) * 8;
@@ -53974,9 +55011,9 @@ function raw_type_size(name, structs, enums) {
 			size += 16;
 			continue;
 		}
-		size += raw_type_size(field.type.name, structs, enums);
+		size += raw_type_size(field.type.name, structs, tables);
 		if (field.type.is_nullable && structs.find((s) => s.name === field.type.name && !s.is_simple_type && !s.is_class)) size += 8;
-		else if (is_nullable_scalar_type(field.type)) size += 1;
+		else if (is_nullable_scalar_type(field.type, tables)) size += 1;
 	}
 	return raw_align_to(size, 8);
 }
@@ -54021,12 +55058,15 @@ function raw_block_is_pure_asm(value) {
 function is_reference_type_arg(t, structs, traits) {
 	return !!traits.some((tr) => tr.name === t.name) || !!structs.find((s) => s.name === t.name && s.is_class);
 }
-function substitute_raw_in_node(node, substitution, structs, deref_params = /* @__PURE__ */ new Set(), traits = [], enums = []) {
+function substitute_raw_in_node(node, substitution, structs, deref_params = /* @__PURE__ */ new Set(), traits = [], tables = {
+	enums: [],
+	bitsets: []
+}) {
 	if (node.node_type === "value") {
 		const vn = node;
 		for (const [param, type] of substitution) {
 			if (vn.value === `${param}_SIZE`) {
-				vn.value = String(raw_type_size(type, structs, enums));
+				vn.value = String(raw_type_size(type, structs, tables));
 				vn.type = new Type("int", true);
 				return;
 			}
@@ -54051,7 +55091,7 @@ function substitute_raw_in_node(node, substitution, structs, deref_params = /* @
 			else if (struct_node) c_type_name = `struct ${type}`;
 			else c_type_name = raw_c_type_name(type);
 			value = value.replace(new RegExp(`\\b${param}\\b`, "g"), c_type_name);
-			const size = raw_type_size(type, structs, enums);
+			const size = raw_type_size(type, structs, tables);
 			const size_expr = raw_block_is_pure_asm(value) ? String(size) : `sizeof(${c_type_name})`;
 			value = value.replace(new RegExp(`\\b${param}_SIZE\\b`, "g"), size_expr);
 			value = value.replace(new RegExp(`\\b${param}_destroy\\b`, "g"), `${type}_destroy`);
@@ -54087,22 +55127,22 @@ function substitute_raw_in_node(node, substitution, structs, deref_params = /* @
 		if (any_node.func_return_type?.name) any_node.func_return_type = substitute_type(any_node.func_return_type, substitution);
 	}
 	if (any_node.allocations && Array.isArray(any_node.allocations)) {
-		for (const child of any_node.allocations) if (child && typeof child === "object" && "node_type" in child) substitute_raw_in_node(child, substitution, structs, deref_params, traits, enums);
+		for (const child of any_node.allocations) if (child && typeof child === "object" && "node_type" in child) substitute_raw_in_node(child, substitution, structs, deref_params, traits, tables);
 	}
 	if (any_node.statements && Array.isArray(any_node.statements)) {
-		for (const child of any_node.statements) if (child && typeof child === "object" && "node_type" in child) substitute_raw_in_node(child, substitution, structs, deref_params, traits, enums);
+		for (const child of any_node.statements) if (child && typeof child === "object" && "node_type" in child) substitute_raw_in_node(child, substitution, structs, deref_params, traits, tables);
 	}
 	if (any_node.params && Array.isArray(any_node.params)) {
-		for (const child of any_node.params) if (child && typeof child === "object" && "node_type" in child) substitute_raw_in_node(child, substitution, structs, deref_params, traits, enums);
+		for (const child of any_node.params) if (child && typeof child === "object" && "node_type" in child) substitute_raw_in_node(child, substitution, structs, deref_params, traits, tables);
 	}
-	if (any_node.value && any_node.value.node_type) substitute_raw_in_node(any_node.value, substitution, structs, deref_params, traits, enums);
-	if (any_node.left_value?.node_type) substitute_raw_in_node(any_node.left_value, substitution, structs, deref_params, traits, enums);
-	if (any_node.right_value?.node_type) substitute_raw_in_node(any_node.right_value, substitution, structs, deref_params, traits, enums);
-	if (any_node.target?.node_type) substitute_raw_in_node(any_node.target, substitution, structs, deref_params, traits, enums);
-	if (any_node.access?.node_type) substitute_raw_in_node(any_node.access, substitution, structs, deref_params, traits, enums);
-	if (any_node.swap?.node_type) substitute_raw_in_node(any_node.swap, substitution, structs, deref_params, traits, enums);
-	if (any_node.condition?.node_type) substitute_raw_in_node(any_node.condition, substitution, structs, deref_params, traits, enums);
-	if (any_node.index?.node_type) substitute_raw_in_node(any_node.index, substitution, structs, deref_params, traits, enums);
+	if (any_node.value && any_node.value.node_type) substitute_raw_in_node(any_node.value, substitution, structs, deref_params, traits, tables);
+	if (any_node.left_value?.node_type) substitute_raw_in_node(any_node.left_value, substitution, structs, deref_params, traits, tables);
+	if (any_node.right_value?.node_type) substitute_raw_in_node(any_node.right_value, substitution, structs, deref_params, traits, tables);
+	if (any_node.target?.node_type) substitute_raw_in_node(any_node.target, substitution, structs, deref_params, traits, tables);
+	if (any_node.access?.node_type) substitute_raw_in_node(any_node.access, substitution, structs, deref_params, traits, tables);
+	if (any_node.swap?.node_type) substitute_raw_in_node(any_node.swap, substitution, structs, deref_params, traits, tables);
+	if (any_node.condition?.node_type) substitute_raw_in_node(any_node.condition, substitution, structs, deref_params, traits, tables);
+	if (any_node.index?.node_type) substitute_raw_in_node(any_node.index, substitution, structs, deref_params, traits, tables);
 }
 function specialize_function(generic_func, call_node, status) {
 	const substitution = /* @__PURE__ */ new Map();
@@ -55121,7 +56161,7 @@ function check_function_call(node, status, func, target_type, self_value, self_p
 	for (let [i, param] of node.params.entries()) {
 		const func_param = func.params[i + self_offset];
 		if (func_param && func_param.type.is_nullable && !func_param.is_self_param && !func_param.type.is_ref && !func_param.type.is_array) {
-			if (status.structs.find((st) => st.name === func_param.type.name && !st.is_class && !st.is_simple_type) || is_nullable_scalar_type(func_param.type)) {
+			if (status.structs.find((st) => st.name === func_param.type.name && !st.is_class && !st.is_simple_type) || is_nullable_scalar_type(func_param.type, status)) {
 				if (!node.nullable_param_indices) node.nullable_param_indices = [];
 				if (!node.nullable_param_indices.includes(i)) node.nullable_param_indices.push(i);
 			}
@@ -55252,7 +56292,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 +57650,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 +59001,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);