nomen-lang 0.6.2 → 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;
@@ -6538,6 +6544,18 @@ var FunctionCallNode = class extends BaseNode {
 	ref_param_indices;
 	move_param_indices;
 	/**
+	* Indices of arguments bound to a `move T` parameter where T is a
+	* pass-by-value owning struct on a registered free function: ownership
+	* TRANSFERS at the boundary (the callee seeds the param's string-field
+	* records and frees them at its exit), so the caller drops its records
+	* instead of freeing them. The plain `move_param_indices` convention
+	* (callee deep-copies, caller frees the originals) still governs
+	* container stores and every non-transfer shape. Stamped by
+	* check_function_call alongside owned_value_param_indices.
+	*/
+	move_owned_param_indices;
+	owned_value_param_indices;
+	/**
 	* Indices of arguments whose corresponding callee parameter is a nullable
 	* struct value type (`T?` where T is a non-class struct). Populated during
 	* the check pass when the callee's signature is resolved. The build uses
@@ -6736,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;
@@ -6958,6 +6984,12 @@ var FunctionNode = class extends BaseNode {
 	* are dual-natured: called under their own name AND passed as values).
 	*/
 	is_closure;
+	/** The function's address escapes into a func-typed value (bound to a
+	*  `var func …` variable/field, passed as a func value, …) — so it may be
+	*  invoked through a pointer with a BORROWED argument: pass-by-value
+	*  normalization (owned-param record seeding / call-site shell
+	*  materialization) must not apply. Set during check. */
+	address_escaped;
 	/**
 	* Captured outer locals (CLOSURE.md Phase 2). One entry per variable the
 	* lambda body references from an enclosing function; the backends emit an
@@ -7335,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
@@ -7366,6 +7405,16 @@ var DeclarationNode = class extends BaseNode {
 	*  paths strdup the initializer and free the temp's copy at scope exit.
 	*  Set at build time by hoist_field_overrides. */
 	force_owned_string;
+	/** True for an OWNED value-struct PARAMETER whose string fields the
+	*  callee frees at scope exit: the field accesses (and the record-free
+	*  emitted by free_scoped_declarations) go through the param POINTER
+	*  (`p->field`) instead of value syntax (`p.field`). Set at build time
+	*  when the function builder seeds pass-by-value struct params. */
+	string_fields_via_pointer;
+	/** True alongside string_fields_via_pointer when the caller materialized
+	*  a heap shell for the argument (pass-by-value): the callee frees the
+	*  shell itself at scope exit (`free(p)`) after freeing the fields. */
+	owned_heap_shell;
 	constructor(start, visibility, declaration, name, type, value) {
 		super("declare", start);
 		this.visibility = visibility;
@@ -7986,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();
 /**
@@ -8329,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) {
@@ -8445,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();
@@ -8582,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": {
@@ -8718,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);
@@ -10913,6 +11148,85 @@ function array_struct_name(type, status) {
 	return status.structs.find((s) => s.name === mono && !s.is_generic) ? mono : void 0;
 }
 //#endregion
+//#region ../src/build_common/destroy_analysis.ts
+/**
+* Whether any field of the struct is an enum-with-data value owning heap
+* payloads (a string payload — always heap, case construction strdups it —
+* or a class/trait reference payload — construction transfers ownership).
+* Such a field must be reclaimed when the struct dies.
+*/
+function struct_has_owning_enum_field(struct, table) {
+	for (const field of struct.fields) {
+		if (field.type.is_ref) continue;
+		const en = table.enums?.find((e) => e.name === field.type.name);
+		if (!en?.has_associated_data) continue;
+		for (const c of en.cases) for (const p of c.params) {
+			if (p.type.name === "string" && !p.type.is_array) return true;
+			if (table.traits?.some((t) => t.name === p.type.name)) return true;
+			if (table.structs.find((s) => s.name === p.type.name)?.is_class) return true;
+		}
+	}
+	return false;
+}
+/**
+* Whether a struct declares its own `#destroy` (user side effects /
+* resource release).
+*/
+function has_destroy(struct) {
+	return !!struct.functions.find((f) => f.name === "#destroy");
+}
+/**
+* Whether any field (recursively) requires destroy handling — a class
+* field (heap instance to reclaim) or a nested struct with its own
+* `#destroy` (or nested fields that do). Deliberately excludes `string`
+* fields: a struct local whose only owning fields are strings is NOT
+* auto-destroyed at scope exit (the strings may be raw rodata arg
+* pointers, not heap) — see `struct_needs_auto_destroy` for the broader
+* form used to decide whether a `<Struct>_destroy` function is generated.
+*/
+function has_struct_fields_with_destroy(struct, table) {
+	for (const field of struct.fields) {
+		if (field.type.is_ref) continue;
+		const field_struct = resolve_struct_type(field.type, table);
+		if (!field_struct) continue;
+		if (field_struct.is_class) return true;
+		if (has_destroy(field_struct)) return true;
+		if (has_struct_fields_with_destroy(field_struct, table)) return true;
+	}
+	return false;
+}
+/**
+* Whether a struct (or any embedded struct field, recursively) needs a
+* destroy call at scope exit — it has a `#destroy`, a class-typed field,
+* or a nested struct field that itself needs destroying. This does NOT
+* count `string` fields (see `has_struct_fields_with_destroy`).
+*/
+function struct_needs_destroy(struct, table) {
+	return has_destroy(struct) || has_struct_fields_with_destroy(struct, table) || struct_has_owning_enum_field(struct, table);
+}
+/**
+* Whether a struct needs an auto-generated `<Struct>_destroy` function.
+* Broader than `struct_needs_destroy`: also returns true for structs with
+* `string` fields, because a Buffer<T> for such a struct deep-copies the
+* strings into slots (strdup on store) and the per-element destroy must
+* free them. The generated destroy frees each string field; it is called
+* from Buffer's specialized #destroy / replace_T, NOT from struct local
+* scope exit (`struct_needs_destroy` governs that path and excludes
+* strings).
+*/
+function struct_needs_auto_destroy(struct, table) {
+	if (struct_needs_destroy(struct, table)) return true;
+	if (struct_has_owning_enum_field(struct, table)) return true;
+	for (const field of struct.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 = resolve_struct_type(field.type, table);
+		if (field_struct && !field_struct.is_class && struct_needs_auto_destroy(field_struct, table)) return true;
+	}
+	return false;
+}
+//#endregion
 //#region ../src/build_common/scan_force_heap_strings.ts
 function scan_force_heap_strings(statements, structs) {
 	const result = /* @__PURE__ */ new Set();
@@ -13391,85 +13705,6 @@ function emit_strdup(status) {
 	emit_asm(status, `ldr x1, [sp], #16\n`);
 }
 //#endregion
-//#region ../src/build_common/destroy_analysis.ts
-/**
-* Whether any field of the struct is an enum-with-data value owning heap
-* payloads (a string payload — always heap, case construction strdups it —
-* or a class/trait reference payload — construction transfers ownership).
-* Such a field must be reclaimed when the struct dies.
-*/
-function struct_has_owning_enum_field(struct, table) {
-	for (const field of struct.fields) {
-		if (field.type.is_ref) continue;
-		const en = table.enums?.find((e) => e.name === field.type.name);
-		if (!en?.has_associated_data) continue;
-		for (const c of en.cases) for (const p of c.params) {
-			if (p.type.name === "string" && !p.type.is_array) return true;
-			if (table.traits?.some((t) => t.name === p.type.name)) return true;
-			if (table.structs.find((s) => s.name === p.type.name)?.is_class) return true;
-		}
-	}
-	return false;
-}
-/**
-* Whether a struct declares its own `#destroy` (user side effects /
-* resource release).
-*/
-function has_destroy(struct) {
-	return !!struct.functions.find((f) => f.name === "#destroy");
-}
-/**
-* Whether any field (recursively) requires destroy handling — a class
-* field (heap instance to reclaim) or a nested struct with its own
-* `#destroy` (or nested fields that do). Deliberately excludes `string`
-* fields: a struct local whose only owning fields are strings is NOT
-* auto-destroyed at scope exit (the strings may be raw rodata arg
-* pointers, not heap) — see `struct_needs_auto_destroy` for the broader
-* form used to decide whether a `<Struct>_destroy` function is generated.
-*/
-function has_struct_fields_with_destroy(struct, table) {
-	for (const field of struct.fields) {
-		if (field.type.is_ref) continue;
-		const field_struct = resolve_struct_type(field.type, table);
-		if (!field_struct) continue;
-		if (field_struct.is_class) return true;
-		if (has_destroy(field_struct)) return true;
-		if (has_struct_fields_with_destroy(field_struct, table)) return true;
-	}
-	return false;
-}
-/**
-* Whether a struct (or any embedded struct field, recursively) needs a
-* destroy call at scope exit — it has a `#destroy`, a class-typed field,
-* or a nested struct field that itself needs destroying. This does NOT
-* count `string` fields (see `has_struct_fields_with_destroy`).
-*/
-function struct_needs_destroy(struct, table) {
-	return has_destroy(struct) || has_struct_fields_with_destroy(struct, table) || struct_has_owning_enum_field(struct, table);
-}
-/**
-* Whether a struct needs an auto-generated `<Struct>_destroy` function.
-* Broader than `struct_needs_destroy`: also returns true for structs with
-* `string` fields, because a Buffer<T> for such a struct deep-copies the
-* strings into slots (strdup on store) and the per-element destroy must
-* free them. The generated destroy frees each string field; it is called
-* from Buffer's specialized #destroy / replace_T, NOT from struct local
-* scope exit (`struct_needs_destroy` governs that path and excludes
-* strings).
-*/
-function struct_needs_auto_destroy(struct, table) {
-	if (struct_needs_destroy(struct, table)) return true;
-	if (struct_has_owning_enum_field(struct, table)) return true;
-	for (const field of struct.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 = resolve_struct_type(field.type, table);
-		if (field_struct && !field_struct.is_class && struct_needs_auto_destroy(field_struct, table)) return true;
-	}
-	return false;
-}
-//#endregion
 //#region ../src/build_common/temp_anchor_consolidation.ts
 /**
 * Shared OWNERSHIP decision for hoisted call-temporary consolidation.
@@ -13504,6 +13739,144 @@ function superseded_param_temp_names(table, call_node, result_type_name) {
 	return names;
 }
 //#endregion
+//#region ../src/build_aarch64/utils/string_pair.ts
+/**
+* Load the string variable `name` into the consecutive register pair
+* (base, base+1) — default x0/x1. Handles the plain slot case; callers
+* that have register-allocated or param forms handle theirs first.
+*/
+function emit_string_pair_load(status, name, base = "x0") {
+	const offset = status.stack_offsets?.get(name);
+	if (offset === void 0) return false;
+	const w = base.startsWith("x") ? base : "x0";
+	const n = parseInt(w.substring(1), 10);
+	if (offset + 8 > 504) {
+		emit_asm(status, `ldr ${w}, [x29, #${offset}]\n`);
+		emit_asm(status, `ldr x${n + 1}, [x29, #${offset + 8}]\n`);
+		return true;
+	}
+	emit_asm(status, `ldp ${w}, x${n + 1}, [x29, #${offset}]\n`);
+	return true;
+}
+/** Load the pair at [addr_reg, #offset] into (base, base+1). */
+function emit_string_pair_load_at(status, addr_reg, offset, base = "x0") {
+	const w = base.startsWith("x") ? base : "x0";
+	emit_asm(status, `ldp ${w}, x${parseInt(w.substring(1), 10) + 1}, [${addr_reg}, #${offset}]\n`);
+}
+/**
+* strdup the fat string in (x0=ptr, x1=len): preserve the len half across
+* the call and leave the owned copy's pair in (x0, x1). The caller keeps
+* ownership of the original.
+*/
+function emit_strdup_string(status) {
+	emit_asm(status, `str x1, [sp, #-16]!\n`);
+	emit_asm(status, status.audit ? `bl _nomen_strdup_wrap\n` : `bl _strdup\n`);
+	emit_asm(status, `ldr x1, [sp], #16\n`);
+}
+/**
+* Pair load/store at [x29, #offset] with an arbitrary register pair —
+* splits into two single-word accesses beyond the ldp/stp +504 range.
+*/
+function emit_pair_load_x29(status, offset, a = "x0", b = "x1") {
+	if (offset + 8 > 504) {
+		emit_asm(status, `ldr ${a}, [x29, #${offset}]\n`);
+		emit_asm(status, `ldr ${b}, [x29, #${offset + 8}]\n`);
+		return;
+	}
+	emit_asm(status, `ldp ${a}, ${b}, [x29, #${offset}]\n`);
+}
+function emit_pair_store_x29(status, offset, a = "x0", b = "x1") {
+	if (offset + 8 > 504) {
+		emit_asm(status, `str ${a}, [x29, #${offset}]\n`);
+		emit_asm(status, `str ${b}, [x29, #${offset + 8}]\n`);
+		return;
+	}
+	emit_asm(status, `stp ${a}, ${b}, [x29, #${offset}]\n`);
+}
+/**
+* Owning specializations for Array<string>'s raw T-generic bodies
+* (`with` / `set`), replacing the shared-pointer copies with per-slot deep
+* copies — the aarch64 analog of Array.nm's `#if T_NEEDS_STRDUP` C branch.
+*
+* Conventions (matching Array.nm raw bodies):
+*   - `with`  (static): x0/x1 = value pair, x2 = count. Returns x0 = heap
+*     buffer ([ptr] = length, elements at +8..).
+*   - `set`   (method): x19 = first element, x1 = index, x2/x3 = value pair.
+* Bounds are guaranteed by the Nomen-level constraints.
+*/
+function emit_owning_array_string_specialize(func_name, status, self_reg = "x19") {
+	if (func_name === "with") {
+		emit_asm(status, `stp x19, x20, [sp, #-16]!\n`);
+		emit_asm(status, `stp x21, x22, [sp, #-16]!\n`);
+		emit_asm(status, `stp x24, x25, [sp, #-16]!\n`);
+		emit_asm(status, `mov x19, x0\n`);
+		emit_asm(status, `mov x20, x1\n`);
+		emit_asm(status, `mov x21, x2\n`);
+		emit_asm(status, `add x0, x21, #1\n`);
+		emit_asm(status, `lsl x0, x0, #4\n`);
+		emit_malloc(status);
+		emit_asm(status, `mov x22, x0\n`);
+		emit_asm(status, `str x21, [x22]\n`);
+		emit_asm(status, `mov x23, #8\n`);
+		emit_asm(status, `mov x24, #0\n`);
+		emit_asm(status, `.Larr_str_with_loop:\n`);
+		emit_asm(status, `cmp x24, x21\n`);
+		emit_asm(status, `b.ge .Larr_str_with_done\n`);
+		emit_asm(status, `mov x0, x19\n`);
+		emit_strdup(status);
+		emit_asm(status, `add x25, x22, x23\n`);
+		emit_asm(status, `stp x0, x20, [x25]\n`);
+		emit_asm(status, `add x23, x23, #16\n`);
+		emit_asm(status, `add x24, x24, #1\n`);
+		emit_asm(status, `b .Larr_str_with_loop\n`);
+		emit_asm(status, `.Larr_str_with_done:\n`);
+		emit_asm(status, `mov x0, x22\n`);
+		emit_asm(status, `ldp x24, x25, [sp], #16\n`);
+		emit_asm(status, `ldp x21, x22, [sp], #16\n`);
+		emit_asm(status, `ldp x19, x20, [sp], #16\n`);
+		return true;
+	}
+	if (func_name === "at" || func_name === "first" || func_name === "at_end") {
+		emit_asm(status, `stp x20, x21, [sp, #-16]!\n`);
+		if (func_name === "at") {
+			emit_asm(status, `lsl x9, x1, #4\n`);
+			emit_asm(status, `add x9, ${self_reg}, x9\n`);
+		} else if (func_name === "at_end") {
+			emit_asm(status, `ldr x9, [${self_reg}, #-8]\n`);
+			emit_asm(status, `sub x9, x9, #1\n`);
+			emit_asm(status, `lsl x9, x9, #4\n`);
+			emit_asm(status, `add x9, ${self_reg}, x9\n`);
+		} else emit_asm(status, `add x9, ${self_reg}, #0\n`);
+		emit_asm(status, `ldp x0, x1, [x9]\n`);
+		emit_asm(status, `ldp x20, x21, [sp], #16\n`);
+		return true;
+	}
+	if (func_name === "set") {
+		emit_asm(status, `stp x20, x21, [sp, #-16]!\n`);
+		emit_asm(status, `lsl x9, x1, #4\n`);
+		emit_asm(status, `add x9, ${self_reg}, x9\n`);
+		emit_asm(status, `ldr x0, [x9]\n`);
+		emit_asm(status, `mov x20, x2\n`);
+		emit_asm(status, `mov x21, x3\n`);
+		emit_free(status);
+		emit_asm(status, `mov x0, x20\n`);
+		emit_strdup(status);
+		emit_asm(status, `str x0, [x9]\n`);
+		emit_asm(status, `str x21, [x9, #8]\n`);
+		emit_asm(status, `ldp x20, x21, [sp], #16\n`);
+		return true;
+	}
+	return false;
+}
+/** Pair store to [base_reg, #offset] with stur fallback (misaligned/far). */
+function emit_pair_store_to(status, base_reg, offset, a, b) {
+	if (offset % 8 === 0 && offset + 8 <= 504 && offset >= 0) emit_asm(status, `stp ${a}, ${b}, [${base_reg}, #${offset}]\n`);
+	else {
+		emit_asm(status, `stur ${a}, [${base_reg}, #${offset}]\n`);
+		emit_asm(status, `stur ${b}, [${base_reg}, #${offset + 8}]\n`);
+	}
+}
+//#endregion
 //#region ../src/build_aarch64/utils/auto_destroy.ts
 /**
 * Whether a declaration's initializer is a non-`move` FIELD ACCESS — a shallow
@@ -13540,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);
@@ -13553,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/
@@ -13911,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}`;
@@ -13964,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) {
@@ -14123,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) {
@@ -14172,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;
@@ -14191,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) {
@@ -14265,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;
@@ -14346,6 +14805,27 @@ function mark_moved_if_struct(value, status, opts) {
 		status.moved.add(var_name);
 	}
 }
+/**
+* strdup the UNRECORDED direct string fields of a value struct whose base is
+* in `base_reg` (+ base_offset) — the return-boundary normalization: the
+* sret byte-copy transfers the RECORDED (heap) fields raw, but unrecorded
+* fields may hold rodata/borrowed bytes the caller cannot free, so they are
+* deep-copied here and the returned struct is uniformly heap-owned.
+*/
+function emit_string_field_strdups_at(status, struct_name, base_reg, base_offset = 0, skip_fields) {
+	const struct = status.structs.find((s) => s.name === struct_name && !s.is_simple_type && !s.is_class);
+	if (!struct) return;
+	for (const field of direct_string_fields(struct)) {
+		if (skip_fields?.has(field.name)) continue;
+		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");
+	}
+}
 //#endregion
 //#region ../src/build_aarch64/utils/closure_a64.ts
 /**
@@ -14520,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;
@@ -16823,28 +17321,6 @@ function value_number_loops(body, ast_list, status, mutate_ast) {
 	};
 }
 //#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;
-}
-//#endregion
 //#region ../src/build_aarch64/utils/owning_buffer_specialize.ts
 /**
 * Detect whether a monomorphized struct is a `Buffer_<T>` whose element type
@@ -19070,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 = [];
@@ -19458,6 +19936,16 @@ function build_function_node$1(node, status) {
 			}
 			param_idx++;
 			if (param.declaration === "var") status.function_param_vars.add(param.name);
+			const is_free_function = (!node.scope || node.scope.node_type === "root" || node.scope.node_type === "func") && !node.params.some((p) => p.is_self_param);
+			const owned_value_param = !param.is_self_param && !param.is_variadic && !param.type.is_ref && !param.type.is_nullable && !param.type.is_view && !param.type.is_array && param.type.name ? status.structs.find((st) => st.name === param.type.name && !st.is_simple_type && !st.is_class) : void 0;
+			if (is_free_function && !node.address_escaped && owned_value_param && direct_string_fields(owned_value_param).length > 0 && !(owned_value_param.traits ?? []).length && !struct_needs_destroy(owned_value_param, status) && (status.normalized_struct_returners?.has(node.name) || status.normalized_struct_returners?.has(label_name)) && !status.func_address_taken?.has(node.name) && !status.func_address_taken?.has(label_name)) {
+				status.function_param_vars.add(param.name);
+				const param_decl = new DeclarationNode(param.start, "private", "var", param.name, param.type);
+				param_decl.string_fields_via_pointer = true;
+				status.scoped_declarations.push(param_decl);
+				if (!status.heap_string_fields) status.heap_string_fields = /* @__PURE__ */ new Set();
+				for (const field of direct_string_fields(owned_value_param)) status.heap_string_fields.add(`${param.name}.${field.name}`);
+			}
 			if (param.type.is_array) {
 				if (!param.is_variadic ? array_struct_name(param.type, status) : void 0) {
 					if (!status.heap_array_vars) status.heap_array_vars = /* @__PURE__ */ new Set();
@@ -19648,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;
@@ -19669,144 +20158,6 @@ function build_function_node$1(node, status) {
 	status.function_return_type = void 0;
 }
 //#endregion
-//#region ../src/build_aarch64/utils/string_pair.ts
-/**
-* Load the string variable `name` into the consecutive register pair
-* (base, base+1) — default x0/x1. Handles the plain slot case; callers
-* that have register-allocated or param forms handle theirs first.
-*/
-function emit_string_pair_load(status, name, base = "x0") {
-	const offset = status.stack_offsets?.get(name);
-	if (offset === void 0) return false;
-	const w = base.startsWith("x") ? base : "x0";
-	const n = parseInt(w.substring(1), 10);
-	if (offset + 8 > 504) {
-		emit_asm(status, `ldr ${w}, [x29, #${offset}]\n`);
-		emit_asm(status, `ldr x${n + 1}, [x29, #${offset + 8}]\n`);
-		return true;
-	}
-	emit_asm(status, `ldp ${w}, x${n + 1}, [x29, #${offset}]\n`);
-	return true;
-}
-/** Load the pair at [addr_reg, #offset] into (base, base+1). */
-function emit_string_pair_load_at(status, addr_reg, offset, base = "x0") {
-	const w = base.startsWith("x") ? base : "x0";
-	emit_asm(status, `ldp ${w}, x${parseInt(w.substring(1), 10) + 1}, [${addr_reg}, #${offset}]\n`);
-}
-/**
-* strdup the fat string in (x0=ptr, x1=len): preserve the len half across
-* the call and leave the owned copy's pair in (x0, x1). The caller keeps
-* ownership of the original.
-*/
-function emit_strdup_string(status) {
-	emit_asm(status, `str x1, [sp, #-16]!\n`);
-	emit_asm(status, status.audit ? `bl _nomen_strdup_wrap\n` : `bl _strdup\n`);
-	emit_asm(status, `ldr x1, [sp], #16\n`);
-}
-/**
-* Pair load/store at [x29, #offset] with an arbitrary register pair —
-* splits into two single-word accesses beyond the ldp/stp +504 range.
-*/
-function emit_pair_load_x29(status, offset, a = "x0", b = "x1") {
-	if (offset + 8 > 504) {
-		emit_asm(status, `ldr ${a}, [x29, #${offset}]\n`);
-		emit_asm(status, `ldr ${b}, [x29, #${offset + 8}]\n`);
-		return;
-	}
-	emit_asm(status, `ldp ${a}, ${b}, [x29, #${offset}]\n`);
-}
-function emit_pair_store_x29(status, offset, a = "x0", b = "x1") {
-	if (offset + 8 > 504) {
-		emit_asm(status, `str ${a}, [x29, #${offset}]\n`);
-		emit_asm(status, `str ${b}, [x29, #${offset + 8}]\n`);
-		return;
-	}
-	emit_asm(status, `stp ${a}, ${b}, [x29, #${offset}]\n`);
-}
-/**
-* Owning specializations for Array<string>'s raw T-generic bodies
-* (`with` / `set`), replacing the shared-pointer copies with per-slot deep
-* copies — the aarch64 analog of Array.nm's `#if T_NEEDS_STRDUP` C branch.
-*
-* Conventions (matching Array.nm raw bodies):
-*   - `with`  (static): x0/x1 = value pair, x2 = count. Returns x0 = heap
-*     buffer ([ptr] = length, elements at +8..).
-*   - `set`   (method): x19 = first element, x1 = index, x2/x3 = value pair.
-* Bounds are guaranteed by the Nomen-level constraints.
-*/
-function emit_owning_array_string_specialize(func_name, status, self_reg = "x19") {
-	if (func_name === "with") {
-		emit_asm(status, `stp x19, x20, [sp, #-16]!\n`);
-		emit_asm(status, `stp x21, x22, [sp, #-16]!\n`);
-		emit_asm(status, `stp x24, x25, [sp, #-16]!\n`);
-		emit_asm(status, `mov x19, x0\n`);
-		emit_asm(status, `mov x20, x1\n`);
-		emit_asm(status, `mov x21, x2\n`);
-		emit_asm(status, `add x0, x21, #1\n`);
-		emit_asm(status, `lsl x0, x0, #4\n`);
-		emit_malloc(status);
-		emit_asm(status, `mov x22, x0\n`);
-		emit_asm(status, `str x21, [x22]\n`);
-		emit_asm(status, `mov x23, #8\n`);
-		emit_asm(status, `mov x24, #0\n`);
-		emit_asm(status, `.Larr_str_with_loop:\n`);
-		emit_asm(status, `cmp x24, x21\n`);
-		emit_asm(status, `b.ge .Larr_str_with_done\n`);
-		emit_asm(status, `mov x0, x19\n`);
-		emit_strdup(status);
-		emit_asm(status, `add x25, x22, x23\n`);
-		emit_asm(status, `stp x0, x20, [x25]\n`);
-		emit_asm(status, `add x23, x23, #16\n`);
-		emit_asm(status, `add x24, x24, #1\n`);
-		emit_asm(status, `b .Larr_str_with_loop\n`);
-		emit_asm(status, `.Larr_str_with_done:\n`);
-		emit_asm(status, `mov x0, x22\n`);
-		emit_asm(status, `ldp x24, x25, [sp], #16\n`);
-		emit_asm(status, `ldp x21, x22, [sp], #16\n`);
-		emit_asm(status, `ldp x19, x20, [sp], #16\n`);
-		return true;
-	}
-	if (func_name === "at" || func_name === "first" || func_name === "at_end") {
-		emit_asm(status, `stp x20, x21, [sp, #-16]!\n`);
-		if (func_name === "at") {
-			emit_asm(status, `lsl x9, x1, #4\n`);
-			emit_asm(status, `add x9, ${self_reg}, x9\n`);
-		} else if (func_name === "at_end") {
-			emit_asm(status, `ldr x9, [${self_reg}, #-8]\n`);
-			emit_asm(status, `sub x9, x9, #1\n`);
-			emit_asm(status, `lsl x9, x9, #4\n`);
-			emit_asm(status, `add x9, ${self_reg}, x9\n`);
-		} else emit_asm(status, `add x9, ${self_reg}, #0\n`);
-		emit_asm(status, `ldp x0, x1, [x9]\n`);
-		emit_asm(status, `ldp x20, x21, [sp], #16\n`);
-		return true;
-	}
-	if (func_name === "set") {
-		emit_asm(status, `stp x20, x21, [sp, #-16]!\n`);
-		emit_asm(status, `lsl x9, x1, #4\n`);
-		emit_asm(status, `add x9, ${self_reg}, x9\n`);
-		emit_asm(status, `ldr x0, [x9]\n`);
-		emit_asm(status, `mov x20, x2\n`);
-		emit_asm(status, `mov x21, x3\n`);
-		emit_free(status);
-		emit_asm(status, `mov x0, x20\n`);
-		emit_strdup(status);
-		emit_asm(status, `str x0, [x9]\n`);
-		emit_asm(status, `str x21, [x9, #8]\n`);
-		emit_asm(status, `ldp x20, x21, [sp], #16\n`);
-		return true;
-	}
-	return false;
-}
-/** Pair store to [base_reg, #offset] with stur fallback (misaligned/far). */
-function emit_pair_store_to(status, base_reg, offset, a, b) {
-	if (offset % 8 === 0 && offset + 8 <= 504 && offset >= 0) emit_asm(status, `stp ${a}, ${b}, [${base_reg}, #${offset}]\n`);
-	else {
-		emit_asm(status, `stur ${a}, [${base_reg}, #${offset}]\n`);
-		emit_asm(status, `stur ${b}, [${base_reg}, #${offset + 8}]\n`);
-	}
-}
-//#endregion
 //#region ../src/build_aarch64/build_struct_node.ts
 let field_strdup_guard_counter = 0;
 function emit_typed_store(status, src_reg, dst_base, offset, size) {
@@ -21312,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);
@@ -21327,7 +21684,7 @@ function build_block_node$1(node, status) {
 		heap_slots: [],
 		struct_decls: []
 	});
-	const declarations_before = status.scoped_declarations.length;
+	const declarations_before = node.node_type === "func" ? 0 : status.scoped_declarations.length;
 	for (let child of node.statements) if (is_struct_node(child)) {
 		if (!should_emit_definition(child, status.emit_mode, status.structs, status.system_struct_names)) continue;
 		build_struct_node$1(child, status);
@@ -21482,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.
@@ -21611,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);
@@ -22006,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];
@@ -22405,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;
@@ -22554,12 +22998,15 @@ function build_declaration_node$1(node, status, nir_init, nir_swap) {
 				build_swap_params(func_call, status);
 			} else {
 				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", node.name);
+				status.struct_return_buffer_var = node.name;
 				status.struct_return_buffer = "x8";
 				status.call_x8_preset = true;
 				emit_init_value$1(node.value, nir_init, status);
 				status.struct_return_buffer = old_buffer;
+				status.struct_return_buffer_var = old_buffer_var;
 				status.call_x8_preset = old_preset;
 			}
 			return;
@@ -22867,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;
@@ -22889,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) {
@@ -23085,14 +23549,18 @@ function build_declaration_node$1(node, status, nir_init, nir_swap) {
 					build_swap_params(func_call, 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;
 					const old_preset = status.call_x8_preset;
 					emit_var_address(status, "x8", node.name);
+					status.struct_return_buffer_var = node.name;
 					status.struct_return_buffer = "x8";
 					status.call_x8_preset = true;
 					emit_init_value$1(node.value, nir_init, status);
 					status.struct_return_buffer = old_buffer;
+					status.struct_return_buffer_var = old_buffer_var;
 					status.call_x8_preset = old_preset;
 					emit_var_address(status, "x0", node.name);
+					record_call_init_string_fields(node, status);
 				} else {
 					emit_init_value$1(node.value, nir_init, status);
 					emit_var_store(status, "x0", node.name, struct_size);
@@ -23128,6 +23596,7 @@ function build_declaration_node$1(node, status, nir_init, nir_swap) {
 					const field_type = (target_type.name ? status.structs.find((s) => s.name === target_type.name) : void 0)?.fields.find((f) => f.name === field_name)?.type ?? type_from_value_node$1(access.access);
 					emit_struct_copy("x1", "x0", get_field_offset(target_type.name, field_name, status), get_struct_size(field_type.name, status), status);
 				}
+				record_call_init_string_fields(node, status);
 			}
 		}
 	} else if (node.value) {
@@ -24785,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;
@@ -24805,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;
@@ -24893,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`);
@@ -24905,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;
@@ -24913,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") {
@@ -24923,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) {
@@ -24967,6 +25440,28 @@ function build_return_node$1(node, status, nir_value) {
 				const field_off = get_field_offset(ret_struct.name, field.name, status);
 				emit_enum_payload_strdups_at(status, field_enum.name, "x8", field_off);
 			}
+			if (ret_struct && !returns_nullable_struct) {
+				const returned_var = node.value.node_type === "value" ? node.value.value : "";
+				if (returned_var !== "" && returned_var !== "0" && returned_var !== "null" && all_scope_frames(status).flat().some((d) => d.name === returned_var)) {
+					let skip_fields;
+					const prefix = `${node.value.value}.`;
+					for (const key of status.heap_string_fields ?? []) if (key.startsWith(prefix)) {
+						skip_fields ??= /* @__PURE__ */ new Set();
+						skip_fields.add(key.slice(prefix.length));
+					}
+					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);
+				}
+			}
 		}
 	}
 	if (status.return_assign) {
@@ -25034,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;
@@ -28271,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",
@@ -28310,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";
@@ -28321,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 = [];
@@ -28596,8 +29115,39 @@ function build_function_call_node$1(node, status) {
 						emit_asm(status, `str x9, [x29, #${off + struct_size}]\n`);
 						emit_asm(status, `add x0, x29, #${off}\n`);
 					}
-				} else if (is_struct_type$3(param_type, status) || is_enum_with_data_type$2(param_type, status)) emit_struct_address(node.params[i], status);
-				else if (arg_deferrable(i)) {
+				} else if (is_struct_type$3(param_type, status) || is_enum_with_data_type$2(param_type, status)) {
+					if (node.move_owned_param_indices?.includes(i) && node.params[i].node_type === "value") {
+						const transfer_struct = status.structs.find((st) => st.name === resolve_struct_name(param_type, param.type?.type_args, status) && !st.is_simple_type && !st.is_class && !st.is_generic);
+						const transfer_var = node.params[i].value;
+						if (transfer_struct && direct_string_fields(transfer_struct).length > 0 && transfer_var) {
+							const recorded = /* @__PURE__ */ new Set();
+							for (const key of status.heap_string_fields ?? []) if (key.startsWith(`${transfer_var}.`)) recorded.add(key.slice(transfer_var.length + 1));
+							if (direct_string_fields(transfer_struct).filter((f) => !recorded.has(f.name)).length > 0) {
+								emit_struct_address(node.params[i], status);
+								ensure_newline(status);
+								emit_string_field_strdups_at(status, transfer_struct.name, "x0", 0, recorded);
+								if (status.call_x8_preset && status.struct_return_buffer_var) emit_var_address(status, "x8", status.struct_return_buffer_var);
+							}
+						}
+					}
+					const arg_struct = status.structs.find((st) => st.name === resolve_struct_name(param_type, param.type?.type_args, status) && !st.is_simple_type && !st.is_class && !st.is_generic);
+					if (node.owned_value_param_indices?.includes(i) && arg_struct && !(arg_struct.traits ?? []).length && direct_string_fields(arg_struct).length > 0 && status.normalized_struct_returners?.has(func_name) && !status.func_address_taken?.has(func_name)) {
+						const mono_name = arg_struct.name;
+						const struct_size = get_struct_size(mono_name, status);
+						const off = allocate_stack_space(status, struct_size);
+						emit_struct_address(node.params[i], status);
+						ensure_newline(status);
+						emit_asm(status, `mov x1, x0\n`);
+						emit_asm(status, `add x0, x29, #${off}\n`);
+						for (let b = 0; b < struct_size; b += 8) {
+							emit_asm(status, `ldr x2, [x1, #${b}]\n`);
+							emit_asm(status, `str x2, [x0, #${b}]\n`);
+						}
+						emit_asm(status, `add x0, x29, #${off}\n`);
+						emit_string_field_strdups_at(status, mono_name, "x0");
+						if (status.call_x8_preset && status.struct_return_buffer_var) emit_var_address(status, "x8", status.struct_return_buffer_var);
+					} else emit_struct_address(node.params[i], status);
+				} else if (arg_deferrable(i)) {
 					deferred_args.push({
 						param: node.params[i],
 						slot: arg_slot[i]
@@ -28729,6 +29279,7 @@ function build_function_call_node$1(node, status) {
 			const tname = all_scope_frames(status).flat().find((d) => d.name === vname)?.type?.name ?? param.type?.name;
 			if (tname === "string") continue;
 			if (tname && status.enums.find((e) => e.name === tname && e.has_associated_data)) continue;
+			if (vname !== void 0 && (node.move_owned_param_indices?.includes(idx) ?? false)) clear_heap_string_fields(status, vname);
 		}
 		if (param) mark_moved_if_struct(param, status);
 	}
@@ -31030,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) {
@@ -31051,17 +31616,34 @@ 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(".");
-			status.code += `free(${c_function_name(key.substring(0, dot))}${key.substring(dot)}.ptr);\n`;
+			const base = c_function_name(key.substring(0, dot));
+			const arrow = dec.string_fields_via_pointer ? "->" : ".";
+			const field = key.substring(dot + 1);
+			const free_fn = status.audit ? "nomen_free_wrap" : "free";
+			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) {
+			if (!commented) {
+				status.code += "\n// Auto-free\n";
+				commented = true;
+			}
+			status.code += `${status.audit ? "nomen_free_wrap" : "free"}(${c_function_name(dec.name)});\n`;
+			continue;
+		}
 		if (persist_string_field_records && dec.force_owned_string === true) continue;
 		if (status.moved?.has(dec.name)) continue;
 		const cname = c_function_name(dec.name);
@@ -31569,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") {
@@ -31659,7 +32284,8 @@ function build_assignment_node$1(node, status, nir_rhs, nir_swap) {
 			status.init_assigned_fields.add(tracked_key);
 		}
 		const old_was_heap = !!target_struct?.is_class && !first_init_write || !!status.heap_string_fields?.has(tracked_key);
-		if (target_struct && target_var && (!self_target || target_struct.is_class)) {
+		const is_class_target = !!target_struct?.is_class;
+		if (target_struct && (target_var || is_class_target) && (!self_target || is_class_target)) {
 			const fresh_heap = is_owned_heap_temp$1(node.right_value, status);
 			const rhs_is_null_value = node.right_value.node_type === "value" && node.right_value.value === "null";
 			const saved_len = begin_code_scratch(status);
@@ -31942,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);
@@ -32263,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
@@ -32274,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);
@@ -32421,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;
@@ -32624,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`;
@@ -32693,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);
@@ -32730,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") {
@@ -32741,6 +33491,7 @@ function build_declaration_node(node, status, nir_init, nir_swap) {
 				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);
 		}
 	}
 }
@@ -33256,6 +34007,7 @@ function build_return_node(node, status, nir_value) {
 		}
 	}
 	let returned_value_decl;
+	let returned_recorded_string_fields;
 	if (node.value.node_type === "value") {
 		const value = node.value.value;
 		returned_value_decl = find_decl_across_scopes(value, status);
@@ -33269,7 +34021,11 @@ function build_return_node(node, status, nir_value) {
 		}
 		if (status.heap_string_fields?.size) {
 			const prefix = `${value}.`;
-			for (const key of Array.from(status.heap_string_fields)) if (key.startsWith(prefix)) status.heap_string_fields.delete(key);
+			for (const key of Array.from(status.heap_string_fields)) if (key.startsWith(prefix)) {
+				returned_recorded_string_fields ??= /* @__PURE__ */ new Set();
+				returned_recorded_string_fields.add(key.slice(prefix.length));
+				status.heap_string_fields.delete(key);
+			}
 		}
 	}
 	if (ret_type?.is_array && return_array_var && return_array_len > 0) {
@@ -33378,6 +34134,20 @@ function build_return_node(node, status, nir_value) {
 		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`;
 		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" && 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`;
@@ -35142,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) {
@@ -35328,6 +36114,18 @@ function build_function_node(node, status) {
 				if (param_trait && !param_struct?.is_class) decl.trait_class_trait = param.type.name;
 				status.scoped_declarations.push(decl);
 			}
+			const is_free_function = (!node.scope || node.scope.node_type === "root" || node.scope.node_type === "func") && !node.params.some((p) => p.is_self_param);
+			const fn_name = node.name;
+			const fn_label = emission_label(node);
+			const owned_value_struct = is_free_function && !node.address_escaped && !param.is_self_param && !param.is_variadic && !param.type.is_ref && !param.type.is_nullable && !param.type.is_view && !param.type.is_array && param.type.name ? status.structs.find((st) => st.name === param.type.name && !st.is_simple_type && !st.is_class) : void 0;
+			if (owned_value_struct && !(owned_value_struct.traits ?? []).length && direct_string_fields(owned_value_struct).length > 0 && !struct_needs_destroy(owned_value_struct, status) && (status.normalized_struct_returners?.has(fn_name) || status.normalized_struct_returners?.has(fn_label)) && !status.func_address_taken?.has(fn_name) && !status.func_address_taken?.has(fn_label)) {
+				const decl = new DeclarationNode(param.start, "private", "var", pname, param.type);
+				decl.string_fields_via_pointer = true;
+				decl.owned_heap_shell = !param.is_moved;
+				status.scoped_declarations.push(decl);
+				if (!status.heap_string_fields) status.heap_string_fields = /* @__PURE__ */ new Set();
+				for (const field of direct_string_fields(owned_value_struct)) status.heap_string_fields.add(`${pname}.${field.name}`);
+			}
 		}
 	}
 	const nir = node.statements?.length ? lower_function(node) : void 0;
