nomen-lang 0.6.3 → 0.6.4

package/dist/index.mjs

@@ -6352,6 +6352,12 @@ var AccessFieldNode = class extends BaseNode {
 	destructure_index;
 	/** `[field = new_name]` rename form — struct/class targets only. */
 	is_destructure_rename;
+	/** `move` binding (`var [move a, field = move n] = expr`): the binding
+	*  TAKES OWNERSHIP of the field. The checker synthesizes the
+	*  revalidating swap (a fresh default of the field's type) once the
+	*  field resolves, so the build reuses the plain
+	*  `move field swap <replacement>` pipeline unchanged. */
+	destructure_move;
 	constructor(start, name, type) {
 		super("access_field", start);
 		this.name = name;
@@ -6748,6 +6754,14 @@ var ValueNode = class extends BaseNode {
 	* name. Mirrors FunctionCallNode.resolved_function.
 	*/
 	resolved_function;
+	/**
+	* Stamped by the literal-element last-use pass (stamp_literal_element_moves):
+	* this bare variable is a bracket-literal element (`[t, c]`) at its last
+	* use, so the checker's tuple-element ownership rule treats it as an
+	* inferred `move` (ownership transfers; the source's cleanup is
+	* suppressed) instead of rejecting the aliasing copy.
+	*/
+	literal_last_use_move;
 	constructor(start, value, type) {
 		super("value", start);
 		this.value = value;
@@ -7353,6 +7367,13 @@ var DeclarationNode = class extends BaseNode {
 	*  struct layout. Set at check time by check_function_call; consumed by the
 	*  build backends' declaration emitters. */
 	is_heap_array_literal;
+	/** True for a root `const string[] = [...]` declaration: Mach-O arm64
+	*  forbids pointer relocations in data sections, so the file-scope data
+	*  emission lays out only the length word + zeroed element space, and the
+	*  declaration is collected into main's prologue to store the rodata
+	*  label addresses at runtime. Set by the aarch64 build_block_node root
+	*  scan; consumed by build_declaration_node's rebuild inside main. */
+	global_runtime_init;
 	/** True for a hoisted call-argument temp (`_param_N`) that is a heap COPY
 	*  of a stack-array local, bound to a heap `Array<T>` param (non-`ref`).
 	*  `value` is the source ValueNode; the temp is materialised as a heap
@@ -8014,6 +8035,38 @@ 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();
 /**
@@ -8357,6 +8410,69 @@ function is_owned_string_branch_value(node, table) {
 	return false;
 }
 //#endregion
+//#region ../src/build_common/call_init_string_fields.ts
+/**
+* Whether a declaration-initializer expression is a value the callee's
+* return-boundary normalization made UNIFORMLY heap-owned, so the fresh
+* binding records every string field and frees them at scope exit:
+*
+*   - a plain function call registered as a normalized struct returner
+*     (the registry is populated at the callee's return sites — a callee
+*     built later, or one that returns slot borrows, is not registered and
+*     the binding keeps the pre-existing borrow behavior);
+*   - an owned accessor (`pop`/`move_T`/`copy`) — move-out semantics
+*     transfer slot-owned heap buffers to the binding.
+*
+* NOT normalized (never recorded): struct constructions (`Info(...)` — its
+* `#init` leaves rodata borrows and bypasses the return path) and container
+* BORROW accessors (`.at`/`.first`/`.slice`/`load` — the slot keeps
+* ownership; recording would free the container's storage).
+*/
+function is_normalized_struct_call(value, status) {
+	if (!value) return false;
+	if (value.node_type === "func_call") {
+		const call = value;
+		return !!status.normalized_struct_returners?.has(call.name);
+	}
+	if (value.node_type === "access") {
+		const access = value.access;
+		if (access?.node_type !== "access_func") return false;
+		const name = access.name ?? "";
+		if (is_container_borrow_accessor_name(name)) return false;
+		if (status.normalized_struct_returners?.has(name)) return true;
+		const target = value.target;
+		const receiver_type = target ? target.type ?? void 0 : void 0;
+		if (receiver_type?.name) {
+			const label = `${mono_type_name(receiver_type)}_${name}`;
+			if (status.normalized_struct_returners?.has(label)) return true;
+		}
+		return false;
+	}
+	return false;
+}
+/**
+* Record every direct string field of a call-initialized value-struct
+* binding (`var Info i = make()`) as heap-owned: the callee's return
+* normalization guarantees each field is a heap buffer, so scope-exit
+* auto_free must free them, and a later `i.field = …` write sees
+* old_was_heap and reclaims the displaced buffer instead of leaking it.
+* No-op for non-struct, class, view, and array types, for structs without
+* direct string fields, and for non-call initializers.
+*/
+function record_call_init_string_fields(node, status) {
+	if (!is_normalized_struct_call(node.value, status)) return;
+	const type = node.type;
+	if (!type?.name) return;
+	const mono_name = mono_type_name(type);
+	if (mono_name.startsWith("_Tuple_")) return;
+	const struct = status.structs.find((s) => s.name === mono_name && !s.is_simple_type);
+	if (!struct || struct.is_class) return;
+	const fields = direct_string_fields(struct);
+	if (!fields.length) return;
+	if (!status.heap_string_fields) status.heap_string_fields = /* @__PURE__ */ new Set();
+	for (const field of fields) status.heap_string_fields.add(`${node.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) {
@@ -8473,7 +8589,21 @@ var Walk = class {
 	reads = [];
 	declares = [];
 	assignments = [];
+	literals = [];
 	loop_stack = [];
+	literal(node, names, body) {
+		const loop_ranges = [...this.loop_stack];
+		const enter = ++this.stamp;
+		body();
+		const exit = ++this.stamp;
+		this.literals.push({
+			node,
+			enter,
+			exit,
+			loop_ranges,
+			names
+		});
+	}
 	interval(body) {
 		const enter = ++this.stamp;
 		body();
@@ -8610,6 +8740,80 @@ function classify_declare(decl, walk, param_names, func_label) {
 		desc: `var ${node.name} = ${source}`
 	};
 }
+/**
+* Stamps `literal_last_use_move` on bracket-literal elements (`[a, b]`) that
+* are bare `var` locals at their LAST USE: the literal then TRANSFERS
+* ownership of those locals instead of aliasing them (the checker's
+* tuple-element ownership rule consumes the stamp as an inferred `move`).
+*
+* Same conservative posture as the string pass: it may MISS a last use (the
+* element then needs an explicit `move`), never invent one — reads after the
+* literal, reads under an enclosing loop whose binding outlives the loop,
+* reads in spawn/async subtrees, any re-assignment of the source, and any
+* raw `#arch` body in the function all refuse the inference. Types are NOT
+* consulted here (this runs before checking) — the checker applies the
+* owning-type filter when consuming the stamp.
+*
+* Only the FIRST occurrence of a name per literal is stamped: two elements
+* moving the same local would alias each other inside the tuple.
+*/
+function stamp_literal_element_moves(root) {
+	let count = 0;
+	const visit_functions = (node) => {
+		if (node.node_type === "func") count += scan_function_literal_element_moves(node);
+		for (const child of child_nodes(node)) visit_functions(child);
+	};
+	visit_functions(root);
+	return count;
+}
+function scan_function_literal_element_moves(func) {
+	if (!func.statements?.length) return 0;
+	const walk = new Walk();
+	const param_names = new Set(func.params.map((p) => p.name));
+	for (const stmt of func.statements) walk_stmt(walk, stmt);
+	if (walk.has_raw) return 0;
+	let count = 0;
+	for (const site of walk.literals) {
+		const eligible = [];
+		for (const name of site.names) {
+			if (eligible.includes(name)) continue;
+			if (param_names.has(name)) continue;
+			const binding = walk.declares.filter((d) => d.name === name && d.enter < site.enter).at(-1);
+			if (!binding || binding.declaration !== "var") continue;
+			if (walk.writes.filter((w) => w.name === name).length > 1) continue;
+			let killed = false;
+			for (const r of walk.reads) {
+				if (r.name !== name) continue;
+				if (r.opaque) {
+					killed = true;
+					break;
+				}
+				if (r.enter > site.exit) {
+					killed = true;
+					break;
+				}
+				if (r.enter >= site.enter && r.enter <= site.exit) continue;
+				for (const loop of site.loop_ranges) if (r.enter >= loop.enter && r.enter <= loop.exit) {
+					if (!(binding.enter >= loop.enter && binding.exit <= loop.exit)) {
+						killed = true;
+						break;
+					}
+				}
+				if (killed) break;
+			}
+			if (!killed) eligible.push(name);
+		}
+		const values = site.node.values;
+		for (const v of values) {
+			const vn = v;
+			if (vn.node_type === "value" && typeof vn.value === "string" && eligible.includes(vn.value)) {
+				vn.literal_last_use_move = true;
+				count++;
+			}
+		}
+	}
+	return count;
+}
 function walk_stmt(walk, node) {
 	switch (node.node_type) {
 		case "declare": {
@@ -8746,7 +8950,10 @@ function walk_expr$1(walk, node) {
 		}
 		case "array": {
 			const arr = node;
-			for (const v of arr.values) walk_expr$1(walk, v);
+			const names = arr.values.map((v) => v).filter((v) => v.node_type === "value" && typeof v.value === "string" && /^[A-Za-z_][A-Za-z0-9_]*$/.test(v.value)).map((v) => v.value);
+			walk.literal(node, names, () => {
+				for (const v of arr.values) walk_expr$1(walk, v);
+			});
 			return;
 		}
 		default: for (const child of child_nodes(node)) walk_expr$1(walk, child);
@@ -11020,38 +11227,6 @@ function struct_needs_auto_destroy(struct, table) {
 	return false;
 }
 //#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_force_heap_strings.ts
 function scan_force_heap_strings(statements, structs) {
 	const result = /* @__PURE__ */ new Set();
@@ -13738,12 +13913,27 @@ function clear_heap_string_fields(status, var_name) {
 * fields are unconditionally heap and freed by the destroy path. Called from
 * emit_destroy_for_decl and directly from cleanup loops that skip moved
 * declarations before reaching it.
+*
+* For a nullable struct local (`is_nullable`), the frees are guarded on the
+* companion `_has` flag: the null representation leaves the value bytes
+* uninitialized (a `return null` callee writes only the flag), so reading a
+* field pointer without the guard frees stale stack garbage. Mirrors the C
+* backend's `if (<name>_has)` auto-free guard.
 */
-function release_heap_string_fields(status, decl_name, decl_type_name) {
+function release_heap_string_fields(status, decl_name, decl_type_name, is_nullable) {
 	if (!status.heap_string_fields?.size) return;
 	const prefix = `${decl_name}.`;
 	const fields = Array.from(status.heap_string_fields).filter((k) => k.startsWith(prefix)).map((k) => k.slice(prefix.length));
 	if (!fields.length) return;
+	let skip_label;
+	if (is_nullable) {
+		const flag_off = status.stack_offsets?.get(has_flag_name(decl_name));
+		if (flag_off !== void 0 && flag_off >= 0) {
+			skip_label = `.Lskip_rhs_${status.label_counter = (status.label_counter ?? 0) + 1}`;
+			emit_asm(status, `ldr x0, [x29, #${flag_off}]\n`);
+			emit_asm(status, `cbz x0, ${skip_label}\n`);
+		}
+	}
 	for (const field of fields) {
 		const offset = get_field_offset(decl_type_name, field, status);
 		emit_var_address(status, "x0", decl_name);
@@ -13751,6 +13941,7 @@ function release_heap_string_fields(status, decl_name, decl_type_name) {
 		emit_free(status);
 		status.heap_string_fields.delete(`${decl_name}.${field}`);
 	}
+	if (skip_label) emit_asm(status, `${skip_label}:\n`);
 }
 /**
 * Swap in a fresh scoped_declarations frame for a nested scope (if/while/
@@ -14109,7 +14300,7 @@ function is_struct_type$4(type_name, status) {
 }
 function emit_destroy_for_decl(status, decl_name, decl_type_name, addr_offset, type_args, is_nullable) {
 	const moved = status.moved ?? /* @__PURE__ */ new Set();
-	release_heap_string_fields(status, decl_name, decl_type_name);
+	release_heap_string_fields(status, decl_name, decl_type_name, is_nullable);
 	if (moved.has(decl_name)) return;
 	if (decl_type_name === "func" && status.stack_offsets?.has(decl_name)) {
 		const skip = `.Lclosure_free_done_${status.label_counter = (status.label_counter ?? 0) + 1}`;
@@ -14162,11 +14353,19 @@ function emit_destroy_for_decl(status, decl_name, decl_type_name, addr_offset, t
 		return;
 	}
 	const guard_null = !!is_nullable && struct_type.is_class && addr_offset === void 0;
+	const guard_has_flag = !!is_nullable && !struct_type.is_class && addr_offset === void 0;
 	let skip_label;
 	if (guard_null) {
 		emit_var_load(status, "x0", decl_name, 8);
 		skip_label = `.Lskip_nd_${status.label_counter = (status.label_counter ?? 0) + 1}`;
 		emit_asm(status, `cbz x0, ${skip_label}\n`);
+	} else if (guard_has_flag && (has_destroy(struct_type) || struct_needs_destroy(struct_type, status))) {
+		const flag_off = status.stack_offsets?.get(has_flag_name(decl_name));
+		if (flag_off !== void 0 && flag_off >= 0) {
+			skip_label = `.Lskip_nd_${status.label_counter = (status.label_counter ?? 0) + 1}`;
+			emit_asm(status, `ldr x0, [x29, #${flag_off}]\n`);
+			emit_asm(status, `cbz x0, ${skip_label}\n`);
+		}
 	}
 	if (has_destroy(struct_type) || struct_type.is_class) {
 		if (struct_type.is_class) {
@@ -14321,13 +14520,51 @@ function resolve_decl_struct(decl, status) {
 		}
 	}
 }
+/**
+* Emit the reclaim of a nullable struct local's OLD value before a
+* reassignment (`p = <value>` / `p = null`): when the slot's `_has` flag is
+* set, free every heap string field currently recorded for it. The frees are
+* emitted reading the slot's CURRENT bytes, so this must run before the new
+* value is copied in. Records are left intact — the caller retargets them
+* for the new value (the scope-exit release still owns the final state).
+* Returns true when anything was emitted.
+*/
+function emit_recorded_field_reclaim_for_slot(status, decl_name, decl_type_name) {
+	if (!status.heap_string_fields?.size) return false;
+	const prefix = `${decl_name}.`;
+	const fields = Array.from(status.heap_string_fields).filter((k) => k.startsWith(prefix)).map((k) => k.slice(prefix.length));
+	if (!fields.length) return false;
+	const flag_off = status.stack_offsets?.get(has_flag_name(decl_name));
+	if (flag_off === void 0 || flag_off < 0) return false;
+	const skip = `.Lskip_reclaim_${status.label_counter = (status.label_counter ?? 0) + 1}`;
+	emit_asm(status, `ldr x0, [x29, #${flag_off}]\n`);
+	emit_asm(status, `cbz x0, ${skip}\n`);
+	for (const field of fields) {
+		const offset = get_field_offset(decl_type_name, field, status);
+		emit_var_address(status, "x0", decl_name);
+		emit_asm(status, `ldr x0, [x0, #${offset}]\n`);
+		emit_free(status);
+	}
+	emit_asm(status, `${skip}:\n`);
+	return true;
+}
+/**
+* Drop every heap-string-field record under `prefix` (a variable name plus
+* dot). Used when a slot's ownership is retargeted — the records describe
+* the OLD value, which the caller has just reclaimed or displaced.
+*/
+function drop_heap_string_field_records(status, decl_name) {
+	if (!status.heap_string_fields?.size) return;
+	const prefix = `${decl_name}.`;
+	for (const key of Array.from(status.heap_string_fields)) if (key.startsWith(prefix)) status.heap_string_fields.delete(key);
+}
 function emit_destroy_for_scope(status, declarations_before) {
 	const moved = status.moved ?? /* @__PURE__ */ new Set();
 	const current_scope = status.heap_cleanup_stack?.[status.heap_cleanup_stack.length - 1];
 	if (current_scope?.heap_slots.length) {
 		for (let i = declarations_before; i < status.scoped_declarations.length; i++) {
 			const decl = status.scoped_declarations[i];
-			release_heap_string_fields(status, decl.name, decl.type.name);
+			release_heap_string_fields(status, decl.name, decl.type.name, decl.type.is_nullable);
 			if (moved.has(decl.name)) continue;
 			const scope_enum = status.enums.find((e) => e.name === decl.type.name && e.has_associated_data);
 			if (scope_enum && !decl.type.is_array) {
@@ -14370,6 +14607,18 @@ function emit_destroy_for_scope(status, declarations_before) {
 				emit_free(status);
 				continue;
 			}
+			const tuple_field_offsets = status.heap_string_tuple_fields?.get(decl.name);
+			if (tuple_field_offsets?.length) {
+				const var_offset = status.stack_offsets?.get(decl.name);
+				if (var_offset !== void 0 && var_offset >= 0) {
+					for (const field_offset of tuple_field_offsets) {
+						emit_asm(status, `add x0, x29, #${var_offset}\n`);
+						emit_asm(status, `ldr x0, [x0, #${field_offset}]\n`);
+						emit_free(status);
+					}
+					continue;
+				}
+			}
 			if (decl.type.name === "func") {
 				emit_destroy_for_decl(status, decl.name, "func");
 				continue;
@@ -14389,7 +14638,7 @@ function emit_destroy_for_scope(status, declarations_before) {
 	}
 	for (let i = declarations_before; i < status.scoped_declarations.length; i++) {
 		const decl = status.scoped_declarations[i];
-		release_heap_string_fields(status, decl.name, decl.type.name);
+		release_heap_string_fields(status, decl.name, decl.type.name, decl.type.is_nullable);
 		if (moved.has(decl.name)) continue;
 		const scope_enum = status.enums.find((e) => e.name === decl.type.name && e.has_associated_data);
 		if (scope_enum && !decl.type.is_array) {
@@ -14463,6 +14712,18 @@ function emit_destroy_for_scope(status, declarations_before) {
 			emit_free(status);
 			continue;
 		}
+		const tuple_field_offsets = status.heap_string_tuple_fields?.get(decl.name);
+		if (tuple_field_offsets?.length) {
+			const var_offset = status.stack_offsets?.get(decl.name);
+			if (var_offset !== void 0 && var_offset >= 0) {
+				for (const field_offset of tuple_field_offsets) {
+					emit_asm(status, `add x0, x29, #${var_offset}\n`);
+					emit_asm(status, `ldr x0, [x0, #${field_offset}]\n`);
+					emit_free(status);
+				}
+				continue;
+			}
+		}
 		if (is_field_struct_borrow(decl)) continue;
 		const resolved_decl = resolve_decl_struct(decl, status);
 		if (!resolved_decl) continue;
@@ -14739,13 +15000,31 @@ function materialize_func_value_a64(func, status) {
 	const lines = [];
 	lines.push(`.p2align 2`);
 	lines.push(`${thunk}:`);
-	const reg_shift = Math.min(slots, 8);
-	for (let s = 0; s < reg_shift - 1; s++) lines.push(`mov x${s}, x${s + 1}`);
-	for (let k = 0; slots + k > 8 && k < 64; k++) {
-		lines.push(`ldr x9, [sp, #${(k + 1) * 8}]`);
+	const normalizes_borrow_return = func.return_type?.name === "string" && !func.return_type?.is_view && !func.returns_move && func.returns_string_borrow !== false && !(status.heap_returning_functions?.has(target) || (status.heap_returning_functions?.has(func.name ?? "") ?? false));
+	const V = slots - 1;
+	const dest_stack_slots = Math.max(0, V - 8);
+	const dest_area = normalizes_borrow_return ? Math.ceil(dest_stack_slots * 8 / 16) * 16 : 0;
+	const frame_pad = normalizes_borrow_return ? dest_area + 16 : 0;
+	if (normalizes_borrow_return) {
+		lines.push(`stp x29, x30, [sp, #-16]!`);
+		if (dest_area > 0) lines.push(`sub sp, sp, #${dest_area}`);
+	}
+	const reg_moves = Math.min(V, 7);
+	for (let s = 0; s < reg_moves; s++) lines.push(`mov x${s}, x${s + 1}`);
+	if (V >= 8) lines.push(`ldr x7, [sp, #${frame_pad}]`);
+	for (let k = 0; k < V - 8; k++) {
+		lines.push(`ldr x9, [sp, #${frame_pad + (k + 1) * 8}]`);
 		lines.push(`str x9, [sp, #${k * 8}]`);
 	}
-	lines.push(`b ${target}`);
+	if (normalizes_borrow_return) {
+		lines.push(`bl ${target}`);
+		lines.push(`str x1, [sp, #-16]!`);
+		lines.push(status.audit ? `bl _nomen_strdup_wrap` : `bl _strdup`);
+		lines.push(`ldr x1, [sp], #16`);
+		if (dest_area > 0) lines.push(`add sp, sp, #${dest_area}`);
+		lines.push(`ldp x29, x30, [sp], #16`);
+		lines.push(`ret`);
+	} else lines.push(`b ${target}`);
 	lines.push(``);
 	status.closure_definitions = (status.closure_definitions ?? "") + lines.join("\n") + "\n";
 	status.closure_definitions = (status.closure_definitions ?? "") + DATA_SECTION_OPEN + `.p2align 3\n${descriptor}:\n\t.quad ${thunk}\n\t.quad 0\n\t.quad 0\n\t.quad 0\n` + TEXT_SECTION_RESTORE;
@@ -19267,6 +19546,8 @@ function build_function_node$1(node, status) {
 	if (check_c_fallback(node, void 0, status)) return;
 	const old_function_name = status.current_function_name;
 	status.current_function_name = emission_label(node);
+	const old_is_closure = status.current_function_is_closure;
+	status.current_function_is_closure = !!node.is_closure;
 	status.function_nursery_depth = status.nursery_stack?.length ?? 0;
 	const old_scoped_declarations = status.scoped_declarations;
 	status.scoped_declarations = [];
@@ -19855,6 +20136,7 @@ function build_function_node$1(node, status) {
 	status.heap_cleanup_stack = old_heap_cleanup_stack;
 	status.trait_class_frames = old_trait_class_frames;
 	status.current_function_name = old_function_name;
+	status.current_function_is_closure = old_is_closure;
 	status.stack_size = old_stack_size;
 	status.stack_offsets = old_stack_offsets;
 	status.closure_env_slot = old_closure_env_slot;
@@ -21381,7 +21663,13 @@ function build_block_node$1(node, status) {
 			if (is_struct_node(child) || is_trait_node(child) || is_function_node(child) || child.node_type === "enum" || child.node_type === "bitset") continue;
 			if (child.node_type === "declare") {
 				const decl = child;
-				if (decl.declaration === "const") continue;
+				if (decl.declaration === "const") {
+					if (decl.type?.name === "string" && decl.type.is_array && decl.value?.node_type === "array") {
+						decl.global_runtime_init = true;
+						module_init_statements.push(child);
+					}
+					continue;
+				}
 				if (inlined_const_names.has(decl.name)) continue;
 				if (is_literal_init(decl.value)) continue;
 				module_init_statements.push(child);
@@ -21490,69 +21778,6 @@ function call_in_set(set, call) {
 	return set.has(call.name.replace(/#/g, ""));
 }
 //#endregion
-//#region ../src/build_common/call_init_string_fields.ts
-/**
-* Whether a declaration-initializer expression is a value the callee's
-* return-boundary normalization made UNIFORMLY heap-owned, so the fresh
-* binding records every string field and frees them at scope exit:
-*
-*   - a plain function call registered as a normalized struct returner
-*     (the registry is populated at the callee's return sites — a callee
-*     built later, or one that returns slot borrows, is not registered and
-*     the binding keeps the pre-existing borrow behavior);
-*   - an owned accessor (`pop`/`move_T`/`copy`) — move-out semantics
-*     transfer slot-owned heap buffers to the binding.
-*
-* NOT normalized (never recorded): struct constructions (`Info(...)` — its
-* `#init` leaves rodata borrows and bypasses the return path) and container
-* BORROW accessors (`.at`/`.first`/`.slice`/`load` — the slot keeps
-* ownership; recording would free the container's storage).
-*/
-function is_normalized_struct_call(value, status) {
-	if (!value) return false;
-	if (value.node_type === "func_call") {
-		const call = value;
-		return !!status.normalized_struct_returners?.has(call.name);
-	}
-	if (value.node_type === "access") {
-		const access = value.access;
-		if (access?.node_type !== "access_func") return false;
-		const name = access.name ?? "";
-		if (is_container_borrow_accessor_name(name)) return false;
-		if (status.normalized_struct_returners?.has(name)) return true;
-		const target = value.target;
-		const receiver_type = target ? target.type ?? void 0 : void 0;
-		if (receiver_type?.name) {
-			const label = `${mono_type_name(receiver_type)}_${name}`;
-			if (status.normalized_struct_returners?.has(label)) return true;
-		}
-		return false;
-	}
-	return false;
-}
-/**
-* Record every direct string field of a call-initialized value-struct
-* binding (`var Info i = make()`) as heap-owned: the callee's return
-* normalization guarantees each field is a heap buffer, so scope-exit
-* auto_free must free them, and a later `i.field = …` write sees
-* old_was_heap and reclaims the displaced buffer instead of leaking it.
-* No-op for non-struct, class, view, and array types, for structs without
-* direct string fields, and for non-call initializers.
-*/
-function record_call_init_string_fields(node, status) {
-	if (!is_normalized_struct_call(node.value, status)) return;
-	const type = node.type;
-	if (!type?.name) return;
-	const mono_name = mono_type_name(type);
-	if (mono_name.startsWith("_Tuple_")) return;
-	const struct = status.structs.find((s) => s.name === mono_name && !s.is_simple_type);
-	if (!struct || struct.is_class) return;
-	const fields = direct_string_fields(struct);
-	if (!fields.length) return;
-	if (!status.heap_string_fields) status.heap_string_fields = /* @__PURE__ */ new Set();
-	for (const field of fields) status.heap_string_fields.add(`${node.name}.${field.name}`);
-}
-//#endregion
 //#region ../src/build_common/fold_string_const.ts
 /**
 * Fold a top-level `const`'s string `+` chain into a single string literal.
@@ -21614,6 +21839,24 @@ function literal(raw, start) {
 	return new ValueNode(start, raw, new Type("string", true));
 }
 //#endregion
+//#region ../src/build_common/mark_tuple_literal_move_owners.ts
+/**
+* A tuple-literal constructor call (`[move t, move c]` lowered to
+* `_Tuple_.._init(&t, &c)`) copies its fields BY POINTER, and a `move`
+* element transfers ownership: the source local's scope-exit cleanup must
+* be suppressed (the tuple's own field cleanup now owns and frees the
+* buffer). Registers every bare `move <local>` argument into the build's
+* moved set — the same suppression the move-assignment path uses. Called
+* from every constructor-call build site (declarations, assignments, and
+* the generic call builder), since monomorphized tuple inits route through
+* each of them.
+*/
+function mark_tuple_literal_move_owners(node, status) {
+	if (!node.type?.name?.startsWith("_Tuple_")) return;
+	if (!status.moved) status.moved = /* @__PURE__ */ new Set();
+	for (const p of node.params) if (p.node_type === "value" && p.is_moved && typeof p.value === "string") status.moved.add(p.value);
+}
+//#endregion
 //#region ../src/build_common/string_escapes.ts
 /**
 * Source string-literal escape handling shared by both backends.
@@ -21743,6 +21986,37 @@ function escape_asciz(value) {
 	return quote + reencoded.slice(1, reencoded.endsWith(quote) ? -1 : void 0).replace(/\n/g, "\\n") + (reencoded.endsWith(quote) ? quote : "");
 }
 //#endregion
+//#region ../src/build_common/tuple_return_owned_element.ts
+/**
+* Whether a RETURN-position tuple-literal STRING element already owns a heap
+* buffer of its own, so the return boundary can leave it raw (normalization
+* skips it). Two shapes qualify:
+*
+*  - a bare local that was TRANSFERRED into the tuple (`move`, or the
+*    last-use inference) whose buffer is genuinely heap — the callee's
+*    cleanup skips it, so the field owns the original allocation. A
+*    transferred RODATA local (a string literal on aarch64) does NOT
+*    qualify: the field would alias static storage and the caller's
+*    ownership of it would free static memory.
+*  - a fresh expression result that is not a borrow (a call, interpolation,
+*    concat) — it owns its heap already.
+*
+* Everything else (string literals, non-transferred locals, parameters,
+* borrow accessors such as `.at(0)`) must be strdup'd at the return so the
+* caller can uniformly own every string field of the returned tuple (see the
+* caller-side binding ownership).
+*/
+function tuple_return_owned_element(element, heap_strings) {
+	if (element.node_type === "value") {
+		const v = element.value ?? "";
+		if (typeof v !== "string") return false;
+		if (v.startsWith("\"")) return false;
+		if (!/^[A-Za-z_]/.test(v) || v === "null") return false;
+		return !!element.is_moved && !!heap_strings?.has(v);
+	}
+	return !is_string_borrow(element);
+}
+//#endregion
 //#region ../src/build_aarch64/build_range_node.ts
 function build_range_node$1(node, status) {
 	const start = evaluate_constant$1(node.left_value);
@@ -22138,6 +22412,7 @@ function emit_struct_constructor_to_slot(fc, slot_addr, status) {
 * so register slots start at x1 — overflow begins at the 8th arg (slot 8).
 */
 function build_constructor_params(fc, param_regs, status) {
+	mark_tuple_literal_move_owners(fc, status);
 	const variadic_idx = fc.variadic_param_index;
 	if (variadic_idx !== void 0 && fc.params[variadic_idx] && fc.params[variadic_idx].node_type === "array") {
 		const arr = fc.params[variadic_idx];
@@ -22537,6 +22812,43 @@ function build_declaration_node$1(node, status, nir_init, nir_swap) {
 		if (!status.function_local_types) status.function_local_types = /* @__PURE__ */ new Map();
 		status.function_local_types.set(node.name, node.type.name);
 	}
+	if (node.declaration === "var" && node.type.name?.startsWith("_Tuple_") && !node.name.startsWith("_tuple_dst_") && node.value?.node_type === "func_call") {
+		const tuple_call = node.value;
+		const tuple_struct = status.structs.find((st) => st.name === node.type.name && !st.is_simple_type);
+		const init_is_tuple_call = !String(tuple_call.name ?? "").startsWith("_Tuple_") && !!tuple_call.type?.name?.startsWith("_Tuple_");
+		const init_is_tuple_literal = String(tuple_call.name ?? "").startsWith("_Tuple_");
+		if (tuple_struct && (init_is_tuple_call || init_is_tuple_literal)) {
+			const offsets = [];
+			for (const field of direct_string_fields(tuple_struct)) {
+				if (init_is_tuple_literal) {
+					const idx = parseInt(field.name.replace(/^_/, ""), 10);
+					const element = tuple_call.params[idx];
+					if (!element || !tuple_return_owned_element(element, status.heap_strings)) continue;
+				}
+				offsets.push(get_field_offset(tuple_struct.name, field.name, status));
+			}
+			if (offsets.length) {
+				if (!status.heap_string_tuple_fields) status.heap_string_tuple_fields = /* @__PURE__ */ new Map();
+				status.heap_string_tuple_fields.set(node.name, offsets);
+			}
+		}
+	}
+	if (node.declaration === "var" && node.type.name === "string" && !node.type.is_array) {
+		const binding_value = node.value;
+		if (binding_value?.node_type === "access" && binding_value.access.node_type === "access_field" && binding_value.target.node_type === "value" && String(binding_value.target.value ?? "").startsWith("_tuple_dst_")) {
+			const temp_name = String(binding_value.target.value);
+			const temp_init = status.scoped_declarations.findLast((d) => d.name === temp_name)?.value;
+			const m = /^_(\d+)$/.exec(String(binding_value.access.name ?? ""));
+			if (temp_init?.node_type === "func_call" && !String(temp_init.name ?? "").startsWith("_Tuple_") && !!temp_init.type?.name?.startsWith("_Tuple_")) {
+				mark_heap_string(status, node.name);
+				binding_value.is_moved = true;
+			} else if (temp_init?.type?.name?.startsWith("_Tuple_") && m) {
+				const param = temp_init.params[parseInt(m[1], 10)];
+				const src_name = param?.node_type === "value" ? String(param.value) : "";
+				if (param?.node_type === "value" && param.is_moved && !!src_name && !!status.heap_strings?.has(src_name)) mark_heap_string(status, node.name);
+			}
+		}
+	}
 	hoist_field_overrides(node.value, build_node, status, "", node.name);
 	status.last_result_is_heap = false;
 	const prev_heap = status.last_result_is_heap;
@@ -23002,13 +23314,33 @@ function build_declaration_node$1(node, status, nir_init, nir_swap) {
 			} else if (status.function_return_label) {
 				const labels = emit_string_array_labels(array_values.values, status);
 				if (needs_runtime_array_init(array_values.values, status)) {
-					const offset = alloc_array_with_prefix(status, array_values.values.length, element_size);
-					status.stack_offsets.set(node.name, offset);
-					array_values.values.forEach((value, i) => {
-						const slot_offset = offset + i * element_size;
-						const resolved = resolve_static_value(value, status);
-						if (resolved !== null) emit_string_array_element(status, resolved, labels, "x29", slot_offset);
-					});
+					if (node.global_runtime_init) {
+						emit_data(status, `.data\n`);
+						emit_data(status, `.quad ${array_values.values.length}\n`);
+						emit_data(status, `${node.name}:\n`);
+						emit_data(status, `.space ${array_values.values.length * 16}\n`);
+						emit_data(status, `.p2align 2\n`);
+						emit_data(status, `.text\n`);
+						emit_asm(status, `adrp x0, ${node.name}@PAGE\n`);
+						emit_asm(status, `add x0, x0, ${node.name}@PAGEOFF\n`);
+						array_values.values.forEach((value, i) => {
+							const resolved = resolve_static_value(value, status);
+							if (resolved !== null && resolved.startsWith("\"")) {
+								emit_asm(status, `adr x1, ${resolve_array_element(resolved, labels)}\n`);
+								emit_asm(status, `str x1, [x0, #${i * 16}]\n`);
+								emit_asm(status, `mov x1, #${string_literal_length(resolved)}\n`);
+								emit_asm(status, `str x1, [x0, #${i * 16 + 8}]\n`);
+							}
+						});
+					} else {
+						const offset = alloc_array_with_prefix(status, array_values.values.length, element_size);
+						status.stack_offsets.set(node.name, offset);
+						array_values.values.forEach((value, i) => {
+							const slot_offset = offset + i * element_size;
+							const resolved = resolve_static_value(value, status);
+							if (resolved !== null) emit_string_array_element(status, resolved, labels, "x29", slot_offset);
+						});
+					}
 				} else {
 					emit_data(status, `${node.name}: ${directive} `);
 					let first = true;
@@ -23024,19 +23356,16 @@ function build_declaration_node$1(node, status, nir_init, nir_swap) {
 					emit_data(status, `\n.p2align 2\n`);
 				}
 			} else if (node.type.name === "string" && node.type.is_array) {
-				const labels = emit_string_array_labels(array_values.values, status);
-				emit_asm(status, `${node.name}: ${directive} `);
-				array_values.values.forEach((value, i) => {
-					if (i > 0) emit_data(status, ", ");
+				emit_data(status, `.quad ${array_values.values.length}\n`);
+				emit_data(status, `${node.name}: .space ${array_values.values.length * 16}\n\t.p2align 2\n`);
+			} else {
+				emit_data(status, `.quad ${array_values.values.length}\n`);
+				emit_data(status, `${node.name}:\n`);
+				array_values.values.forEach((value) => {
 					const resolved = resolve_static_value(value, status);
-					if (resolved !== null && resolved.startsWith("\"")) emit_asm(status, `.quad ${resolve_array_element(resolved, labels)}\n\t.quad ${string_literal_length(resolved)}`);
-					else emit_asm(status, ".quad 0\n	.quad 0");
+					emit_data(status, `\t${directive} ${resolved !== null ? resolved : "0"}\n`);
 				});
-				emit_asm(status, `\n.p2align 2\n`);
-			} else {
-				emit_asm(status, `${node.name}: ${directive} `);
-				build_array_values_node$1(array_values, status);
-				emit_asm(status, `\n.p2align 2\n`);
+				emit_data(status, `\t.p2align 2\n`);
 			}
 		} else if (node.value && node.value.node_type === "range") {
 			if (status.function_return_label) {
@@ -24925,7 +25254,7 @@ function build_return_node$1(node, status, nir_value) {
 		const finalized = status.moved ?? /* @__PURE__ */ new Set();
 		for (const decl of all_scope_frames(status).flat()) {
 			if (finalized.has(decl.name)) {
-				release_heap_string_fields(status, decl.name, decl.type.name);
+				release_heap_string_fields(status, decl.name, decl.type.name, decl.type.is_nullable);
 				continue;
 			}
 			if (is_field_struct_borrow(decl)) continue;
@@ -24945,7 +25274,7 @@ function build_return_node$1(node, status, nir_value) {
 			const finalized = status.moved ?? /* @__PURE__ */ new Set();
 			for (const decl of all_scope_frames(status).flat()) {
 				if (finalized.has(decl.name)) {
-					release_heap_string_fields(status, decl.name, decl.type.name);
+					release_heap_string_fields(status, decl.name, decl.type.name, decl.type.is_nullable);
 					continue;
 				}
 				if (is_field_struct_borrow(decl)) continue;
@@ -25033,7 +25362,10 @@ function build_return_node$1(node, status, nir_value) {
 			if (anon.base.is_moved) mark_moved_if_struct(anon.base, status);
 			emit_field_overrides(temp_name, anon, build_node, status);
 			emit_var_address(status, "x0", temp_name);
-		} else emit_return_value$1(node.value, nir_value, status);
+		} else {
+			status.last_result_is_heap = false;
+			emit_return_value$1(node.value, nir_value, status);
+		}
 		if (ret_is_float) {
 			ensure_newline(status);
 			if (status.float_result_in_d0) emit_asm(status, `fmov d0, x0\n`);
@@ -25045,7 +25377,7 @@ function build_return_node$1(node, status, nir_value) {
 	if (current_return_is_string(status) && node.value.node_type === "value" && node.value.value.length >= 2 && node.value.value.startsWith("\"") && node.value.value.endsWith("\"")) {
 		const fn_name = status.current_function_name;
 		const mangled = status.current_struct ? `${status.current_struct.name}_${fn_name}` : fn_name;
-		if (fn_name && (!!status.heap_returning_functions && (status.heap_returning_functions.has(fn_name) || mangled !== void 0 && status.heap_returning_functions.has(mangled)) || current_function_returns_move_string(status))) {
+		if (fn_name && (status.current_function_is_closure || !!status.heap_returning_functions && (status.heap_returning_functions.has(fn_name) || mangled !== void 0 && status.heap_returning_functions.has(mangled)) || current_function_returns_move_string(status))) {
 			emit_strdup_string(status);
 			ensure_newline(status);
 			status.last_result_is_heap = true;
@@ -25053,7 +25385,7 @@ function build_return_node$1(node, status, nir_value) {
 	}
 	const borrow_fn_name = status.current_function_name;
 	const borrow_mangled = status.current_struct && borrow_fn_name ? `${status.current_struct.name}_${borrow_fn_name}` : void 0;
-	const normalizes_borrow_returns = !!borrow_fn_name && !is_call_site_borrow_accessor(borrow_fn_name) && current_return_is_string(status) && (!!status.heap_returning_functions && (status.heap_returning_functions.has(borrow_fn_name) || borrow_mangled !== void 0 && status.heap_returning_functions.has(borrow_mangled)) || current_function_returns_move_string(status));
+	const normalizes_borrow_returns = !!borrow_fn_name && !is_call_site_borrow_accessor(borrow_fn_name) && current_return_is_string(status) && (!!status.current_function_is_closure || !!status.heap_returning_functions && (status.heap_returning_functions.has(borrow_fn_name) || borrow_mangled !== void 0 && status.heap_returning_functions.has(borrow_mangled)) || current_function_returns_move_string(status));
 	let needs_borrow_strdup = false;
 	if (normalizes_borrow_returns) {
 		if (node.value.node_type === "value") {
@@ -25063,6 +25395,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 === "match" || node.value.node_type === "switch") && !return_join_owned_string) needs_borrow_strdup = true;
 	}
 	if (needs_borrow_strdup) {
@@ -25118,6 +25451,16 @@ 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" && String(node.value.name ?? "").startsWith("_Tuple_") && node.value.type?.name?.startsWith("_Tuple_")) {
+					const tuple_call = node.value;
+					const skip_fields = /* @__PURE__ */ new Set();
+					for (const field of direct_string_fields(ret_struct)) {
+						const idx = parseInt(field.name.replace(/^_/, ""), 10);
+						const element = tuple_call.params[idx];
+						if (element && tuple_return_owned_element(element, status.heap_strings)) skip_fields.add(field.name);
+					}
+					emit_string_field_strdups_at(status, ret_struct.name, "x8", 0, skip_fields);
+				}
 			}
 		}
 	}
@@ -25186,7 +25529,7 @@ function build_return_node$1(node, status, nir_value) {
 		emit_nursery_joins_on_return_a64(status);
 		for (const decl of all_scope_frames(status).flat()) {
 			if (finalized.has(decl.name)) {
-				release_heap_string_fields(status, decl.name, decl.type.name);
+				release_heap_string_fields(status, decl.name, decl.type.name, decl.type.is_nullable);
 				continue;
 			}
 			if (is_field_struct_borrow(decl)) continue;
@@ -28423,6 +28766,7 @@ function build_function_call_node$1(node, status) {
 		}
 	}
 	const is_struct = status.structs.find((s) => s.name === node.name && !s.is_simple_type);
+	mark_tuple_literal_move_owners(node, status);
 	const func_name = is_struct ? node.mangled_name ?? `${node.name}_init` : emission_label(node.resolved_function ?? node);
 	const param_regs = [
 		"x0",
@@ -28462,8 +28806,25 @@ function build_function_call_node$1(node, status) {
 		const env_off = status.closure_env_offsets?.get(node.name);
 		const paramReg = func_offset === void 0 ? status.function_param_regs?.get(node.name) : void 0;
 		const desc_source = env_off !== void 0 ? `ldr x9, [x29, #${status.closure_env_slot}]\nldr x9, [x9, #${env_off}]\n` : func_offset !== void 0 ? `ldr x9, [x29, #${func_offset}]\n` : paramReg ? `mov x9, ${paramReg}\n` : `adr x9, ${node.name}\n`;
+		const param_slots = [];
+		let total_visible_slots = 0;
+		for (const p of node.params) {
+			param_slots.push(total_visible_slots);
+			total_visible_slots += type_from_value_node$1(p)?.name === "string" ? 2 : 1;
+		}
+		const reg_capacity = 8 - (start_reg + 1);
+		const overflow_count = Math.max(0, total_visible_slots - reg_capacity);
+		let outgoing_size = 0;
+		let spill_base = 0;
+		if (overflow_count > 0) spill_base = allocate_stack_space(status, overflow_count * 8, 8);
 		const lambda_arg_slots = [];
-		let arg_slot = start_reg + 1;
+		const store_arg_half = (value_reg, slot) => {
+			if (slot < 8) {
+				const reg = param_regs[slot];
+				if (reg === value_reg) emit_asm(status, `\n`);
+				else emit_asm(status, `\nmov ${reg}, ${value_reg}\n`);
+			} else emit_asm(status, `\nstr ${value_reg}, [x29, #${spill_base + (slot - 8) * 8}]\n`);
+		};
 		for (let i = node.params.length - 1; i >= 0; i--) {
 			const param = node.params[i];
 			const is_pair = type_from_value_node$1(param)?.name === "string";
@@ -28473,19 +28834,25 @@ function build_function_call_node$1(node, status) {
 				emit_asm(status, `str x0, [x29, #${dispose_slot}]\n`);
 				lambda_arg_slots.push(dispose_slot);
 			}
-			const reg = param_regs[arg_slot];
-			const len_reg = param_regs[arg_slot + 1];
-			if (is_pair && len_reg !== "x1") emit_asm(status, `\nmov ${len_reg}, x1\n`);
-			if (reg !== "x0") emit_asm(status, `\nmov ${reg}, x0\n`);
-			else emit_asm(status, `\n`);
-			if (is_pair) arg_slot += 2;
-			else arg_slot += 1;
+			const arg_slot = start_reg + 1 + param_slots[i];
+			if (is_pair) store_arg_half("x1", arg_slot + 1);
+			store_arg_half("x0", arg_slot);
+		}
+		if (overflow_count > 0) {
+			outgoing_size = Math.ceil(overflow_count * 8 / 16) * 16;
+			emit_asm(status, `sub sp, sp, #${outgoing_size}\n`);
+			for (let k = 0; k < overflow_count; k++) {
+				emit_asm(status, `ldr x9, [x29, #${spill_base + k * 8}]\n`);
+				emit_asm(status, `str x9, [sp, #${k * 8}]\n`);
+			}
 		}
 		emit_asm(status, desc_source);
 		emit_asm(status, `ldr x8, [x9]\n`);
 		emit_asm(status, `ldr x0, [x9, #8]\n`);
 		emit_asm(status, `blr x8\n`);
 		emit_dispose_lambda_args_a64(status, lambda_arg_slots);
+		if (outgoing_size > 0) emit_asm(status, `add sp, sp, #${outgoing_size}\n`);
+		if (node.type?.name === "string" && !node.type.is_view) status.last_result_is_heap = true;
 	} else {
 		const variadic_idx = node.variadic_param_index;
 		const ref_class_sync_names = [];
@@ -31214,6 +31581,20 @@ function emit_enum_payload_reclaim(cname, enum_node, c, p, status) {
 	if (payload_is_reference$2(p.type, status)) status.code += `${guard} { ${p.type.name}_destroy(${cname}._data._${c.name}.${p.name}); free(${cname}._data._${c.name}.${p.name}); }\n`;
 	else if (p.type.name === "string") status.code += `${guard} { free(${cname}._data._${c.name}.${p.name}.ptr); }\n`;
 }
+/**
+* Drop the `name.field` heap-string records belonging to `decls` WITHOUT
+* emitting any free code. Used when the emitted reclaim would be unreachable
+* (a function body that cannot fall through — see build_function_node): the
+* return-site reclaim already emitted the frees, so the records must be
+* cleared for the next function build but must not produce a second block.
+*/
+function discard_string_field_records(status, decls) {
+	if (!status.heap_string_fields?.size) return;
+	for (const dec of decls) {
+		const prefix = `${dec.name}.`;
+		for (const key of Array.from(status.heap_string_fields)) if (key.startsWith(prefix)) status.heap_string_fields.delete(key);
+	}
+}
 function build_auto_free(status) {
 	free_scoped_declarations(status, status.scoped_declarations);
 	if (status.deferred_frees?.length) {
@@ -31235,11 +31616,15 @@ function free_scoped_declarations(status, decls, persist_string_field_records =
 	let commented = false;
 	if (status.heap_string_fields?.size) for (const dec of decls) {
 		const prefix = `${dec.name}.`;
-		for (const key of Array.from(status.heap_string_fields)) if (key.startsWith(prefix)) {
-			if (!commented) {
-				status.code += "\n// Auto-free\n";
-				commented = true;
-			}
+		const keys = Array.from(status.heap_string_fields).filter((key) => key.startsWith(prefix));
+		if (!keys.length) continue;
+		if (!commented) {
+			status.code += "\n// Auto-free\n";
+			commented = true;
+		}
+		const nullable_flag = is_nullable_struct_type(dec.type, status) ? has_flag_name(c_function_name(dec.name)) : void 0;
+		if (nullable_flag) status.code += `if (${nullable_flag}) { `;
+		for (const key of keys) {
 			const dot = key.indexOf(".");
 			const base = c_function_name(key.substring(0, dot));
 			const arrow = dec.string_fields_via_pointer ? "->" : ".";
@@ -31248,6 +31633,7 @@ function free_scoped_declarations(status, decls, persist_string_field_records =
 			status.code += `${free_fn}(${base}${arrow}${field}.ptr);\n`;
 			if (!persist_string_field_records) status.heap_string_fields.delete(key);
 		}
+		if (nullable_flag) status.code += `}\n`;
 	}
 	for (const dec of decls) {
 		if (dec.owned_heap_shell) {
@@ -31765,6 +32151,49 @@ function emit_rhs_value$1(rhs, nir, status) {
 }
 function build_assignment_node$1(node, status, nir_rhs, nir_swap) {
 	hoist_field_overrides(node.right_value, build_node$1, status, ";\n", node.left_value.node_type === "value" ? node.left_value.value : void 0);
+	const lhs_nullable_type = lhs_nullable_struct_type(node, status);
+	if (!node.operator && lhs_nullable_type) {
+		const lhs_expr = capture_build(node.left_value, status);
+		const flag = `${lhs_expr}_has`;
+		const rhs_is_null = node.right_value.node_type === "value" && node.right_value.value === "null";
+		const lhs_is_local = node.left_value.node_type === "value";
+		const lhs_name = lhs_is_local ? node.left_value.value : "";
+		const rhs_is_same_var = lhs_is_local && node.right_value.node_type === "value" && node.right_value.value === lhs_name;
+		const type_name = (lhs_is_local ? status.scoped_declarations.find((d) => d.name === lhs_name) : void 0)?.type?.name || "";
+		if (lhs_is_local && !rhs_is_same_var && type_name) {
+			const prefix = `${lhs_name}.`;
+			const recorded = status.heap_string_fields ? Array.from(status.heap_string_fields).filter((k) => k.startsWith(prefix)) : [];
+			if (recorded.length > 0) {
+				const free_fn = status.audit ? "nomen_free_wrap" : "free";
+				const frees = recorded.map((k) => {
+					const dot = k.indexOf(".");
+					return `${free_fn}(${lhs_expr}.${k.slice(dot + 1)}.ptr)`;
+				});
+				status.code += `if (${flag}) { ${frees.join("; ")}; }\n`;
+				for (const k of recorded) status.heap_string_fields.delete(k);
+			}
+			if (!rhs_is_null && is_normalized_struct_call(node.right_value, status)) {
+				const struct = status.structs.find((s) => s.name === type_name && !s.is_simple_type && !s.is_class);
+				if (struct) {
+					if (!status.heap_string_fields) status.heap_string_fields = /* @__PURE__ */ new Set();
+					for (const field of direct_string_fields(struct)) status.heap_string_fields.add(`${lhs_name}.${field.name}`);
+				}
+			}
+		}
+		if (rhs_is_null) status.code += `${flag} = 0`;
+		else if (node.right_value.node_type === "func_call" && is_nullable_struct_type(node.right_value.type, status)) {
+			const old = status.current_nullable_call_flag;
+			status.current_nullable_call_flag = flag;
+			status.code += `${lhs_expr} = `;
+			emit_rhs_value$1(node.right_value, nir_rhs, status);
+			status.current_nullable_call_flag = old;
+		} else {
+			status.code += `${lhs_expr} = `;
+			emit_rhs_value$1(node.right_value, nir_rhs, status);
+			status.code += `;\n${flag} = 1`;
+		}
+		return;
+	}
 	if (node.left_value.node_type === "access") {
 		const accessNode = node.left_value;
 		if (accessNode.target.node_type === "value") {
@@ -32139,18 +32568,6 @@ function build_assignment_node$1(node, status, nir_rhs, nir_swap) {
 		}
 	}
 	status.code += ``;
-	const lhs_nullable_type = lhs_nullable_struct_type(node, status);
-	if (!node.operator && lhs_nullable_type) {
-		const lhs_expr = capture_build(node.left_value, status);
-		const flag = `${lhs_expr}_has`;
-		if (node.right_value.node_type === "value" && node.right_value.value === "null") status.code += `${flag} = 0`;
-		else {
-			status.code += `${lhs_expr} = `;
-			emit_rhs_value$1(node.right_value, nir_rhs, status);
-			status.code += `;\n${flag} = 1`;
-		}
-		return;
-	}
 	if (!node.operator && !node.swap && node.left_value.node_type === "value") {
 		const lhs_name = node.left_value.value;
 		const lhs_type = type_from_value_node$1(node.left_value);
@@ -32460,6 +32877,101 @@ function emit_nursery_joins_on_return_c(status) {
 	for (let i = status.nursery_stack.length - 1; i >= base; i--) emit_nursery_join_c(status, status.nursery_stack[i], true);
 }
 //#endregion
+//#region ../src/build_common/decode_char_literal.ts
+/**
+* Decode a Nomen char literal token (raw value INCLUDING its surrounding
+* quotes, as carried by ValueNode) to its numeric code. The tokenizer
+* consumes escape pairs as a unit, so multi-char forms like `'\\\\'`,
+* `'\\n'`, `'\\''` and `'\\xNN'` arrive raw and must be decoded here.
+* Returns undefined for malformed literals.
+*/
+function decode_char_literal(raw) {
+	if (raw.length < 3 || raw[0] !== "'" || raw[raw.length - 1] !== "'") return;
+	const inner = raw.slice(1, -1);
+	if (inner.length === 1) return inner.charCodeAt(0);
+	if (inner[0] !== "\\") return;
+	const esc = inner[1];
+	switch (esc) {
+		case "\\": return 92;
+		case "n": return 10;
+		case "t": return 9;
+		case "r": return 13;
+		case "'": return 39;
+		case "\"": return 34;
+		case "0": return 0;
+		case "x": {
+			const hex = inner.slice(2);
+			if (!/^[0-9a-fA-F]+$/.test(hex)) return void 0;
+			return parseInt(hex, 16);
+		}
+		default: return esc.charCodeAt(0);
+	}
+}
+//#endregion
+//#region ../src/build_c/utils/c_char_literal.ts
+function c_char_literal(value) {
+	const code = decode_char_literal(value);
+	if (code === void 0) return value;
+	if (code === 92) return `'\\\\'`;
+	if (code === 39) return `'\\''`;
+	if (code === 10) return `'\\n'`;
+	if (code === 13) return `'\\r'`;
+	if (code === 9) return `'\\t'`;
+	if (code < 32 || code > 126) return `'\\x${code.toString(16)}'`;
+	return `'${String.fromCharCode(code)}'`;
+}
+//#endregion
+//#region ../src/build_c/build_value_node.ts
+const INT_LITERAL_SUFFIX = {
+	int: "L",
+	uint: "UL",
+	int64: "LL",
+	uint64: "ULL"
+};
+function build_value_node$1(node, status) {
+	let value = node.value;
+	if (status.closure_env?.has(value)) {
+		if (!(!!status.current_function?.params.some((p) => p.name === value) || !!find_decl_in_c_scopes(status, value))) {
+			status.code += status.closure_env.get(value);
+			return;
+		}
+	}
+	const inlined = status.top_level_consts?.get(value);
+	if (inlined?.value) {
+		build_node$1(fold_string_const(inlined, status.top_level_consts) ?? inlined.value, status);
+		return;
+	}
+	if (node.is_enum_shorthand) {
+		const enum_node = status.enums.find((e) => value.startsWith(e.name + "_"));
+		if (enum_node) {
+			if (enum_node.has_associated_data) status.code += `${value}_init()`;
+			else status.code += value;
+			return;
+		}
+	}
+	if (value === "null") value = "0";
+	else if (value === "true") value = "1";
+	else if (value === "false") value = "0";
+	else if (value === "default") value = "_nomen_default";
+	else if (is_int_literal(value)) value = value.replace(/_/g, "") + (INT_LITERAL_SUFFIX[node.type?.name ?? "int"] ?? "");
+	else if (node.resolved_function) {
+		status.code += materialize_func_value(node.resolved_function, status);
+		return;
+	} else if (value.startsWith("'") && value.endsWith("'")) value = c_char_literal(value);
+	else value = c_function_name(value);
+	if (value.startsWith("\"")) value = `nomen_str_lit(${escape_c_string(value)}, ${string_literal_length(value)})`;
+	if (value !== "self" && status.function_ref_params?.has(value) && !status.suppress_dereference) status.code += `*`;
+	if (value === "self" && status.function_ref_params?.has("self") && !status.suppress_dereference) status.code += `*`;
+	if (value !== "self" && status.ref_class_params?.has(value) && !status.suppress_dereference) {
+		status.code += `(*${value})`;
+		return;
+	}
+	status.code += value;
+}
+function escape_c_string(s) {
+	return reencode_hex_escapes(s.replace(/\n/g, "\\n").replace(/\r/g, "\\r").replace(/\t/g, "\\t"));
+}
+//#endregion
 //#region ../src/build_c/build_array_values_node.ts
 /**
 * Build an array literal's `{a, b, c}` initializer text. Under NIR-driven
@@ -32471,11 +32983,13 @@ function emit_nursery_joins_on_return_c(status) {
 function build_array_values_node(node, status, nir_elements) {
 	status.code += `{`;
 	const elem_is_string = node.type?.name === "string";
+	const static_init = status.static_string_array_inits === true;
 	node.values.forEach((value, i) => {
 		if (i > 0) status.code += ", ";
 		const is_string_literal = elem_is_string && value.node_type === "value" && value.value.length >= 2 && value.value.startsWith("\"") && value.value.endsWith("\"");
 		const nir_elem = nir_elements?.[i];
-		if (is_string_literal) {
+		if (is_string_literal && static_init) status.code += `{ ${escape_c_string(value.value)}, ${string_literal_length(value.value)} }`;
+		else if (is_string_literal) {
 			status.code += `nomen_str_dup(`;
 			if (nir_elem && nir_elem.node === value) emit_expr_from_nir(nir_elem, status);
 			else build_node$1(value, status);
@@ -32618,6 +33132,42 @@ function build_declaration_node(node, status, nir_init, nir_swap) {
 		status.code += `] = {${variables.map((v) => `&${v}`).join(", ")}}`;
 	} else {
 		const safe_name = c_function_name(node.name);
+		if (node.type.name?.startsWith("_Tuple_") && !node.name.startsWith("_tuple_dst_") && node.value?.node_type === "func_call") {
+			const tuple_call = node.value;
+			const tuple_struct = status.structs.find((st) => st.name === node.type.name && !st.is_simple_type);
+			const init_is_tuple_call = !String(tuple_call.name ?? "").startsWith("_Tuple_") && !!tuple_call.type?.name?.startsWith("_Tuple_");
+			const init_is_tuple_literal = String(tuple_call.name ?? "").startsWith("_Tuple_");
+			if (tuple_struct && init_is_tuple_call) for (const field of direct_string_fields(tuple_struct)) {
+				if (!status.heap_string_fields) status.heap_string_fields = /* @__PURE__ */ new Set();
+				status.heap_string_fields.add(`${node.name}.${field.name}`);
+			}
+			else if (tuple_struct && init_is_tuple_literal) for (const field of direct_string_fields(tuple_struct)) {
+				const idx = parseInt(field.name.replace(/^_/, ""), 10);
+				const element = tuple_call.params[idx];
+				if (element && tuple_return_owned_element(element, status.heap_strings)) {
+					if (!status.heap_string_fields) status.heap_string_fields = /* @__PURE__ */ new Set();
+					status.heap_string_fields.add(`${node.name}.${field.name}`);
+				}
+			}
+		}
+		if (node.declaration === "var" && node.type.name === "string" && !node.type.is_array && node.value?.node_type === "access" && node.value.access.node_type === "access_field" && node.value.target.node_type === "value" && String(node.value.target.value ?? "").startsWith("_tuple_dst_")) {
+			const tuple_binding_value = node.value;
+			const temp_name = String(tuple_binding_value.target.value);
+			const temp_init = status.scoped_declarations.findLast((d) => d.name === temp_name)?.value;
+			const m = /^_(\d+)$/.exec(String(tuple_binding_value.access.name ?? ""));
+			if (temp_init?.node_type === "func_call" && !String(temp_init.name ?? "").startsWith("_Tuple_") && !!temp_init.type?.name?.startsWith("_Tuple_")) {
+				if (!status.heap_strings) status.heap_strings = /* @__PURE__ */ new Set();
+				status.heap_strings.add(safe_name);
+				tuple_binding_value.is_moved = true;
+			} else if (temp_init?.type?.name?.startsWith("_Tuple_") && m) {
+				const param = temp_init.params[parseInt(m[1], 10)];
+				if (param?.node_type === "value" && param.is_moved) {
+					if (!status.heap_strings) status.heap_strings = /* @__PURE__ */ new Set();
+					status.heap_strings.add(safe_name);
+					tuple_binding_value.is_moved = true;
+				}
+			}
+		}
 		const mono_name = mono_type_name(node.type);
 		const mono_struct = status.structs.find((s) => s.name === mono_name && !s.is_simple_type && !s.is_generic);
 		const is_class_type = !!mono_struct?.is_class;
@@ -32821,6 +33371,7 @@ function build_declaration_node(node, status, nir_init, nir_swap) {
 						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 {
 						emit_init_value(node.value, nir_init, status);
 						status.code += `;\n${flag} = 1`;
@@ -32890,6 +33441,7 @@ function build_declaration_node(node, status, nir_init, nir_swap) {
 			} else if (node.value.node_type === "value" && node.value.value === "null" && node.type.name === "string" && !node.type.is_view && !node.type.is_array) status.code += ` = {0, 0}`;
 			else {
 				status.code += " = ";
+				status.static_string_array_inits = is_stack_array && !status.current_function && node.type.name === "string";
 				const val_node = node.value;
 				const val_is_string_literal = node.value.node_type === "value" && val_node.value.length >= 2 && val_node.value.startsWith("\"") && val_node.value.endsWith("\"");
 				const val_is_heap_string_var = node.value.node_type === "value" && !val_is_string_literal && !!status.scoped_declarations.find((d) => d.name === val_node.value);
@@ -32927,6 +33479,7 @@ function build_declaration_node(node, status, nir_init, nir_swap) {
 						emit_init_value(node.value, nir_init, status);
 						status.suppress_dereference = false;
 					} else emit_init_value(node.value, nir_init, status);
+					status.static_string_array_inits = false;
 				}
 			}
 			if (node.swap && node.value.node_type === "access") {
@@ -33586,6 +34139,15 @@ function build_return_node(node, status, nir_value) {
 			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" && String(node.value.name ?? "").startsWith("_Tuple_") && !!node.value.type?.name?.startsWith("_Tuple_")) {
+			const tuple_call = node.value;
+			for (const field of direct_string_fields(return_struct)) {
+				const idx = parseInt(field.name.replace(/^_/, ""), 10);
+				const element = tuple_call.params[idx];
+				if (element && tuple_return_owned_element(element, status.heap_strings)) continue;
+				status.code += `_return_val.${field.name} = nomen_str_dup(_return_val.${field.name});\n`;
+			}
+		}
 		emit_nursery_joins_on_return_c(status);
 		reclaim_all_c_scopes(status);
 		status.code += `return _return_val;\n`;
@@ -35350,6 +35912,22 @@ function emit_closure_env_type(func, status) {
 }
 //#endregion
 //#region ../src/build_c/build_function_node.ts
+/**
+* True when control cannot reach the end of `statements` — the last statement
+* is a `return`, or an `if`/`else` whose every arm itself definitely returns.
+* Used to suppress the fall-through auto-free: when no path falls through, the
+* epilogue reclaim is unreachable text after the last `return`.
+*/
+function statements_definitely_return(statements) {
+	if (!statements?.length) return false;
+	const last = statements[statements.length - 1];
+	if (last.node_type === "return") return true;
+	if (last.node_type === "if") {
+		const branch = last;
+		return !!branch.if_branch && !!branch.else_branch && statements_definitely_return(branch.if_branch.statements) && statements_definitely_return(branch.else_branch.statements);
+	}
+	return false;
+}
 function build_function_node(node, status) {
 	if (node.is_generic) return;
 	if (node.is_extern) {
@@ -35571,7 +36149,8 @@ function build_function_node(node, status) {
 	status.current_function_name = old_function_name;
 	status.current_function = old_current_function;
 	status.closure_env = old_closure_env;
-	build_auto_free(status);
+	if (statements_definitely_return(node.statements)) discard_string_field_records(status, status.scoped_declarations);
+	else build_auto_free(status);
 	if (node.name.toLocaleLowerCase() === "main" && status.used_fibers) {
 		status.code += `\n__nomen_fiber_drain_all();\n`;
 		status.code += `__nomen_io_shutdown();\n`;
@@ -36755,6 +37334,7 @@ function build_function_call_node(node, status) {
 	const func_name = is_struct ? node.mangled_name ?? `${node.name}_init` : c_function_name(emission_label(node.resolved_function ?? node));
 	const callee_params = node.resolved_function?.params?.filter((p) => !p.is_self_param);
 	const lambda_arg_temps = /* @__PURE__ */ new Map();
+	mark_tuple_literal_move_owners(node, status);
 	if (!is_struct) for (let i = 0; i < node.params.length; i++) {
 		const p = node.params[i];
 		if (p.node_type !== "func") continue;
@@ -37156,101 +37736,6 @@ function build_todo_node$1(node, status) {
 	status.code += `exit(EXIT_FAILURE);\n`;
 }
 //#endregion
-//#region ../src/build_common/decode_char_literal.ts
-/**
-* Decode a Nomen char literal token (raw value INCLUDING its surrounding
-* quotes, as carried by ValueNode) to its numeric code. The tokenizer
-* consumes escape pairs as a unit, so multi-char forms like `'\\\\'`,
-* `'\\n'`, `'\\''` and `'\\xNN'` arrive raw and must be decoded here.
-* Returns undefined for malformed literals.
-*/
-function decode_char_literal(raw) {
-	if (raw.length < 3 || raw[0] !== "'" || raw[raw.length - 1] !== "'") return;
-	const inner = raw.slice(1, -1);
-	if (inner.length === 1) return inner.charCodeAt(0);
-	if (inner[0] !== "\\") return;
-	const esc = inner[1];
-	switch (esc) {
-		case "\\": return 92;
-		case "n": return 10;
-		case "t": return 9;
-		case "r": return 13;
-		case "'": return 39;
-		case "\"": return 34;
-		case "0": return 0;
-		case "x": {
-			const hex = inner.slice(2);
-			if (!/^[0-9a-fA-F]+$/.test(hex)) return void 0;
-			return parseInt(hex, 16);
-		}
-		default: return esc.charCodeAt(0);
-	}
-}
-//#endregion
-//#region ../src/build_c/utils/c_char_literal.ts
-function c_char_literal(value) {
-	const code = decode_char_literal(value);
-	if (code === void 0) return value;
-	if (code === 92) return `'\\\\'`;
-	if (code === 39) return `'\\''`;
-	if (code === 10) return `'\\n'`;
-	if (code === 13) return `'\\r'`;
-	if (code === 9) return `'\\t'`;
-	if (code < 32 || code > 126) return `'\\x${code.toString(16)}'`;
-	return `'${String.fromCharCode(code)}'`;
-}
-//#endregion
-//#region ../src/build_c/build_value_node.ts
-const INT_LITERAL_SUFFIX = {
-	int: "L",
-	uint: "UL",
-	int64: "LL",
-	uint64: "ULL"
-};
-function build_value_node$1(node, status) {
-	let value = node.value;
-	if (status.closure_env?.has(value)) {
-		if (!(!!status.current_function?.params.some((p) => p.name === value) || !!find_decl_in_c_scopes(status, value))) {
-			status.code += status.closure_env.get(value);
-			return;
-		}
-	}
-	const inlined = status.top_level_consts?.get(value);
-	if (inlined?.value) {
-		build_node$1(fold_string_const(inlined, status.top_level_consts) ?? inlined.value, status);
-		return;
-	}
-	if (node.is_enum_shorthand) {
-		const enum_node = status.enums.find((e) => value.startsWith(e.name + "_"));
-		if (enum_node) {
-			if (enum_node.has_associated_data) status.code += `${value}_init()`;
-			else status.code += value;
-			return;
-		}
-	}
-	if (value === "null") value = "0";
-	else if (value === "true") value = "1";
-	else if (value === "false") value = "0";
-	else if (value === "default") value = "_nomen_default";
-	else if (is_int_literal(value)) value = value.replace(/_/g, "") + (INT_LITERAL_SUFFIX[node.type?.name ?? "int"] ?? "");
-	else if (node.resolved_function) {
-		status.code += materialize_func_value(node.resolved_function, status);
-		return;
-	} else if (value.startsWith("'") && value.endsWith("'")) value = c_char_literal(value);
-	else value = c_function_name(value);
-	if (value.startsWith("\"")) value = `nomen_str_lit(${escape_c_string(value)}, ${string_literal_length(value)})`;
-	if (value !== "self" && status.function_ref_params?.has(value) && !status.suppress_dereference) status.code += `*`;
-	if (value === "self" && status.function_ref_params?.has("self") && !status.suppress_dereference) status.code += `*`;
-	if (value !== "self" && status.ref_class_params?.has(value) && !status.suppress_dereference) {
-		status.code += `(*${value})`;
-		return;
-	}
-	status.code += value;
-}
-function escape_c_string(s) {
-	return reencode_hex_escapes(s.replace(/\n/g, "\\n").replace(/\r/g, "\\r").replace(/\t/g, "\\t"));
-}
-//#endregion
 //#region ../src/build_c/build_node.ts
 function build_node$1(node, status, with_semicolon = false) {
 	if (node.allocations) {
@@ -38740,13 +39225,49 @@ function build_nullable_struct_assignment(node, status, nir_rhs) {
 	if (node.left_value.node_type === "value") {
 		const name = node.left_value.value;
 		const flag_name = has_flag_name(name);
+		const type_name = status.scoped_declarations.find((d) => d.name === name)?.type?.name || status.variable_types?.get(name)?.name || "";
+		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) {
+			if (reclaimable) emit_recorded_field_reclaim_for_slot(status, name, type_name);
 			emit_var_store(status, "xzr", flag_name, 8);
+			drop_heap_string_field_records(status, name);
+			return;
+		}
+		const retarget_records = () => {
+			drop_heap_string_field_records(status, name);
+			if (is_normalized_struct_call(node.right_value, status)) {
+				const struct = status.structs.find((s) => s.name === type_name && !s.is_simple_type && !s.is_class);
+				if (struct) {
+					if (!status.heap_string_fields) status.heap_string_fields = /* @__PURE__ */ new Set();
+					for (const field of direct_string_fields(struct)) status.heap_string_fields.add(`${name}.${field.name}`);
+				}
+			}
+		};
+		if (node.right_value.node_type === "func_call" && is_nullable_struct_type(node.right_value.type, status)) {
+			if (reclaimable) emit_recorded_field_reclaim_for_slot(status, name, type_name);
+			retarget_records();
+			const old_buffer = status.struct_return_buffer;
+			const old_buffer_var = status.struct_return_buffer_var;
+			const old_preset = status.call_x8_preset;
+			emit_var_address(status, "x8", name);
+			status.struct_return_buffer_var = name;
+			status.struct_return_buffer = "x8";
+			status.call_x8_preset = true;
+			emit_rhs_value(node.right_value, nir_rhs, status);
+			status.struct_return_buffer = old_buffer;
+			status.struct_return_buffer_var = old_buffer_var;
+			status.call_x8_preset = old_preset;
 			return;
 		}
 		emit_rhs_value(node.right_value, nir_rhs, status);
 		ensure_newline(status);
-		const struct_size = get_struct_size(status.scoped_declarations.find((d) => d.name === name)?.type?.name || status.variable_types?.get(name)?.name || "", status);
+		if (reclaimable) {
+			emit_asm(status, `str x0, [sp, #-16]!\n`);
+			emit_recorded_field_reclaim_for_slot(status, name, type_name);
+			emit_asm(status, `ldr x0, [sp], #16\n`);
+		}
+		retarget_records();
+		const struct_size = get_struct_size(type_name, status);
 		const dst_offset = status.stack_offsets?.get(name);
 		emit_struct_copy("x0", "x29", dst_offset ?? 0, struct_size, status);
 		emit_asm(status, `mov x9, #1\n`);
@@ -41040,6 +41561,7 @@ function is_owned_heap_temp(node, status) {
 	if (check_type_name !== "string") return false;
 	if (check_node.node_type === "op") return true;
 	if (check_node.node_type === "func_call" || check_node.node_type === "access_func") {
+		if (!check_node.type?.is_view && (check_node.is_func_param || check_node.is_func_field_call)) return true;
 		const raw_name = check_node.name;
 		const mangled = check_node.mangled_name || raw_name;
 		const dbg = process.env.NOMEN_DBG_TEMP && typeof mangled === "string" && mangled.indexOf("replace") >= 0;
@@ -42282,6 +42804,22 @@ function resolve_access_target_type(target, status) {
 * final field is read. Without this, `state.rules.blocks.length` (State/
 * BlockParserState is a class) summed 8+8+8 and loaded from `state + 24`.
 */
+/**
+* True when every hop in the access chain is a FIELD access (no call
+* segments) — the shape whose field address is the root base plus the sum of
+* field offsets. A call segment (`arena.get(handle).children`,
+* `make().field`) makes the summed-offset computation invalid: the call
+* result is different storage than the root base, so the receiver address
+* must be built from the call (`build_node` of the object) plus the field
+* offset instead.
+*/
+function chain_is_pure_fields(node) {
+	if (node.node_type === "value") return true;
+	if (node.node_type !== "access") return false;
+	const acc = node;
+	if (acc.access.node_type !== "access_field") return false;
+	return chain_is_pure_fields(acc.target);
+}
 function access_chain_crosses_class(node, status) {
 	const base_type = resolve_access_target_type(get_base_target(node), status);
 	if (base_type?.name && status.structs.find((s) => s.name === base_type.name && s.is_class)) return true;
@@ -42704,6 +43242,12 @@ function build_access_field(node, status) {
 		ensure_newline(status);
 		const final_offset = offset;
 		const field_type = access_field.type?.name || "";
+		const method_field_type = status.structs.find((s) => s.name === (target_type?.name || "") && !s.is_simple_type)?.fields.find((f) => f.name === access_field.name)?.type ?? access_field.type;
+		const method_field_name = method_field_type?.type_args?.length ? mono_type_name(method_field_type) : method_field_type?.name || "";
+		if (method_field_name && !method_field_type?.is_ref && !method_field_type?.is_nullable && is_struct_type(method_field_name, status)) {
+			if (final_offset > 0) emit_asm(status, `add x0, x0, #${final_offset}\n`);
+			return;
+		}
 		const at_reg = status.at_addr_reg;
 		status.at_addr_reg = void 0;
 		const load_base = at_reg ?? "x0";
@@ -42725,7 +43269,7 @@ function build_access_field(node, status) {
 		else emit_asm(status, `ldr x0, [${load_base}, #${final_offset}]\n`);
 		return;
 	}
-	if (target_is_class_access) {
+	if (target_is_class_access || !chain_is_pure_fields(node.target)) {
 		build_node(node.target, status);
 		ensure_newline(status);
 		const final_offset = get_field_offset(target_type?.name || "", access_field.name, status);
@@ -43328,9 +43872,11 @@ function build_access_method(node, access_func, status) {
 		} else if (!target_is_simple && node.target.node_type === "access") {
 			const access_target = node.target;
 			if (access_target.access.node_type === "access_field") {
-				if (access_chain_crosses_class(access_target, status)) {
-					build_node(access_target, status);
+				if (!chain_is_pure_fields(access_target) || access_chain_crosses_class(access_target, status)) {
+					const field_offset = get_field_offset(type_from_value_node$1(access_target.target)?.name || "", access_target.access.name, status);
+					build_node(access_target.target, status);
 					ensure_newline(status);
+					if (field_offset > 0) emit_asm(status, `add x0, x0, #${field_offset}\n`);
 				} else {
 					const offset = compute_field_offset(access_target, status);
 					const base = get_base_target(access_target);
@@ -47526,9 +48072,11 @@ function mismatch(expected, actual, status, start) {
 * when either side's signature is unavailable.
 */
 function check_func_argument_signature(expected, arg, status, start) {
+	const expected_params = expected.func_params ?? expected.type?.func_params;
+	const expected_return = expected.func_return_type ?? expected.type?.func_return_type;
 	const expected_sig = {
-		params: expected.func_params ?? expected.type?.func_params,
-		return_type: expected.func_return_type ?? expected.type?.func_return_type
+		params: expected_params ?? (expected_return ? [] : void 0),
+		return_type: expected_return
 	};
 	if (!expected_sig.params && !expected_sig.return_type) return;
 	const actual_sig = arg_signature(arg, status);
@@ -49759,10 +50307,18 @@ function check_declaration_node(decl, status) {
 		if (decl.value?.node_type === "access" && decl.value.access.node_type === "access_field") {
 			const field_type = type_from_value_node(decl.value, status);
 			if (field_type.name && is_owning_struct_type_requiring_move(field_type, status)) {
-				const field_name = decl.value.access.name;
-				if (!decl.value.is_moved) add_error(status, `cannot copy '${field_type.name}' out of field '${field_name}' by value — it owns heap resources; use 'move ... swap <replacement>'`, decl.value.start);
-				else if (!decl.swap) add_error(status, `move out of a field requires a swap to revalidate it`, decl.value.start);
-				else if (check_node(decl.swap, status)) check_type_and_value_match(field_type, type_from_value_node(decl.swap, status), void 0, status, decl.swap.start, "swap");
+				const access_field = decl.value.access;
+				const field_name = access_field.name;
+				const temp_rhs = af_is_destructure_temp(decl.value.target.node_type === "value" ? decl.value.target.value : "");
+				if (!decl.value.is_moved && !temp_rhs) add_error(status, `cannot copy '${field_type.name}' out of field '${field_name}' by value — it owns heap resources; use 'move ... swap <replacement>'`, decl.value.start);
+				else if (!decl.swap) {
+					if (!access_field.destructure_move && !temp_rhs) add_error(status, `move out of a field requires a swap to revalidate it`, decl.value.start);
+					else {
+						decl.value.is_moved = true;
+						decl.swap = synthesized_swap_value(field_type, decl.value.start);
+						if (check_node(decl.swap, status)) check_type_and_value_match(field_type, type_from_value_node(decl.swap, status), void 0, status, decl.swap.start, "swap");
+					}
+				} else if (check_node(decl.swap, status)) check_type_and_value_match(field_type, type_from_value_node(decl.swap, status), void 0, status, decl.swap.start, "swap");
 			}
 		}
 		if (decl.value?.node_type === "value" && decl.value.is_moved && !decl.swap) {
@@ -49906,6 +50462,33 @@ function extract_const_value(value) {
 	if (/^[+-]?\d+$/.test(vn.value)) return parseInt(vn.value, 10);
 	if (/^[+-]?\d+\.\d+$/.test(vn.value)) return parseFloat(vn.value);
 }
+/**
+* The revalidating swap value synthesized for a move-DESTRUCTURING binding
+* (`var [move a] = t`): a fresh default of the moved field's type. A string
+* swaps in an empty literal; an owning struct (List/Buffer/Map/...) swaps in
+* its no-argument constructor (type_args carried so `List<string>` swaps in
+* `List<string>()`). The zero/empty replacement makes the source field's own
+* cleanup a no-op instead of a double-free of the transferred buffer.
+*/
+function synthesized_swap_value(field_type, start) {
+	if (field_type.name === "string") return new ValueNode(start, "\"\"", new Type("string"));
+	const constructor = new FunctionCallNode(start, field_type.name);
+	constructor.type = new Type(field_type.name);
+	if (field_type.type_args?.length) constructor.type_args = field_type.type_args;
+	return constructor;
+}
+/**
+* Whether a destructuring binding's access targets the compiler-created
+* `_tuple_dst_N` temp (a non-simple destructuring RHS): the temp exists only
+* to feed the bindings and is never read again, so an owning field's
+* ownership transfer to the binding is INFERRED (a view binding would
+* dangle — the temp's cleanup frees its fields). (`is_destructure` itself
+* is cleared by the time the binding's owning-field check runs — the access
+* rewrite consumes it — so only the temp-name convention identifies this.)
+*/
+function af_is_destructure_temp(target_name) {
+	return !!target_name && target_name.startsWith("_tuple_dst_");
+}
 //#endregion
 //#region ../src/check/utils/check_init_fields.ts
 const checked_structs = /* @__PURE__ */ new WeakSet();
@@ -54390,6 +54973,10 @@ function check_access_node(node, status) {
 		if (af.is_destructure) {
 			const i = af.destructure_index;
 			if (target_type.is_array) {
+				if (af.destructure_move) {
+					add_error(status, `move destructuring requires a tuple or struct (an array element has no field storage to revalidate)`, node.start);
+					return false;
+				}
 				if (af.is_destructure_rename) {
 					add_error(status, `Cannot rename elements when destructuring an array`, node.start);
 					return false;
@@ -55151,6 +55738,55 @@ function check_array_values_node(array, status) {
 * On success, mutates `array` in-place into a FunctionCallNode that constructs
 * the appropriate auto-generated tuple struct.
 */
+/**
+* Tuple-element ownership resolution. A bare owning-struct variable element
+* (`[t, c]` where t is a `List<string>`) byte-copies the struct — the
+* tuple's field would alias the local's buffer, and both cleanups free it
+* (double-free). Three outcomes per element:
+*
+*   - explicit `move t` — transfer (registered like the move-assignment
+*     path; the tuple's field cleanup owns the buffer now);
+*   - plain `t` stamped by the literal last-use pass — INFERRED transfer
+*     (t is provably never read again, so copy-then-drop and move are
+*     observationally identical; the move is free);
+*   - plain `t` still referenced later — rejected, exactly like the
+*     declaration-path owning-struct copy rule: transfer with `move` or
+*     deep-copy with `.copy()`.
+*
+* Strings and non-owning structs are ordinary by-value copies (views).
+*/
+function check_tuple_element_ownership(array, status) {
+	let rejected = false;
+	for (const value of array.values) {
+		const vn = value;
+		if (vn.node_type !== "value") continue;
+		if (!/^[A-Za-z_][A-Za-z0-9_]*$/.test(vn.value) || vn.value === "null") continue;
+		const t = type_from_value_node(value, status);
+		if (!t.name) continue;
+		if (is_owning_struct_type(t, status)) {
+			if (vn.is_moved || vn.literal_last_use_move) {
+				vn.is_moved = true;
+				if (!status.moved_variables) status.moved_variables = /* @__PURE__ */ new Set();
+				status.moved_variables.add(vn.value);
+			} else {
+				add_error(status, `cannot copy '${t.name}' by value — it owns heap resources; use 'move ${vn.value}' or '${vn.value}.copy()'`, value.start);
+				rejected = true;
+			}
+			continue;
+		}
+		if (t.name === "string" && !t.is_view && !t.is_array) {
+			if (vn.is_moved || vn.literal_last_use_move) {
+				vn.is_moved = true;
+				if (!status.moved_variables) status.moved_variables = /* @__PURE__ */ new Set();
+				status.moved_variables.add(vn.value);
+			} else {
+				add_error(status, `string local '${vn.value}' is read again after the literal — use 'move ${vn.value}' or '${vn.value}.to_string()'`, value.start);
+				rejected = true;
+			}
+		}
+	}
+	return rejected;
+}
 function check_as_tuple(array, tuple_element_types, status) {
 	if (array.values.length !== tuple_element_types.length) return check_as_array_or_inferred_tuple(array, status, tuple_element_types);
 	let result = true;
@@ -55169,6 +55805,7 @@ function check_as_tuple(array, tuple_element_types, status) {
 		value_types.push(vt);
 		check_type_and_value_match(tuple_element_types[i], vt, value_from_value_node(value), status, value.start, "tuple");
 	}
+	if (check_tuple_element_ownership(array, status)) result = false;
 	const struct_name = tuple_struct_name(tuple_element_types);
 	get_or_create_tuple_struct(tuple_element_types, status);
 	const constructor = new FunctionCallNode(array.start, struct_name);
@@ -55251,12 +55888,19 @@ function check_as_array_or_inferred_tuple(array, status, forced_tuple_types) {
 	if (!has_outer_expected) {
 		const meaningful = value_types.filter((t) => t.name && t.name !== "null");
 		const first_meaningful = meaningful[0];
-		if (!(meaningful.length > 0 && meaningful.every((t) => t.name === first_meaningful.name && !t.tuple_types?.length && !first_meaningful.tuple_types?.length)) && array.values.length > 0) {
+		const same_generic_shape = (a, b) => {
+			if (a.name !== b.name) return false;
+			const aa = a.type_args ?? [];
+			const bb = b.type_args ?? [];
+			return aa.length === bb.length && aa.every((t, i) => t.name === bb[i]?.name) && !a.tuple_types?.length && !b.tuple_types?.length;
+		};
+		if (!(meaningful.length > 0 && meaningful.every((t) => same_generic_shape(t, first_meaningful))) && array.values.length > 0) {
 			const elem_types = value_types.map((t, _i) => {
 				if (!t.name || t.name === "null") return meaningful[0] || new Type("int");
 				return t;
 			});
 			for (let i = 0; i < value_types.length; i++) check_type_and_value_match(elem_types[i], value_types[i], value_from_value_node(array.values[i]), status, array.values[i].start, "tuple");
+			if (check_tuple_element_ownership(array, status)) result = false;
 			const struct_name = tuple_struct_name(elem_types);
 			get_or_create_tuple_struct(elem_types, status);
 			const constructor = new FunctionCallNode(array.start, struct_name);
@@ -55753,7 +56397,7 @@ function list_element_type(t, status) {
 	return struct.source_type_args?.[0];
 }
 function check_for_loop_node(for_loop, status) {
-	if (for_loop.list && !(for_loop.list instanceof RangeNode) && for_loop.list.node_type === "value") {
+	if (for_loop.list && !(for_loop.list instanceof RangeNode) && (for_loop.list.node_type === "value" || for_loop.list.node_type === "access")) {
 		const list_type = type_from_value_node(for_loop.list, status);
 		const enumerable = list_type.name ? has_trait(list_type.name, "Enumerable", status) : false;
 		const has_at = list_type.name !== void 0 && !!status.structs.find((s) => s.name === "Array_" + list_type.name && s.functions.some((f) => f.name === "at"));
@@ -55779,6 +56423,16 @@ function check_for_loop_node(for_loop, status) {
 		check_node(for_loop.list, for_status);
 		const list_type = type_from_value_node(for_loop.list, for_status);
 		const is_enumerable = list_type.name ? has_trait(list_type.name, "Enumerable", for_status) : false;
+		const chained_list_elem = list_element_type(list_type, for_status);
+		if (chained_list_elem && !is_enumerable && chain_is_call_free(for_loop.list)) {
+			if (for_loop.item_is_ref) {
+				add_error(for_status, `'ref' iteration is not supported for List<T> — index explicitly (for i of 0..xs.length) and use .set to write back`, for_loop.item.start);
+				return;
+			}
+			desugar_array_for_loop(for_loop, list_type, chained_list_elem);
+			check_for_loop_node(for_loop, for_status);
+			return;
+		}
 		if (!list_type.is_array && !is_enumerable && list_type.name) add_error(for_status, `For loop list must be an array, List, or Enumerable, not ${list_type.name}`, for_loop.list.start);
 		if (for_loop.item_is_ref && list_type.is_array && for_loop.list.node_type === "value") {
 			const list_name = for_loop.list.value;
@@ -55831,6 +56485,23 @@ function check_for_loop_node(for_loop, status) {
 * break/continue so mutations persist on all exit paths. (The write-back is
 * skipped on `return`, matching Rust's copy semantics.)
 */
+/**
+* Whether an iterable expression contains no call segments — the guard for
+* the post-check List desugar (`for x of holder.children`). A chain through
+* a CALL result (`arena.get(handle).children`) cannot discharge the
+* desugared `.at` bounds and miscompiles on aarch64 (FOLLOWUP.md), so it
+* keeps the clear must-be-array-or-Enumerable error.
+*/
+function chain_is_call_free(node) {
+	if (!node || typeof node !== "object") return true;
+	if (node.node_type === "func_call") return false;
+	if (node.node_type === "access") {
+		const access = node;
+		if (access.access.node_type === "access_func") return false;
+		return chain_is_call_free(access.target);
+	}
+	return true;
+}
 function desugar_array_for_loop(for_loop, array_type, elem_type) {
 	const list = for_loop.list;
 	const start = list.start;
@@ -57076,6 +57747,7 @@ function check(root, options) {
 		allow_internal: options?.allow_internal,
 		library_boundary: options?.library_boundary
 	};
+	stamp_literal_element_moves(root);
 	check_node(root, status);
 	unwrap_unsafe_blocks(root);
 	if (!status.errors.length) emit_warnings(root, status);
@@ -57883,6 +58555,10 @@ function looks_like_destructuring(status, start_idx) {
 *   - bare name: `a` — positional (tuples/arrays) or same-named field (structs)
 *   - rename:    `field = name` — struct/class field accessed as `field`,
 *     bound to `name`
+*
+* Either form may be prefixed with `move` (`[move a]`, `[field = move n]`):
+* the binding TAKES OWNERSHIP of the field (see destructure_move) instead of
+* binding a non-owning view.
 */
 function parse_destructuring(visibility, declaration, start, status) {
 	expect("[", status);
@@ -57893,8 +58569,17 @@ function parse_destructuring(visibility, declaration, start, status) {
 		let field = first;
 		let name = first;
 		let rename = false;
-		if (peek_current(status) === "=") {
+		let move = false;
+		if (first === "move" && peek_current(status) !== "=" && peek_current(status) !== "]") {
+			move = true;
+			name = consume(status);
+			field = name;
+		} else if (peek_current(status) === "=") {
 			accept("=", status);
+			if (peek_current(status) === "move") {
+				consume(status);
+				move = true;
+			}
 			name = consume_name(status);
 			field = first;
 			rename = true;
@@ -57902,7 +58587,8 @@ function parse_destructuring(visibility, declaration, start, status) {
 		bindings.push({
 			name,
 			field,
-			rename
+			rename,
+			move
 		});
 		index++;
 		if (!accept(",", status)) break;
@@ -57932,7 +58618,7 @@ function parse_destructuring(visibility, declaration, start, status) {
 		const temp_counter = status.__tuple_destructure_counter || 0;
 		status.__tuple_destructure_counter = temp_counter + 1;
 		const temp_name = `_tuple_dst_${temp_counter}`;
-		push_to_parent(new DeclarationNode(start, "private", "const", temp_name, new Type(""), value));
+		push_to_parent(new DeclarationNode(start, "private", bindings.some((b) => b.move) ? "var" : "const", temp_name, new Type(""), value));
 		base_node = new ValueNode(start, temp_name);
 	}
 	for (let i = 0; i < bindings.length; i++) {
@@ -57942,7 +58628,9 @@ function parse_destructuring(visibility, declaration, start, status) {
 		access_field.is_destructure = true;
 		access_field.destructure_index = i;
 		access_field.is_destructure_rename = binding.rename;
+		access_field.destructure_move = binding.move;
 		const access = new AccessNode(start, base_node, access_field);
+		access.is_moved = binding.move;
 		push_to_parent(new DeclarationNode(start, visibility, declaration, binding.name, new Type(""), access));
 	}
 }