@@ -35351,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`;
@@ -36535,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;
@@ -36568,6 +37368,27 @@ function build_function_call_node(node, status) {
 			continue;
 		}
 		const param_type = type_from_value_node$1(node.params[i]);
+		if (node.move_owned_param_indices?.includes(i) && node.params[i].node_type === "value") {
+			const transfer_struct = status.structs.find((st) => st.name === mono_type_name(param_type) && !st.is_simple_type && !st.is_class && !st.is_generic);
+			const transfer_var = node.params[i].value;
+			if (transfer_struct && direct_string_fields(transfer_struct).length > 0 && transfer_var) {
+				const recorded = /* @__PURE__ */ new Set();
+				for (const key of status.heap_string_fields ?? []) if (key.startsWith(`${transfer_var}.`)) recorded.add(key.slice(transfer_var.length + 1));
+				const unrecorded = direct_string_fields(transfer_struct).filter((f) => !recorded.has(f.name));
+				if (unrecorded.length > 0) {
+					const saved_arg = begin_code_scratch(status);
+					status.code += `(void *)&`;
+					status.suppress_dereference = true;
+					build_node$1(node.params[i], status);
+					status.suppress_dereference = false;
+					const addr_text = end_code_scratch(status, saved_arg);
+					status.code += `(void *)({ struct ${transfer_struct.name} *_t = (struct ${transfer_struct.name} *)${addr_text}; `;
+					for (const f of unrecorded) status.code += `_t->${f.name} = nomen_str_dup(_t->${f.name}); `;
+					status.code += `(void *)_t; })`;
+					continue;
+				}
+			}
+		}
 		if (node.nullable_param_indices?.includes(i) && node.params[i].node_type === "value" && node.params[i].value === "null") {
 			status.code += `(void *)&(struct ${param_type.name}){0}, 0`;
 			continue;
@@ -36614,6 +37435,23 @@ function build_function_call_node(node, status) {
 			status.suppress_dereference = false;
 			continue;
 		}
+		const arg_struct = status.structs.find((st) => st.name === mono_type_name(param_type) && !st.is_simple_type && !st.is_class && !st.is_generic);
+		if (node.owned_value_param_indices?.includes(i) && !param_is_class && arg_struct && !(arg_struct.traits ?? []).length && direct_string_fields(arg_struct).length > 0 && status.normalized_struct_returners?.has(func_name) && !status.func_address_taken?.has(func_name)) {
+			const struct_name = arg_struct.name;
+			const fields = direct_string_fields(arg_struct);
+			const saved_arg = begin_code_scratch(status);
+			status.code += `(void *)&`;
+			status.suppress_dereference = true;
+			build_node$1(node.params[i], status);
+			status.suppress_dereference = false;
+			const addr_text = end_code_scratch(status, saved_arg);
+			status.code += `(void *)({ struct ${struct_name} *_src = (struct ${struct_name} *)${addr_text}; `;
+			status.code += `struct ${struct_name} *_own = (struct ${struct_name} *)malloc(sizeof(struct ${struct_name})); `;
+			status.code += `*_own = *_src; `;
+			for (const field of fields) status.code += `_own->${field.name} = nomen_str_dup(_own->${field.name}); `;
+			status.code += `_own; })`;
+			continue;
+		}
 		if (!param_is_class && !!status.structs.find((s) => s.name === param_type.name && !s.is_simple_type) || !!status.traits.find((t) => t.name === param_type.name) || is_ref_param) {
 			if (node.params[i].node_type === "value" && (status.function_ref_params?.has(node.params[i].value) || status.class_vars?.has(node.params[i].value))) status.suppress_dereference = true;
 			else if (is_ref_param) status.code += `&`;
@@ -36690,9 +37528,12 @@ function build_function_call_node(node, status) {
 			if (decl_hit) decl_hit.frame.splice(decl_hit.index, 1);
 			if (is_value_struct) {
 				const prefix = `${vname}.`;
+				const transfer = node.move_owned_param_indices?.includes(idx) ?? false;
 				for (const key of Array.from(status.heap_string_fields ?? [])) if (key.startsWith(prefix)) {
-					if (!status.pending_string_releases) status.pending_string_releases = [];
-					status.pending_string_releases.push(`free(${key}.ptr);`);
+					if (!transfer) {
+						if (!status.pending_string_releases) status.pending_string_releases = [];
+						status.pending_string_releases.push(`free(${key}.ptr);`);
+					}
 					status.heap_string_fields.delete(key);
 				}
 			}
@@ -36895,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) {
@@ -38353,6 +39099,10 @@ function get_base_address(access, status, reg) {
 			if (paramReg !== reg) emit_asm(status, `mov ${reg}, ${paramReg}\n`);
 		} else if (is_local_ref_var(name, status)) emit_deref_var_address(status, reg, name);
 		else emit_var_address(status, reg, name);
+	} else if (access_chain_crosses_class(access, status)) {
+		build_node(access.target, status);
+		ensure_newline(status);
+		if (reg !== "x0") emit_asm(status, `mov ${reg}, x0\n`);
 	} else {
 		emit_address_of(access.target, status);
 		ensure_newline(status);
@@ -38475,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`);
@@ -40775,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;
@@ -41871,6 +42658,9 @@ function emit_address_of(node, status) {
 					if (paramReg !== "x0") emit_asm(status, `mov x0, ${paramReg}\n`);
 				} else if (is_local_ref_var(name, status)) emit_deref_var_address(status, "x0", name);
 				else emit_var_address(status, "x0", name);
+			} else if (access_chain_crosses_class(access, status)) {
+				build_node(access.target, status);
+				ensure_newline(status);
 			} else {
 				emit_address_of(access.target, status);
 				ensure_newline(status);
@@ -42014,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;
@@ -42436,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";
@@ -42457,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);
@@ -43060,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);
@@ -44254,6 +45068,195 @@ function scan_func(func, struct_name, result, class_type_names) {
 	}
 }
 //#endregion
+//#region ../src/build_common/struct_return_classification.ts
+/**
+* Pre-build classification of which functions return value structs whose
+* string fields are UNIFORMLY heap-owned via return-boundary normalization.
+* Populates `status.normalized_struct_returners`; a caller binding a call
+* result of a registered function records the struct's string fields and
+* frees them at scope exit, while bindings of unregistered callees keep the
+* pre-existing borrow behavior (never recorded, never freed — sound, though
+* it may leak on slot overwrites, which is the documented status quo).
+*
+* The rule is deliberately narrow: a function normalizes iff EVERY
+* struct-return statement returns a BARE VARIABLE (a local or parameter).
+* That is the transfer shape — the returned variable dies at the return, so
+* the boundary normalization (transfer recorded heap fields, strdup the
+* rest) is sound and leak-free. Every other shape keeps the status quo:
+*
+*   - container borrow accessors (`at`/`first`/`slice`/`load` — e.g.
+*     `Map.get`'s `return self.values.load_T(idx)`) yield SLOT-owned bytes;
+*     normalizing them would leak in expression-temp consumers
+*     (`m.get(k).field`) that nobody records or frees;
+*   - owned accessors (`pop`/`move_T`/`copy`) transfer slot-owned heap
+*     buffers — the caller's recording is sound WITHOUT normalization, so
+*     they record via the owned-accessor rule (see
+*     call_init_string_fields.ts) and the callee skips the copy;
+*   - forwarded calls (`return make()`) are skipped when the callee is
+*     registered (its result is already uniformly owned — copying it would
+*     leak the inner buffers) and keep the status quo when it is not.
+*
+* This runs as a WHOLE-PROGRAM AST PRE-PASS (before any function body is
+* built) because a build-order-sensitive registry cannot work: nested
+* functions are built after their enclosing function's body, so a runtime
+* registration would be invisible to the caller's earlier lookup.
+*/
+/** Collect every function and struct declaration under the AST (including
+*  nested functions, struct methods, and function bodies at any depth). */
+function collect(node, fns, structs, seen) {
+	if (!node || typeof node !== "object" || seen.has(node)) return;
+	seen.add(node);
+	if (node.node_type === "func") fns.push(node);
+	if (node.node_type === "struct") structs.push(node);
+	for (const key of Object.keys(node)) {
+		if (key === "parent" || key === "scope") continue;
+		const value = node[key];
+		if (Array.isArray(value)) {
+			for (const item of value) if (item && typeof item === "object" && "node_type" in item) collect(item, fns, structs, seen);
+		} else if (value && typeof value === "object" && "node_type" in value) collect(value, fns, structs, seen);
+	}
+}
+/** The DIRECT `return <expr>` statements of a function body (nested function
+*  declarations are not descended into — their returns belong to them). */
+function direct_returns(fn) {
+	const out = [];
+	const seen = /* @__PURE__ */ new Set();
+	const walk = (node) => {
+		if (!node || typeof node !== "object" || seen.has(node)) return;
+		seen.add(node);
+		if (node.node_type === "func" && node !== fn) return;
+		if (node.node_type === "return") out.push(node);
+		for (const key of Object.keys(node)) {
+			if (key === "parent" || key === "scope") continue;
+			const value = node[key];
+			if (Array.isArray(value)) {
+				for (const item of value) if (item && typeof item === "object" && "node_type" in item) walk(item);
+			} else if (value && typeof value === "object" && "node_type" in value) walk(value);
+		}
+	};
+	for (const statement of fn.statements ?? []) walk(statement);
+	return out;
+}
+/** Whether the function is a FREE function: not a method of a struct (whose
+*  element/slot params are passed by address for in-place access) and not a
+*  monomorphized container clone. */
+function is_free_function_node(fn) {
+	const scope = fn.scope;
+	return !scope || scope.node_type === "root" || scope.node_type === "func";
+}
+/**
+* Whole-program pre-pass: classify free functions that take an OWNING value
+* struct parameter (string fields) — those get pass-by-value semantics:
+*
+*   - the CALL SITE materializes a uniformly heap-owned shell (struct-copy
+*     + per-string-field strdup) and passes its address;
+*   - the CALLEE seeds the param's string-field records at entry and frees
+*     the surviving fields (and the shell) at scope exit.
+*
+* Writes through the param then stay local to the callee; the caller's
+* variable is never aliased or mutated. Functions whose address escapes
+* into a func-typed value (`var f = g`, `apply(g, …)`, `b.modify(0, touch)`)
+* are EXCLUDED: they may be invoked through a pointer with a borrowed
+* argument, and keep the status quo (borrow + the documented write leak).
+*
+* Populates `status.normalized_struct_returners` (the materializing set) and
+* `status.func_address_taken` (the excluded set) for the call-site and
+* function-definition builders.
+*/
+function gather_normalized_struct_returners(root, status) {
+	const fns = [];
+	const structs = [];
+	collect(root, fns, structs, /* @__PURE__ */ new Set());
+	const address_taken = /* @__PURE__ */ new Set();
+	const value_walk = (node) => {
+		if (!node || typeof node !== "object") return;
+		if (node.node_type === "value") {
+			const v = node;
+			if (typeof v.value === "string" && v.type?.name === "func" && /^[A-Za-z_]/.test(v.value)) address_taken.add(v.value);
+		}
+		for (const key of Object.keys(node)) {
+			if (key === "parent" || key === "scope") continue;
+			const child = node[key];
+			if (Array.isArray(child)) {
+				for (const item of child) if (item && typeof item === "object" && "node_type" in item) value_walk(item);
+			} else if (child && typeof child === "object" && "node_type" in child) value_walk(child);
+		}
+	};
+	value_walk(root);
+	const decl_walk = (node) => {
+		if (!node || typeof node !== "object") return;
+		const d = node;
+		if (d.node_type === "declaration" && typeof d.name === "string" && d.type?.name === "func") address_taken.add(d.name);
+		for (const key of Object.keys(node)) {
+			if (key === "parent" || key === "scope") continue;
+			const child = node[key];
+			if (Array.isArray(child)) {
+				for (const item of child) if (item && typeof item === "object" && "node_type" in item) decl_walk(item);
+			} else if (child && typeof child === "object" && "node_type" in child) decl_walk(child);
+		}
+	};
+	decl_walk(root);
+	const return_candidates = [];
+	for (const fn of fns) {
+		if (!is_free_function_node(fn)) continue;
+		if (address_taken.has(fn.name)) continue;
+		const ret = fn.return_type;
+		if (!ret || ret.is_array || ret.is_view) continue;
+		const ret_struct = structs.find((st) => st.name === ret.name && !st.is_simple_type && !st.is_class);
+		if (!ret_struct || direct_string_fields(ret_struct).length === 0) continue;
+		return_candidates.push(fn);
+	}
+	const return_normalizing = new Set(return_candidates.map((c) => c.name));
+	let changed = true;
+	while (changed) {
+		changed = false;
+		for (const fn of return_candidates) {
+			if (!return_normalizing.has(fn.name)) continue;
+			for (const ret of direct_returns(fn)) {
+				const value = ret.value ?? void 0;
+				if (value && value.node_type === "value") continue;
+				if (value && value.node_type === "func_call" && return_normalizing.has(value.name ?? "")) continue;
+				return_normalizing.delete(fn.name);
+				changed = true;
+				break;
+			}
+		}
+	}
+	for (const fn of fns) {
+		if (!is_free_function_node(fn)) continue;
+		if (address_taken.has(fn.name)) continue;
+		if (fn.params.some((p) => p.is_self_param)) continue;
+		if (fn.address_escaped) continue;
+		if (!fn.has_body) continue;
+		for (const param of fn.params ?? []) {
+			if (param.is_self_param || param.is_variadic) continue;
+			if (param.type.is_ref || param.type.is_nullable || param.type.is_view || param.type.is_array) continue;
+			const struct = param.type.name ? structs.find((st) => st.name === param.type.name && !st.is_simple_type && !st.is_class) : void 0;
+			if (!struct) continue;
+			if (direct_string_fields(struct).length > 0 && !(struct.traits ?? []).length && !struct_needs_destroy(struct, status)) {
+				if (!status.normalized_struct_returners) status.normalized_struct_returners = /* @__PURE__ */ new Set();
+				status.normalized_struct_returners.add(fn.name);
+				status.normalized_struct_returners.add(emission_label(fn));
+				break;
+			}
+		}
+		if (return_normalizing.has(fn.name)) {
+			if (!status.normalized_struct_returners) status.normalized_struct_returners = /* @__PURE__ */ new Set();
+			status.normalized_struct_returners.add(fn.name);
+			status.normalized_struct_returners.add(emission_label(fn));
+		}
+	}
+	for (const struct of structs) {
+		if (struct.is_class || struct.is_generic || struct.is_simple_type) continue;
+		if (!struct.functions.some((f) => f.name === "copy" && f.has_body)) continue;
+		if (direct_string_fields(struct).length === 0) continue;
+		if (!status.normalized_struct_returners) status.normalized_struct_returners = /* @__PURE__ */ new Set();
+		status.normalized_struct_returners.add(`${struct.name}_copy`);
+	}
+	if (!status.func_address_taken) status.func_address_taken = /* @__PURE__ */ new Set();
+	for (const name of address_taken) status.func_address_taken.add(name);
+}
+//#endregion
 //#region ../src/build.ts
 function build(root, options = {}) {
 	let status = {
@@ -44287,6 +45290,7 @@ function build(root, options = {}) {
 	reset_match_temp_counter();
 	reset_ns_tmp_counter();
 	stamp_last_use_moves(root);
+	gather_normalized_struct_returners(root, status);
 	if (options.arch === "aarch64") {
 		install_asm_code_buffer(status);
 		reset_string_counter$1();
@@ -46510,6 +47514,23 @@ function is_owning_struct_type_requiring_move(type, status) {
 	if (!s || s.is_class) return false;
 	return struct_owns_non_string_heap(s, status, /* @__PURE__ */ new Set());
 }
+/**
+* Whether `type` is a concrete value struct with direct string fields whose
+* only ownership those strings — the pass-by-value convention's domain: a
+* parameter of this type is fully owned by the callee (the call boundary
+* materializes a uniformly heap-owned copy), so `var` field writes inside
+* the body stay local and no call-site acknowledgment is needed. Excludes
+* structs that own non-string heap (those keep `move ... swap` / `ref`
+* semantics) and structs conforming to traits (trait dispatch aliases).
+*/
+function is_pass_by_value_owning_struct(type, status) {
+	const s = resolve_struct$1(type, status);
+	if (!s || s.is_class || s.is_generic || s.is_simple_type) return false;
+	if ((s.traits ?? []).length > 0) return false;
+	if (direct_string_fields(s).length === 0) return false;
+	if (struct_owns_non_string_heap(s, status, /* @__PURE__ */ new Set())) return false;
+	return true;
+}
 function struct_owns_non_string_heap(s, status, visited) {
 	if (visited.has(s.name)) return false;
 	visited.add(s.name);
@@ -47051,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);
@@ -49150,6 +50173,12 @@ function check_declaration_node(decl, status) {
 	if (is_view_keyword && decl.type_start !== void 0) decl.type.is_view = true;
 	if (decl.func_params) {
 		if (is_view_keyword) add_error(status, `'view' cannot declare a function-typed binding`, decl.start);
+		if (decl.value?.node_type === "func") decl.value.address_escaped = true;
+		else if (decl.value?.node_type === "value") {
+			const fn = status.functions.findLast((f) => f.name === decl.value.value);
+			if (fn) fn.address_escaped = true;
+		}
+		if (decl.value?.node_type === "value" && decl.value.value === "null" && !(decl.type.name === "func" && decl.type.is_nullable)) add_error(status, `cannot assign null to a non-nullable func — declare it 'func?' (or 'Func<...>?')`, decl.value.start);
 		if (decl.func_return_type) {
 			check_type_exists(decl.func_return_type, status, -1);
 			const materialized = materialize_type(decl.func_return_type, status);
@@ -49214,7 +50243,7 @@ function check_declaration_node(decl, status) {
 		status.values.push({
 			declaration,
 			name: decl.name,
-			type: decl.func_return_type || decl.type,
+			type: decl.type.name === "func" && decl.type.is_nullable ? decl.type : decl.func_return_type || decl.type,
 			is_set: !!decl.value,
 			start: decl.start,
 			is_null: decl.value?.node_type === "value" && decl.value.value === "null",
@@ -49278,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) {
@@ -49425,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();
@@ -49712,7 +50776,7 @@ function check_struct_node(struct, status) {
 			continue;
 		}
 		if (decl.func_params) {
-			decl.type = new Type("func");
+			if (decl.type.name !== "func") decl.type = new Type("func");
 			check_declaration_node(decl, status);
 			continue;
 		}
@@ -50020,6 +51084,7 @@ function synthesize_for_struct(struct, status) {
 	if (struct.traits.includes("Stringable") && !struct_has_function(struct, "to_string") && fields.every((f) => field_is_stringable(f, status, /* @__PURE__ */ new Set()))) struct.functions.push(build_to_string(struct, fields));
 	if (struct.traits.includes("Equatable") && !struct_has_function(struct, "eq") && !struct_has_function(struct, "ne") && fields.every((f) => field_is_equatable(f, status, /* @__PURE__ */ new Set()))) struct.functions.push(build_eq(struct, fields));
 	if (struct.traits.includes("Hashable") && !struct_has_function(struct, "hash") && fields.every((f) => field_is_hashable(f, status, /* @__PURE__ */ new Set()))) struct.functions.push(build_hash(struct, fields));
+	synthesize_copy_method(struct, status);
 }
 function build_to_string(struct, fields) {
 	const parts = [string_literal(`${struct.name}(`)];
@@ -50051,6 +51116,81 @@ function build_hash(struct, fields) {
 	const ret = new ReturnNode(-1, expr);
 	return new FunctionNode(-1, "pub", "hash", new Type("uint"), [self_param(struct)], [ret]);
 }
+/**
+* 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.
+*/
+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;
+	return struct_copy_ctor_args(struct) !== null;
+}
+/**
+* How a synthesized `copy` constructs the fresh value: the zero-argument
+* `#init` overload when one exists (auto or user), else the bodyless AUTO
+* `#init` whose params map 1:1 onto non-defaulted fields (pass
+* `self.<param>` for each). Null when neither shape exists — a user #init
+* with params only cannot be invoked without re-running its custom logic,
+* so no `copy` is synthesized.
+*/
+function struct_copy_ctor_args(struct) {
+	const inits = struct.functions.filter((f) => f.name === "#init");
+	if (inits.some((f) => f.params.filter((p) => !p.is_self_param).length === 0)) return [];
+	const auto = inits.find((f) => !f.has_body);
+	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) {
+	if (!type.name || type.is_array || type.is_ref || type.is_view || type.is_nullable) return false;
+	const nested = status.structs.find((s) => s.name === type.name);
+	return !!nested && struct_is_copyable(nested, status);
+}
+/**
+* Synthesize `pub func copy(self) -> Struct` for owning value structs: a
+* fresh `Struct()` whose every field is rewritten from `self` — string
+* field writes strdup the source (the backends' field-write path), nested
+* copyable structs recurse through their own `copy`, everything else byte
+* copies. `return c` hits the return-boundary normalization (all fields
+* recorded → transfer raw), so the caller receives a uniformly heap-owned
+* value with no extra copies.
+*/
+function build_copy(struct, status) {
+	const ctor_args = struct_copy_ctor_args(struct) ?? [];
+	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, "="));
+	}
+	statements.push(new ReturnNode(-1, new ValueNode(-1, "c")));
+	return new FunctionNode(-1, "pub", "copy", new Type(struct.name), [self_param(struct)], statements);
+}
+/**
+* Synthesize the `copy` method on `struct` when eligible and not already
+* present. Called from the block-level derive pre-pass (which runs before
+* the struct is checked, so the method's body is checked with it) AND from
+* `monomorphize` — a mono struct materializes mid-check, after that pre-pass
+* ran, so without this hook `Box<string>.copy()` — advertised by the
+* copy-discipline error messages — would resolve to "Function not found".
+* The caller is responsible for checking the synthesized body when no later
+* struct check will (see monomorphize).
+*/
+function synthesize_copy_method(struct, status) {
+	if (struct_has_function(struct, "copy")) return;
+	if (!struct_is_copyable(struct, status)) return;
+	struct.functions.push(build_copy(struct, status));
+}
 //#endregion
 //#region ../src/check/check_block_node.ts
 function check_block_node(node, status) {
@@ -50502,8 +51642,8 @@ function check_function_parameter_node(param, status, is_library_scope = false)
 		if (param.type.is_pointer && !is_library_scope) add_error(status, `'ptr' parameters are reserved for the System library — raw pointer manipulation is not available to user code`, param.type_start ?? param.start);
 		instantiate_generic_type(param.type, status);
 	}
-	if (param.declaration === "var" && !param.is_moved && !param.is_self_param && !param.type.is_ref) add_error(status, `'var' parameters are not allowed — use 'ref' to mutate the caller's value (with 'ref' at the call site), or take it read-only and make a local 'var' copy`, param.start);
-	if (param.is_moved && param.type.name && !is_class_type$1(param.type.name, status) && !is_trait_type(param.type.name, status) && !is_owning_struct_type_requiring_move(param.type, status) && !status.type_params.includes(param.type.name) && !status.structs.some((s) => s.type_params.includes(param.type.name))) add_error(status, `move is only allowed for class, trait, or owning struct types, not '${param.type.name}'`, param.start);
+	if (param.declaration === "var" && !param.is_moved && !param.is_self_param && !param.type.is_ref && !is_pass_by_value_owning_struct(param.type, status)) add_error(status, `'var' parameters are not allowed — use 'ref' to mutate the caller's value (with 'ref' at the call site), or take it read-only and make a local 'var' copy`, param.start);
+	if (param.is_moved && param.type.name && !is_class_type$1(param.type.name, status) && !is_trait_type(param.type.name, status) && !is_owning_struct_type_requiring_move(param.type, status) && !is_pass_by_value_owning_struct(param.type, status) && !status.type_params.includes(param.type.name) && !status.structs.some((s) => s.type_params.includes(param.type.name))) add_error(status, `move is only allowed for class, trait, or owning struct types, not '${param.type.name}'`, param.start);
 	if (param.is_variadic && param.default_value) {
 		add_error(status, `Variadic parameter cannot have a default value`, param.start);
 		return;
@@ -50515,7 +51655,7 @@ function check_function_parameter_node(param, status, is_library_scope = false)
 	}
 	if (status.values.some((v) => v.name === param.name && v.declaration !== "const" && !(is_library_scope && v.is_global))) add_error(status, `Parameter already declared: ${param.name}`, param.start);
 	status.values.push({
-		declaration: param.declaration,
+		declaration: param.declaration === "var" || is_pass_by_value_owning_struct(param.type, status) ? "var" : param.declaration,
 		name: param.name,
 		type: param.type,
 		is_set: true,
@@ -50932,7 +52072,7 @@ function check_function_call_node(node, status) {
 		return false;
 	}
 	if (magic_ctor && spawn_ctor_shape) return check_magic_ctor(node, status, magic_ctor);
-	let func = find_free_function(status, node.name);
+	let func = status.values.findLast((v) => v.name === node.name && v.func_params !== void 0) ? void 0 : find_free_function(status, node.name);
 	if (func?.is_closure && func.captures?.length) func = void 0;
 	if (!func) {
 		const struct = resolve_declared_struct(node.name, status);
@@ -51001,6 +52141,10 @@ function check_function_call_node(node, status) {
 		const param_index = status.values.findLastIndex((v) => v.name === node.name);
 		const param_value = param_index >= 0 ? status.values[param_index] : void 0;
 		if (!!param_value && (param_value.type.name === "func" || param_value.func_params !== void 0 || param_value.func_return_type !== void 0) && param_value) {
+			if (param_value.is_null && !status.allow_null_value) {
+				add_error(status, `Variable '${node.name}' may be null`, node.start);
+				return false;
+			}
 			if (status.moved_variables?.has(node.name)) {
 				add_error(status, `Variable '${node.name}' used after move`, node.start);
 				return false;
@@ -51229,6 +52373,30 @@ function monomorphize(generic_struct, type_args, status) {
 		const init_func = new FunctionNode(generic_struct.start, "pub", "#init", init_return_type, init_params);
 		mono_struct.functions.push(init_func);
 	}
+	synthesize_copy_method(mono_struct, status);
+	const mono_copy = mono_struct.functions.find((f) => f.name === "copy");
+	if (mono_copy && !mono_copy.checked) {
+		mono_copy.scope = mono_struct;
+		check_function_node(mono_copy, {
+			stack: status.stack,
+			scope_depth: status.scope_depth,
+			types: status.types,
+			values: [],
+			function_value_base: 0,
+			structs: status.structs,
+			traits: status.traits,
+			enums: status.enums,
+			bitsets: status.bitsets,
+			functions: status.functions,
+			allocations: [],
+			var_name_counter: status.var_name_counter,
+			type_params: [],
+			errors: status.errors,
+			function_emission_names: status.function_emission_names,
+			allow_internal: status.allow_internal,
+			library_boundary: status.library_boundary
+		});
+	}
 	const root = status.stack[0];
 	if (!root.statements.some((s) => s.node_type === "struct" && s.name === mono_name)) root.statements.push(mono_struct);
 	return mono_struct;
@@ -51732,6 +52900,8 @@ function check_magic_ctor(node, status, name) {
 		add_error(status, `Spawned call '${call.name}' did not resolve`, node.start);
 		return false;
 	}
+	const spawned = call.resolved_function;
+	if (spawned) spawned.address_escaped = true;
 	validate_spawn_args_sendable(call, status);
 	stamp_spawn_ctor(node, name);
 	const return_type = call.type;
@@ -53318,6 +54488,13 @@ function check_function_call(node, status, func, target_type, self_value, self_p
 		const param_type = type_from_value_node(param, status);
 		const param_value = value_from_value_node(param);
 		const has_ref_keyword = node.ref_param_indices?.includes(i) ?? false;
+		if (func && func_param && func.has_body && (!func.scope || func.scope.node_type !== "struct") && !func.params.some((p) => p.is_self_param) && !func.address_escaped && !func_param.is_self_param && !func_param.is_variadic && !func_param.type.is_ref && !func_param.type.is_nullable && func_param.type.name && !is_owning_struct_type_requiring_move(func_param.type, status)) {
+			const owned_struct = status.structs.find((st) => st.name === func_param.type.name && !st.is_simple_type && !st.is_class);
+			if (owned_struct && !(owned_struct.traits ?? []).length && direct_string_fields(owned_struct).length > 0 && !struct_needs_destroy(owned_struct, status)) {
+				const indices = func_param.is_moved ? node.move_owned_param_indices ??= [] : node.owned_value_param_indices ??= [];
+				if (!indices.includes(i)) indices.push(i);
+			}
+		}
 		const has_mov_keyword = node.move_param_indices?.includes(i) ?? false;
 		if (func_param && func_param.type.name === "string" && !func_param.type.is_view && !func_param.type.is_array && param_type.name === "string" && param_type.is_view) add_error(status, `cannot pass a 'view string' to string parameter '${func_param.name}' — call .to_string() to materialize an owned copy`, param.start);
 		if (func_param.type.is_ref && !has_ref_keyword) add_error(status, `Missing 'ref' keyword for ref parameter '${func_param.name}'`, param.start);
@@ -53342,12 +54519,13 @@ function check_function_call(node, status, func, target_type, self_value, self_p
 			else if (!func_param.type.is_ref && (arg_is_stack_array_var || arg_is_literal) && elem_struct && !elem_struct.is_simple_type && !elem_struct.is_class && struct_has_string_fields(elem_struct, status)) add_error(status, `Cannot pass an array of owning value struct '${param_type.name}' (string fields) to 'Array<${param_type.name}>' parameter '${func_param.name}' — the materialised heap copy would share the element strings. Use 'List<${param_type.name}>' instead: its Buffer deep-copies owning elements soundly`, param.start);
 		}
 		const param_is_class = func_param.type.name && is_class_type$1(func_param.type.name, status);
-		const param_is_owning_struct = func_param.is_moved && !func_param.type.is_nullable && !!func_param.type.name && is_owning_struct_type_requiring_move(func_param.type, status);
+		const param_transfers = !!node.move_owned_param_indices?.includes(i);
+		const param_is_owning_struct = func_param.is_moved && !func_param.type.is_nullable && !!func_param.type.name && (is_owning_struct_type_requiring_move(func_param.type, status) || param_transfers);
 		const arg_is_owned_value = param.node_type === "value" && borrow_depth_of(param, status) === void 0;
 		if (func_param.is_moved && !has_mov_keyword && (param_is_class || param_is_owning_struct) && arg_is_owned_value) add_error(status, `Missing 'move' keyword for move parameter '${func_param.name}'`, param.start);
 		else if (!func_param.is_moved && has_mov_keyword) add_error(status, `Unexpected 'move' keyword for non-move parameter '${func_param.name}'`, param.start);
 		if (has_mov_keyword && param_value && !node.swap_params?.has(i)) {
-			if (func_param.type.name && (is_class_type$1(func_param.type.name, status) || func_param.is_moved && is_owning_struct_type_requiring_move(func_param.type, status))) {
+			if (func_param.type.name && (is_class_type$1(func_param.type.name, status) || func_param.is_moved && is_owning_struct_type(func_param.type, status))) {
 				if (!status.moved_variables) status.moved_variables = /* @__PURE__ */ new Set();
 				status.moved_variables.add(param_value);
 			}
@@ -53358,7 +54536,7 @@ function check_function_call(node, status, func, target_type, self_value, self_p
 			if (field_type.name && is_class_type$1(field_type.name, status)) {
 				const field_name = access.access.name;
 				add_error(status, `cannot move '${field_name}' out of struct — struct owns its class fields`, param.start);
-			} else if (field_type.name && !field_type.is_nullable && is_owning_struct_type_requiring_move(field_type, status)) {
+			} else if (field_type.name && !field_type.is_nullable && (is_owning_struct_type_requiring_move(field_type, status) || param_transfers && is_pass_by_value_owning_struct(field_type, status))) {
 				const field_name = access.access.name;
 				add_error(status, `cannot move '${field_name}' out of struct by value — it owns heap resources; use 'move ... swap <replacement>' to revalidate the field`, param.start);
 			}
@@ -53795,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;
@@ -54556,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;
@@ -54574,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);
@@ -54656,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);
@@ -54731,14 +55970,17 @@ function check_assignment_node(assign, status) {
 				return_type: fd?.func_return_type
 			};
 		}
-	} else if (lhs_value?.func_params?.length) lambda_signature = {
+	} else if (lhs_value?.func_params !== void 0) lambda_signature = {
 		params: lhs_value.func_params,
 		return_type: lhs_value.func_return_type
 	};
-	if (assign.right_value.node_type === "func" && lambda_signature.params && lambda_signature.params.length) {
+	if (assign.right_value.node_type === "func" && Array.isArray(lambda_signature.params)) {
+		if (!lhs_value && assign.left_value.node_type === "value") {
+			add_error(status, `cannot assign a lambda to '${lhs_value_name}' — the binding was initialized with a capture-free lambda and has no reassignable slot; declare it with '= null' (or from a named function) to reassign`, assign.right_value.start);
+			return false;
+		}
 		const rhs_func = assign.right_value;
-		if (assign.left_value.node_type === "value") rhs_func.name = lhs_value_name;
-		else if (!rhs_func.name) synthesize_lambda_name(rhs_func, status);
+		if (!rhs_func.name || assign.left_value.node_type === "value") synthesize_lambda_name(rhs_func, status);
 		if (rhs_func.params.length === lambda_signature.params.length) {
 			for (let i = 0; i < rhs_func.params.length; i++) if (!rhs_func.params[i].type.name && lambda_signature.params[i].type.name) rhs_func.params[i].type = lambda_signature.params[i].type;
 		}
@@ -55155,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"));
@@ -55181,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;
@@ -55233,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;
@@ -55970,6 +57239,8 @@ function check_spawn_node(node, status) {
 		add_error(status, "Spawned call did not resolve", node.start);
 		return false;
 	}
+	const spawned = node.call.resolved_function;
+	if (spawned) spawned.address_escaped = true;
 	for (const param of node.call.params) {
 		let arg_type = type_from_value_node(param, status);
 		const stamped = param.type;
@@ -56476,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);
@@ -56787,13 +58059,14 @@ function parse_type(status) {
 		type.type_args = void 0;
 	}
 	if (type.name === "Func" && type.type_args?.length) {
-		if (type.is_nullable || type.is_array || type.is_pointer || type.is_view || type.is_ref) {
-			add_error(status, `Func<...> cannot be combined with '?'/'[]'/'ptr'/'view'/'ref'`, start);
+		if (type.is_array || type.is_pointer || type.is_view || type.is_ref) {
+			add_error(status, `Func<...> cannot be combined with '[]'/'ptr'/'view'/'ref'`, start);
 			return type;
 		}
 		const args = type.type_args;
 		const func_type = new Type("func");
 		func_type.start = type.start;
+		if (type.is_nullable) func_type.is_nullable = true;
 		func_type.func_params = [];
 		for (let i = 0; i < args.length - 1; i++) {
 			if (args[i].name === "void") {
@@ -56906,10 +58179,14 @@ function default_visibility(status) {
 *   - a func RETURN carries its signature on the Type
 *     (`type.func_params` / `type.func_return_type`).
 */
-/** Whether the current token starts a nested func type: `func` immediately
-*  followed by `(` (the bare word `func` alone is the plain marker type). */
+/** Whether the current token starts a nested func type: `func` (optionally
+*  nullable, `func?`) immediately followed by `(` (the bare word `func` alone
+*  is the plain marker type). */
 function at_func_type(status) {
-	return peek_current(status) === "func" && status.tokens[status.i + 1]?.value === "(";
+	if (peek_current(status) !== "func") return false;
+	const next = status.tokens[status.i + 1]?.value;
+	if (next === "(") return true;
+	return next === "?" && status.tokens[status.i + 2]?.value === "(";
 }
 /**
 * Reject `void` where it has no meaning. Only the last type argument of
@@ -56930,6 +58207,7 @@ function reject_void_type(type, status, at) {
 function adopt_func_param_type(param, type) {
 	if (type.name !== "func") return false;
 	param.type = new Type("func");
+	param.type.is_nullable = type.is_nullable;
 	param.func_params = type.func_params;
 	param.func_return_type = type.func_return_type;
 	return true;
@@ -56952,11 +58230,13 @@ function parse_func_type_signature(param, status) {
 }
 /**
 * Parse a full nested func type — the `func` word is consumed by the caller
-* (at_func_type confirmed the `(` follows) — and return it as a Type whose
-* func_params/func_return_type carry the signature.
+* (at_func_type confirmed the `(` follows, possibly after a `?`) — and return
+* it as a Type whose func_params/func_return_type carry the signature. A
+* `func?` spelling marks the type nullable (it may hold `null`).
 */
 function parse_func_type(status) {
 	const type = new Type("func");
+	if (accept("?", status)) type.is_nullable = true;
 	const param = new ParameterNode(get_index(status), "");
 	parse_func_type_signature(param, status);
 	type.func_params = param.func_params;
@@ -56996,6 +58276,7 @@ function parse_signature_params(params, status) {
 		if (at_func_type(status)) {
 			consume(status);
 			param.type = new Type("func");
+			if (accept("?", status)) param.type.is_nullable = true;
 			parse_func_type_signature(param, status);
 		} else {
 			param.type = parse_type(status);
@@ -57036,7 +58317,11 @@ function parse_declaration(visibility, declaration, status, is_readonly = false)
 		if (is_func_alias) {
 			decl.func_params = decl.type.func_params ?? [];
 			decl.func_return_type = decl.type.func_return_type;
-			decl.type = new Type("");
+			if (decl.type.is_nullable) {
+				const nullable_marker = new Type("func");
+				nullable_marker.is_nullable = true;
+				decl.type = nullable_marker;
+			} else decl.type = new Type("");
 		}
 		if (peek_current(status) === "=" || status.i >= status.tokens.length) {
 			const modifier = status.tokens[saved_i]?.value;
@@ -57098,6 +58383,7 @@ function parse_declaration(visibility, declaration, status, is_readonly = false)
 }
 function parse_function_type_declaration(decl, status) {
 	accept("func", status);
+	const func_nullable = accept("?", status);
 	if (expect("(", status)) {
 		const params = [];
 		let return_type;
@@ -57110,6 +58396,10 @@ function parse_function_type_declaration(decl, status) {
 			decl.name = consume_name(status);
 			decl.func_params = params.filter((p) => !p.type.is_return_type);
 			decl.func_return_type = return_type;
+			if (func_nullable) {
+				decl.type = new Type("func");
+				decl.type.is_nullable = true;
+			}
 			const has_equals = accept("=", status);
 			if (peek_current(status) === "{") {
 				const func = new FunctionNode(get_index(status), default_visibility(status), decl.name, new Type(""));
@@ -57209,6 +58499,7 @@ function parse_anon_function_parameter(func, status) {
 	if (at_func_type(status)) {
 		consume(status);
 		param.type = new Type("func");
+		if (accept("?", status)) param.type.is_nullable = true;
 		parse_func_type_signature(param, status);
 		param.name_start = get_index(status);
 		param.name = consume_name(status);
@@ -57264,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);
@@ -57274,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;
@@ -57283,7 +58587,8 @@ function parse_destructuring(visibility, declaration, start, status) {
 		bindings.push({
 			name,
 			field,
-			rename
+			rename,
+			move
 		});
 		index++;
 		if (!accept(",", status)) break;
@@ -57313,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++) {
@@ -57323,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));
 	}
 }
@@ -58142,6 +59449,7 @@ function parse_function_parameter(parent, func, status) {
 		if (at_func_type(status)) {
 			consume(status);
 			param.type = new Type("func");
+			if (accept("?", status)) param.type.is_nullable = true;
 			parse_func_type_signature(param, status);
 			param.name_start = get_index(status);
 			param.name = consume_name(status);
@@ -59500,7 +60808,8 @@ nomen test
 function find_bundled(filename) {
 	const here = path.dirname(fileURLToPath(import.meta.url));
 	const cli_root = path.dirname(here);
-	const candidates = [path.join(cli_root, filename), path.join(cli_root, "..", filename)];
+	const repo_root = path.join(cli_root, "..");
+	const candidates = !cli_root.includes("node_modules") ? [path.join(repo_root, filename), path.join(cli_root, filename)] : [path.join(cli_root, filename), path.join(repo_root, filename)];
 	for (const c of candidates) if (fs.existsSync(c)) return path.resolve(c);
 }
 /**
@@ -59722,6 +61031,10 @@ function parse_records(stdout) {
 		other
 	};
 }
+/** Pull the exit-time audit "LEAK: N allocation(s)" lines out of stdout. */
+function extract_leaks(stdout) {
+	return stdout.split("\n").map((l) => l.trim()).filter((l) => l.startsWith("LEAK:"));
+}
 /**
 * Compile one `*.test.nm` file (with the generated harness) and run it,
 * returning its parsed records and any crash info.
@@ -59737,6 +61050,7 @@ function run_test_file(entry_path, lib_path, arch, audit = false, audit_runtime)
 		fails: [],
 		benches: [],
 		other: [],
+		leaks: [],
 		ms: 0
 	};
 	const resolved = path.resolve(entry_path);
@@ -59834,9 +61148,11 @@ function run_test_file(entry_path, lib_path, arch, audit = false, audit_runtime)
 	result.fails = records.fails;
 	result.benches = records.benches;
 	result.other = records.other;
+	result.leaks = audit ? extract_leaks(runStdout) : [];
+	if (result.leaks.length) result.other = result.other.filter((l) => !l.trim().startsWith("LEAK:"));
 	result.crashed = crashed;
 	if (crashed) result.phase = "run";
-	result.ok = !(result.fails.length > 0 || result.tests.some((t) => t.failed > 0)) && crashed === void 0;
+	result.ok = !(result.fails.length > 0 || result.tests.some((t) => t.failed > 0)) && crashed === void 0 && result.leaks.length === 0;
 	result.ms = performance.now() - start;
 	return result;
 }
@@ -59873,6 +61189,7 @@ function report_file(result) {
 	console.log(` ${mark} ${rel} ${C.dim(`(${totalTests} tests)`)} ${C.dim(format_duration(result.ms))}`);
 	if (result.crashed) console.log(C.red(`   ${result.crashed}`));
 	for (const f of result.fails) console.log(`   ${C.red("✗")} ${f.test} ${C.dim(">")} ${f.message}`);
+	for (const leak of result.leaks) console.log(`   ${C.yellow("⚠")} ${C.yellow(leak)}`);
 	for (const b of result.benches) console.log(`   ${C.cyan("⏱")} ${b.label} ${C.dim(`(n=${b.n})`)} ${C.dim("min")} ${fmt_ns(b.min)} ${C.dim("median")} ${fmt_ns(b.median)} ${C.dim("mean")} ${fmt_ns(Math.round(b.mean))} ${C.dim("max")} ${fmt_ns(b.max)} ${C.dim("±")} ${fmt_ns(Math.round(b.stddev))}`);
 	if (result.other.length) {
 		console.log(C.dim("   --- test stdout ---"));
@@ -59914,10 +61231,12 @@ function runTests(root, options = {}) {
 	const totalTests = results.reduce((a, r) => a + r.tests.length, 0);
 	const totalFailed = results.reduce((a, r) => a + r.tests.reduce((x, t) => x + t.failed, 0), 0);
 	const totalPassed = totalTests - totalFailed;
+	const totalLeaks = results.reduce((a, r) => a + r.leaks.length, 0);
 	const anyFailed = results.some((r) => !r.ok);
 	console.log("");
 	console.log(` ${C.dim("Files ")} ${C.green(`${totalFilesPassed} passed`)}` + (totalFilesFailed ? ` ${C.dim("|")} ${C.red(`${totalFilesFailed} failed`)}` : "") + C.dim(` (${totalFiles})`));
 	console.log(` ${C.dim("Tests ")} ${C.green(`${totalPassed} passed`)}` + (totalFailed ? ` ${C.dim("|")} ${C.red(`${totalFailed} failed`)}` : "") + C.dim(` (${totalTests})`));
+	if (totalLeaks) console.log(` ${C.dim("Leaks ")} ${C.yellow(`${totalLeaks} reported`)}` + C.dim(" (--audit; leaked files count as failures)"));
 	console.log(` ${C.dim(" Time ")} ${format_duration(elapsed)}`);
 	console.log("");
 	return !anyFailed;
@@ -60137,7 +61456,7 @@ function processFolder(folder, config, mode, program_args) {
 	const dir = fs.opendirSync(folder);
 	let dirent;
 	while ((dirent = dir.readSync()) !== null) if (shouldProcessFile(dirent.name)) {
-		processFile(path.join(folder, dirent.name), config, mode, program_args, false);
+		processFile(path.join(folder, dirent.name), config, mode, program_args);
 		fs.watch;
 	}
 	dir.closeSync();
@@ -60145,45 +61464,15 @@ function processFolder(folder, config, mode, program_args) {
 function shouldProcessFile(filename) {
 	return path.extname(filename) === SUPPORTED_EXTENSION;
 }
-/**
-* The project's entry file for `file_path`: walk up to the nearest
-* `package.jsonc` and resolve its `entry` field, so any file inside a project
-* is checked with the entry's import context (`import types` resolves
-* against the project's `src/`, not the file's own folder). Returns
-* undefined when the file is standalone, IS the entry, sits in an
-* entry-less project (e.g. a library checkout), or the config is malformed.
-*/
-function project_entry_for(file_path) {
-	let dir = path.dirname(file_path);
-	for (let i = 0; i < 20; i++) {
-		const config_path = path.join(dir, "package.jsonc");
-		if (fs.existsSync(config_path)) {
-			try {
-				const json = fs.readFileSync(config_path, "utf8").replace(/\/\/.*$/gm, "").replace(/\/\*[\s\S]*?\*\//g, "");
-				const parsed = JSON.parse(json);
-				if (parsed.entry) {
-					const entry = path.resolve(dir, parsed.entry);
-					if (entry !== file_path && fs.existsSync(entry)) return entry;
-				}
-			} catch {}
-			return;
-		}
-		const parent = path.dirname(dir);
-		if (parent === dir) return void 0;
-		dir = parent;
-	}
-}
-function processFile(filename, config, mode, program_args, anchor_to_project = true) {
+function processFile(filename, config, mode, program_args) {
 	console.log("Processing", filename);
 	const arch = config.arch || "aarch64";
 	const platform = config.platform || default_platform();
 	const resolved = path.resolve(filename);
 	if (!config.lib) config.lib = resolve_lib(resolved);
-	const anchor = anchor_to_project && !resolved.endsWith(".test.nm") ? project_entry_for(resolved) ?? resolved : resolved;
-	if (anchor !== resolved) console.log("Anchored to project entry", anchor);
 	let startTime = performance.now();
-	const input = join$1(anchor, config.lib);
-	const parsed = parse(input, config.lib ? get_library(config.lib) : void 0, anchor);
+	const input = join$1(resolved, config.lib);
+	const parsed = parse(input, config.lib ? get_library(config.lib) : void 0, resolved);
 	let errors = parsed.errors;
 	if (errors.length) {
 		console.log(render_errors(input, errors));