nomen-lang 0.6.6 → 0.6.8

package/dist/index.mjs

@@ -6811,6 +6811,27 @@ function find_enum(name, status) {
 }
 //#endregion
 //#region ../src/build_common/mono_name.ts
+/**
+* Whether `name` is a monomorphized owning-container struct whose
+* `<Mono>_copy` is safe to call from the owning-`Buffer.load_T`
+* specialization — `List_<T>` / `Buffer_<T>` (and their bare generics).
+* These own a heap slab their `#destroy` frees unconditionally, and `copy`
+* yields an independent slab, so a returned element's field must be
+* deep-copied or the caller's unconditional container-field teardown
+* double-frees the slot's slab.
+*
+* `Map`/`Set` are deliberately EXCLUDED from the automatic deep copy: their
+* monomorphized `copy` (which composes several `Buffer.copy` calls) is
+* verified standalone on both backends, but invoking it from the load
+* specialization corrupts the returned struct on aarch64 (a codegen
+* interaction still open — see FOLLOWUP.md). A `Map`/`Set` FIELD reached
+* through a container element's `load` therefore stays shallow (the
+* pre-existing bounded gap); an EXPLICIT `.copy()` on the owning struct or
+* the Map/Set itself works on both backends.
+*/
+function is_load_deep_copy_container(name) {
+	return name === "List" || name === "Buffer" || name.startsWith("List_") || name.startsWith("Buffer_");
+}
 function mono_type_name(type_or_name, type_args) {
 	const name = typeof type_or_name === "string" ? type_or_name : type_or_name.name;
 	const args = typeof type_or_name === "string" ? type_args : type_or_name.type_args;
@@ -7147,14 +7168,37 @@ function call_result_type(node) {
 * so `null == 0` conflates them. Nullable `string` (in-band fat zero) and
 * nullable `func`/class values (null pointer) keep their in-band null and
 * are NOT nullable scalars.
+*
+* The same holds for a nullable SIMPLE enum (`Color?`) or bitset
+* (`Permissions?`): the in-band zero (the first case's tag 0 / an empty
+* bitset) is a real value, so `null` needs the companion flag. Enum-with-data
+* and generic template enums are NOT nullable scalars — the checker rejects
+* `?` on enums with associated data, so every nullable enum that reaches the
+* backends is simple.
 */
-/** True if `type` is a nullable built-in scalar (`bool?`, `int?`, `float?`, …). */
-function is_nullable_scalar_type(type) {
+/** True if the TYPE NAME is a built-in scalar, simple enum, or bitset — the
+*  shapes that get the `<slot>_has` flag when nullable. */
+function is_nullable_scalar_name(name, tables) {
+	if (!name) return false;
+	const info = get_built_in_type(name);
+	if (info) return info.kind !== "string" && info.kind !== "func";
+	const enum_node = tables.enums.findLast((e) => (e.name === name || e.source_name === name) && !e.is_generic);
+	if (enum_node) return !enum_node.has_associated_data;
+	return tables.bitsets.some((b) => b.name === name || b.source_name === name);
+}
+/** True if `type` is a nullable built-in scalar, simple enum, or bitset. */
+function is_nullable_scalar_type(type, tables) {
 	if (!type?.is_nullable) return false;
 	if (type.is_array || type.is_ref || type.storage_kind === "view") return false;
 	if (type.is_pointer) return false;
-	const info = type.name ? get_built_in_type(type.name) : void 0;
-	return !!info && info.kind !== "string" && info.kind !== "func";
+	return is_nullable_scalar_name(type.name, tables);
+}
+/** True if `type` is a nullable struct (see nullable_struct.ts) or nullable scalar. */
+function is_nullable_flagged_type(type, status) {
+	if (!type?.is_nullable) return false;
+	if (type.name === "string") return false;
+	if (type.name === "func") return false;
+	return is_nullable_scalar_type(type, status) || !!status.structs.find((s) => s.name === type.name && !s.is_class && !s.is_simple_type);
 }
 //#endregion
 //#region ../src/build_common/nullable_struct.ts
@@ -7653,10 +7697,15 @@ function direct_string_fields(node) {
 * callee's own records are scope-local and die at return, so without the
 * transfer the stored copy leaks.
 *
-* Only DIRECT statements qualify: a store nested in a branch/loop may not
-* execute, and a record over the pre-call value would free it at the caller's
-* scope exit (possibly rodata — an invalid free). Memoized on the function
-* node; forwarding cycles are cut by a visited set (the cycle member's own
+* Only DIRECT statements qualify for the plain transfer: a store nested in a
+* branch/loop may not execute, and a record over the pre-call value would
+* free it at the caller's scope exit (possibly rodata — an invalid free).
+* Those CONDITIONAL stores are reported separately
+* (scan_ref_param_string_field_may_writes): the callee's function builder
+* emits an ENTRY DUP for each of them (`field = strdup(field)` at function
+* entry, recorded), which makes the field heap-owned on EVERY path and the
+* may-store record sound to transfer. Memoized on the function node;
+* forwarding cycles are cut by a visited set (the cycle member's own
 * contribution is skipped, bounded-leak).
 */
 function scan_ref_param_string_field_writes(func, structs) {
@@ -7664,6 +7713,51 @@ function scan_ref_param_string_field_writes(func, structs) {
 	if (stamp._ref_param_string_field_writes) return stamp._ref_param_string_field_writes;
 	const result = /* @__PURE__ */ new Map();
 	stamp._ref_param_string_field_writes = result;
+	const tracked = tracked_ref_params(func, structs);
+	if (tracked.size) scan_top_level(func.statements ?? [], tracked, structs, result);
+	return result;
+}
+/**
+* The CONDITIONAL (`may-executed`) ref-param field stores: direct stores
+* nested in if/else branches, switch cases, and loop bodies. Forwarded
+* calls from a nested position are deliberately EXCLUDED: a helper's store
+* builds with its own (fresh) record set, so it cannot reclaim the
+* displaced entry-dup — dup'ing for a forwarded store would trade the
+* old bounded leak for a new one. Those chains keep the documented
+* bounded-leak posture (the stored copy leaks, never an invalid free).
+* The function builder entry-dups these fields (see
+* ref_param_entry_dup_fields), making the may-store record transferable.
+*/
+function scan_ref_param_string_field_may_writes(func, structs) {
+	const stamp = func;
+	if (stamp._ref_param_string_field_may_writes) return stamp._ref_param_string_field_may_writes;
+	const result = /* @__PURE__ */ new Map();
+	stamp._ref_param_string_field_may_writes = result;
+	const tracked = tracked_ref_params(func, structs);
+	if (tracked.size) scan_nested(func.statements ?? [], tracked, result);
+	return result;
+}
+/**
+* The fields a function's builder must ENTRY DUP: the conditional
+* (may-executed) ref-param string-field stores that are NOT also
+* definitely-executed (a must-store already leaves the field heap-owned on
+* every path — dup'ing it too would just add a pointless strdup per call).
+* The dup runs at callee entry on both backends and records the field, so a
+* call site may transfer these as heap records soundly.
+*/
+function ref_param_entry_dup_fields(func, structs) {
+	const must = scan_ref_param_string_field_writes(func, structs);
+	const may = scan_ref_param_string_field_may_writes(func, structs);
+	const result = /* @__PURE__ */ new Map();
+	for (const [param, fields] of may) {
+		const dup = /* @__PURE__ */ new Set();
+		for (const field of fields) if (!must.get(param)?.has(field)) dup.add(field);
+		if (dup.size) result.set(param, dup);
+	}
+	return result;
+}
+/** The tracked ref params of `func`: name -> writable plain string fields. */
+function tracked_ref_params(func, structs) {
 	const tracked = /* @__PURE__ */ new Map();
 	for (const param of func.params ?? []) {
 		if (param.is_self_param) continue;
@@ -7672,8 +7766,7 @@ function scan_ref_param_string_field_writes(func, structs) {
 		const fields = ref_param_writable_fields(param.type.name, structs);
 		if (fields.size) tracked.set(param.name, fields);
 	}
-	if (tracked.size) scan_function(func, tracked, structs, result, /* @__PURE__ */ new Set());
-	return result;
+	return tracked;
 }
 /** The writable plain string fields of the value struct `type_name` resolves
 *  to, or the empty set (non-struct, class, or no string fields). */
@@ -7683,46 +7776,91 @@ function ref_param_writable_fields(type_name, structs) {
 	if (!struct) return /* @__PURE__ */ new Set();
 	return new Set(direct_string_fields(struct).map((f) => f.name));
 }
-function scan_function(func, tracked, structs, result, visiting) {
-	visiting.add(func);
-	for (const stmt of func.statements ?? []) {
+/**
+* The top-level (definitely-executed) walk: direct `param.field = …`
+* statements and top-level forwarded calls only — nothing nested.
+*/
+function scan_top_level(statements, tracked, structs, result) {
+	for (const stmt of statements) {
 		if (stmt.node_type === "assign") {
-			const lhs = stmt.left_value;
-			if (lhs?.node_type === "access") {
-				const access = lhs;
-				if (access.access.node_type === "access_field" && access.target.node_type === "value") {
-					const name = access.target.value ?? "";
-					const fields = tracked.get(name);
-					const field = access.access.name ?? "";
-					if (fields?.has(field)) {
-						if (!result.has(name)) result.set(name, /* @__PURE__ */ new Set());
-						result.get(name).add(field);
-					}
-				}
-			}
+			record_direct_store(stmt, tracked, result);
 			continue;
 		}
 		const call = ref_forward_call(stmt);
-		if (!call) continue;
-		const [callee, args] = call;
-		const non_self_params = (callee.params ?? []).filter((p) => !p.is_self_param);
-		for (let i = 0; i < args.length && i < non_self_params.length; i++) {
-			const arg = args[i];
-			if (arg?.node_type !== "value") continue;
-			const arg_name = arg.value ?? "";
-			const my_fields = tracked.get(arg_name);
-			if (!my_fields) continue;
-			const callee_param = non_self_params[i];
-			if (!(callee_param.is_ref || callee_param.type.is_ref)) continue;
-			if (visiting.has(callee)) continue;
-			const callee_writes = scan_ref_param_string_field_writes(callee, structs).get(callee_param.name);
-			if (!callee_writes?.size) continue;
-			if (!result.has(arg_name)) result.set(arg_name, /* @__PURE__ */ new Set());
-			const mine = result.get(arg_name);
-			for (const field of callee_writes) if (my_fields.has(field)) mine.add(field);
-		}
-	}
-	visiting.delete(func);
+		if (call) merge_forwarded(call, tracked, structs, result);
+	}
+}
+/**
+* The nested walk: direct stores at ANY depth below the top level are
+* may-stores. Forwarded calls are skipped everywhere (their contributions
+* would need cross-function displaced-value knowledge the callee's fresh
+* record set cannot carry — see the may-scan doc).
+*/
+function scan_nested(statements, tracked, result) {
+	for (const stmt of statements) {
+		if (stmt.node_type === "assign") {
+			record_direct_store(stmt, tracked, result);
+			continue;
+		}
+		for (const nested of nested_statement_lists(stmt)) scan_nested(nested, tracked, result);
+	}
+}
+/** Record a direct `param.<field> = …` store into `result`. */
+function record_direct_store(stmt, tracked, result) {
+	const lhs = stmt.left_value;
+	if (lhs?.node_type !== "access") return;
+	const access = lhs;
+	if (access.access.node_type !== "access_field" || access.target.node_type !== "value") return;
+	const name = access.target.value ?? "";
+	const fields = tracked.get(name);
+	const field = access.access.name ?? "";
+	if (!fields?.has(field)) return;
+	if (!result.has(name)) result.set(name, /* @__PURE__ */ new Set());
+	result.get(name).add(field);
+}
+/** Merge a forwarded call's callee stores for the forwarded param: the
+*  callee's MUST stores at a top-level position. */
+function merge_forwarded(call, tracked, structs, result) {
+	const [callee, args] = call;
+	const non_self_params = (callee.params ?? []).filter((p) => !p.is_self_param);
+	for (let i = 0; i < args.length && i < non_self_params.length; i++) {
+		const arg = args[i];
+		if (arg?.node_type !== "value") continue;
+		const arg_name = arg.value ?? "";
+		const my_fields = tracked.get(arg_name);
+		if (!my_fields) continue;
+		const callee_param = non_self_params[i];
+		if (!(callee_param.is_ref || callee_param.type.is_ref)) continue;
+		const source = scan_ref_param_string_field_writes(callee, structs).get(callee_param.name);
+		if (!source?.size) continue;
+		if (!result.has(arg_name)) result.set(arg_name, /* @__PURE__ */ new Set());
+		const mine = result.get(arg_name);
+		for (const field of source) if (my_fields.has(field)) mine.add(field);
+	}
+}
+/** The statement lists nested inside `stmt` (branch bodies, loop bodies) —
+*  the same walk scan_reassigned_vars uses. */
+function nested_statement_lists(stmt) {
+	const branch_of = (b) => b?.statements ?? [];
+	const lists = [];
+	if (stmt.node_type === "while" || stmt.node_type === "for") {
+		const nested = stmt.statements;
+		if (nested) lists.push(nested);
+		return lists;
+	}
+	if (stmt.node_type === "if") {
+		const n = stmt;
+		if (n.if_branch) lists.push(branch_of(n.if_branch));
+		if (n.else_branch) lists.push(branch_of(n.else_branch));
+		return lists;
+	}
+	if (stmt.node_type === "switch" || stmt.node_type === "match") {
+		const n = stmt;
+		for (const c of n.cases ?? []) if (c.branch) lists.push(branch_of(c.branch));
+		if (n.else_branch) lists.push(branch_of(n.else_branch));
+		return lists;
+	}
+	return lists;
 }
 /**
 * The forwarded-call shape of a top-level statement: a resolved free-function
@@ -7753,6 +7891,12 @@ function ref_forward_call(stmt) {
 * stores (scan_ref_param_string_field_writes) onto the caller's records for
 * the argument variable, making the caller's scope exit free them.
 *
+* The callee's CONDITIONAL stores transfer too
+* (ref_param_entry_dup_fields): the callee's builder entry-dups those
+* fields (`field = strdup(field)` at entry, recorded), so the field is
+* heap-owned on EVERY path out of the call — the not-taken path holds the
+* dup — and a caller-side record is sound.
+*
 * `arg_is_trackable_local` must report true only for variables whose storage
 * THIS function's scope exit owns — a plain local. A `ref` param of the
 * enclosing function forwards caller storage, so a record here would free the
@@ -7760,19 +7904,22 @@ function ref_forward_call(stmt) {
 */
 function transfer_ref_param_field_records(callee, args, status, arg_is_trackable_local) {
 	const writes = scan_ref_param_string_field_writes(callee, status.structs);
-	if (!writes.size) return;
+	const dups = ref_param_entry_dup_fields(callee, status.structs);
+	if (!writes.size && !dups.size) return;
 	const non_self_params = (callee.params ?? []).filter((p) => !p.is_self_param);
 	for (let i = 0; i < args.length && i < non_self_params.length; i++) {
 		const param = non_self_params[i];
 		if (!(param.is_ref || param.type.is_ref)) continue;
 		const fields = writes.get(param.name);
-		if (!fields?.size) continue;
+		const dup_fields = dups.get(param.name);
+		if (!fields?.size && !dup_fields?.size) continue;
 		const arg = args[i];
 		if (arg?.node_type !== "value") continue;
 		const name = arg.value;
 		if (!name || !arg_is_trackable_local(name)) continue;
 		if (!status.heap_string_fields) status.heap_string_fields = /* @__PURE__ */ new Set();
-		for (const field of fields) status.heap_string_fields.add(`${name}.${field}`);
+		for (const field of fields ?? []) status.heap_string_fields.add(`${name}.${field}`);
+		for (const field of dup_fields ?? []) status.heap_string_fields.add(`${name}.${field}`);
 	}
 }
 //#endregion
@@ -8084,7 +8231,7 @@ var AssignmentNode = class extends BaseNode {
 		super("assign", start);
 		this.left_value = left_value;
 		this.right_value = right_value;
-		this.operator = operator;
+		this.operator = operator === "=" ? void 0 : operator;
 	}
 };
 //#endregion
@@ -8265,7 +8412,7 @@ function is_container_borrow_accessor_name(name) {
 * site (see build_return_node), so it counts as owned for classification.
 */
 function is_call_site_borrow_accessor(fn_name) {
-	return fn_name === "at" || fn_name === "first";
+	return fn_name === "at" || fn_name === "first" || fn_name === "load";
 }
 /**
 * Whether `node` is a container/buffer borrow accessor CALL (an
@@ -12011,7 +12158,7 @@ function get_struct_size(name, status) {
 		size = align_to(size, get_type_alignment(field.type, status));
 		size += get_type_size(field.type, status);
 		if (is_nullable_struct_type(field.type, status)) size += 8;
-		else if (is_nullable_scalar_type(field.type)) size += 1;
+		else if (is_nullable_scalar_type(field.type, status)) size += 1;
 	}
 	size = align_to(size, 8);
 	return size;
@@ -12063,7 +12210,7 @@ function get_field_offset_of_fields(fields, field_name, status) {
 		if (field.name === field_name) return offset;
 		offset += get_type_size(field.type, status);
 		if (is_nullable_struct_type(field.type, status)) offset += 8;
-		else if (is_nullable_scalar_type(field.type)) offset += 1;
+		else if (is_nullable_scalar_type(field.type, status)) offset += 1;
 	}
 	return offset;
 }
@@ -17729,7 +17876,7 @@ function owning_buffer_element_aarch64(node, status) {
 	const elem_name = node.name.substring(7);
 	const elem = status.structs.find((s) => s.name === elem_name && !s.is_simple_type && !s.is_generic);
 	if (!elem || elem.is_class) return void 0;
-	if (!has_string_fields(elem, status)) return void 0;
+	if (!has_string_fields(elem, status) && !struct_needs_destroy(elem, status)) return void 0;
 	return elem;
 }
 /**
@@ -17875,6 +18022,75 @@ function collect_string_fields(elem, status, base_offset = 0) {
 	return result;
 }
 /**
+* Collect the (offset, size) pairs of every owned CONTAINER field (`List<T>`/
+* `Buffer<T>`/… mono with a `#destroy`) the element's teardown would reclaim.
+* The owning store_T/replace_T memcpy the source's bytes into the slot, so
+* zeroing these fields of the SOURCE completes the ownership transfer: the
+* slot is the sole owner and the source's own teardown (when it still runs)
+* finds zeroed fields. Nested value struct fields recurse so their container
+* leaves are zeroed at their own flat offsets; their string fields are
+* untouched (the slot owns the strdup'd copies via collect_string_fields).
+* Mirrors the C backend's `emit_transfer_owning_fields`. `view T`/nullable
+* fields are skipped; class/enum payload fields are left alone (recorded in
+* FOLLOWUP.md).
+*/
+function collect_transfer_fields(elem, status, base_offset = 0) {
+	const result = [];
+	let offset = 8;
+	for (const field of elem.fields) {
+		const size = get_type_size(field.type, status);
+		if (!field.type.is_ref && !field.type.is_view && !field.type.is_array && !field.type.is_nullable) {
+			const field_struct = resolve_struct_type(field.type, status);
+			if (field_struct && !field_struct.is_class) {
+				if (has_destroy(field_struct)) result.push({
+					offset: base_offset + offset,
+					size
+				});
+				else if (struct_needs_destroy(field_struct, status)) result.push(...collect_transfer_fields(field_struct, status, base_offset + offset));
+			}
+		}
+		offset += size;
+	}
+	return result;
+}
+/**
+* Emit `memset(&src.field, 0, size)` for every owned field collected by
+* `collect_transfer_fields`. `src` is the register holding the SOURCE struct
+* address (x2 inline / x21 standalone for store_T). Clobbers x0-x2.
+*/
+function emit_transfer_owning_fields$1(status, src, fields) {
+	for (const { offset, size } of fields) {
+		emit_asm(status, `add x0, ${src}, #${offset}\n`);
+		emit_asm(status, `mov x1, #0\n`);
+		emit_asm(status, `mov x2, #${size}\n`);
+		emit_asm(status, `bl _memset\n`);
+	}
+}
+/**
+* Emit the deep-copy half of owning load_T into the sret buffer (x8): for
+* each `List<T>` field whose mono has a `copy` method, replace the
+* shallow-copied field with `<List_T>_copy(&slot.field)` (sret → the sret
+* buffer's field; self == x8 is safe — the copy reads its input before the
+* final result write). Mirrors the C backend's `emit_load_deep_copy_fields`.
+* `sret` is the register holding the returned struct's address; `slot` holds
+* the source slot's address (the copy reads from the slot, writes to sret).
+*/
+function emit_load_deep_copy_fields$1(elem, status, sret, slot) {
+	let offset = 8;
+	for (const field of elem.fields) {
+		const size = get_type_size(field.type, status);
+		if (!field.type.is_ref && !field.type.is_view && !field.type.is_array && !field.type.is_nullable && field.type.name !== "string") {
+			const field_struct = resolve_struct_type(field.type, status);
+			if (field_struct && !field_struct.is_class && is_load_deep_copy_container(field_struct.name) && struct_needs_destroy(field_struct, status) && field_struct.functions.find((f) => f.name === "copy")) {
+				emit_asm(status, `add x8, ${sret}, #${offset}\n`);
+				emit_asm(status, `add x0, ${slot}, #${offset}\n`);
+				emit_asm(status, `bl ${field_struct.name}_copy\n`);
+			}
+		}
+		offset += size;
+	}
+}
+/**
 * Emit `slot.field = strdup(src.field)` guarded against a NULL source field
 * (e.g. JsonTree's "no text" sentinel): a NULL field is copied as NULL —
 * strdup(NULL) would crash. `src`/`dst` are the register names holding the
@@ -17912,6 +18128,10 @@ function emit_owning_buffer_inline_aarch64(struct_node, func_name, status) {
 			emit_owning_shift_T(elem, status, "x0");
 			return true;
 		}
+		if (func_name === "load") {
+			emit_owning_load_T(elem, status, "x0");
+			return true;
+		}
 		return false;
 	}
 	const enum_elem = owning_buffer_enum_element_aarch64(struct_node, status);
@@ -17973,7 +18193,7 @@ function emit_owning_buffer_inline_aarch64(struct_node, func_name, status) {
 function emit_owning_buffer_standalone_aarch64(node, func_name, status) {
 	const elem = owning_buffer_element_aarch64(node, status);
 	if (elem) {
-		if (func_name !== "store" && func_name !== "replace" && func_name !== "shift" && func_name !== "modify") return false;
+		if (func_name !== "store" && func_name !== "replace" && func_name !== "shift" && func_name !== "modify" && func_name !== "load") return false;
 		emit_owning_standalone_struct(elem, func_name, status);
 		return true;
 	}
@@ -18032,6 +18252,7 @@ function emit_owning_buffer_standalone_aarch64(node, func_name, status) {
 function emit_owning_standalone_struct(elem, func_name, status) {
 	const T_SIZE = get_struct_size(elem.name, status);
 	const string_fields = collect_string_fields(elem, status);
+	const transfer_fields = collect_transfer_fields(elem, status);
 	if (func_name === "shift") {
 		emit_owning_shift_T(elem, status, "x19");
 		return true;
@@ -18040,6 +18261,23 @@ function emit_owning_standalone_struct(elem, func_name, status) {
 		emit_owning_modify_T(elem, status, T_SIZE, string_fields);
 		return true;
 	}
+	if (func_name === "load") {
+		emit_asm(status, `stp x20, x21, [sp, #-16]!\n`);
+		emit_asm(status, `stp x22, x23, [sp, #-16]!\n`);
+		emit_asm(status, `ldr x20, [x19, #8]\n`);
+		emit_asm(status, `mov x9, #${T_SIZE}\n`);
+		emit_asm(status, `madd x21, x1, x9, x20\n`);
+		emit_asm(status, `mov x22, x8\n`);
+		emit_asm(status, `mov x0, x22\n`);
+		emit_asm(status, `mov x1, x21\n`);
+		emit_asm(status, `mov x2, x9\n`);
+		emit_asm(status, `bl _memcpy\n`);
+		emit_load_deep_copy_fields$1(elem, status, "x22", "x21");
+		emit_asm(status, `mov x0, x22\n`);
+		emit_asm(status, `ldp x22, x23, [sp], #16\n`);
+		emit_asm(status, `ldp x20, x21, [sp], #16\n`);
+		return true;
+	}
 	emit_asm(status, `stp x20, x21, [sp, #-16]!\n`);
 	emit_asm(status, `str x22, [sp, #-16]!\n`);
 	emit_asm(status, `ldr x20, [x19, #8]\n`);
@@ -18077,6 +18315,7 @@ function emit_owning_standalone_struct(elem, func_name, status) {
 		}
 		if (string_fields.length) emit_asm(status, `add sp, sp, #${Math.ceil(string_fields.length * 8 / 16) * 16}\n`);
 	} else for (const { offset: foff } of string_fields) emit_strdup_field(status, "x21", "x20", foff, status.label_counter = (status.label_counter ?? 0) + 1);
+	emit_transfer_owning_fields$1(status, "x21", transfer_fields);
 	emit_asm(status, `ldr x22, [sp], #16\n`);
 	emit_asm(status, `ldp x20, x21, [sp], #16\n`);
 	return true;
@@ -18278,9 +18517,35 @@ function emit_owning_shift_T(elem, status, self_reg) {
 	emit_asm(status, `ldr x22, [sp], #16\n`);
 	emit_asm(status, `ldp x20, x21, [sp], #16\n`);
 }
+/**
+* Specialized owning-value-struct load_T (inline context: x0 = self, x1 = i,
+* x8 = sret). The caller's scope-exit destroy ALWAYS reclaims a struct
+* local's container fields, so the returned copy must own independent
+* containers — a shallow return would double-free the slot's buffer at the
+* caller's teardown. String fields stay borrowed (struct-local teardown only
+* frees RECORDED heap strings, so a strdup here would leak).
+*/
+function emit_owning_load_T(elem, status, self_reg) {
+	const T_SIZE = get_struct_size(elem.name, status);
+	emit_asm(status, `stp x20, x21, [sp, #-16]!\n`);
+	emit_asm(status, `stp x22, x23, [sp, #-16]!\n`);
+	emit_asm(status, `ldr x20, [${self_reg}, #8]\n`);
+	emit_asm(status, `mov x9, #${T_SIZE}\n`);
+	emit_asm(status, `madd x21, x1, x9, x20\n`);
+	emit_asm(status, `mov x22, x8\n`);
+	emit_asm(status, `mov x0, x22\n`);
+	emit_asm(status, `mov x1, x21\n`);
+	emit_asm(status, `mov x2, x9\n`);
+	emit_asm(status, `bl _memcpy\n`);
+	emit_load_deep_copy_fields$1(elem, status, "x22", "x21");
+	emit_asm(status, `mov x0, x22\n`);
+	emit_asm(status, `ldp x22, x23, [sp], #16\n`);
+	emit_asm(status, `ldp x20, x21, [sp], #16\n`);
+}
 function emit_owning_store_T(elem, status) {
 	const T_SIZE = get_struct_size(elem.name, status);
 	const string_fields = collect_string_fields(elem, status);
+	const transfer_fields = collect_transfer_fields(elem, status);
 	emit_asm(status, `stp x20, x21, [sp, #-16]!\n`);
 	emit_asm(status, `str x22, [sp, #-16]!\n`);
 	emit_asm(status, `ldr x20, [x0, #8]\n`);
@@ -18312,12 +18577,14 @@ function emit_owning_store_T(elem, status) {
 		emit_asm(status, `${lbl}:\n`);
 	}
 	if (string_fields.length) emit_asm(status, `add sp, sp, #${Math.ceil(string_fields.length * 8 / 16) * 16}\n`);
+	emit_transfer_owning_fields$1(status, "x21", transfer_fields);
 	emit_asm(status, `ldr x22, [sp], #16\n`);
 	emit_asm(status, `ldp x20, x21, [sp], #16\n`);
 }
 function emit_owning_replace_T(elem, status) {
 	const T_SIZE = get_struct_size(elem.name, status);
 	const string_fields = collect_string_fields(elem, status);
+	const transfer_fields = collect_transfer_fields(elem, status);
 	emit_asm(status, `stp x20, x21, [sp, #-16]!\n`);
 	emit_asm(status, `str x22, [sp, #-16]!\n`);
 	emit_asm(status, `ldr x20, [x0, #8]\n`);
@@ -18332,6 +18599,7 @@ function emit_owning_replace_T(elem, status) {
 	emit_asm(status, `mov x2, x22\n`);
 	emit_asm(status, `bl _memcpy\n`);
 	for (const { offset: foff } of string_fields) emit_strdup_field(status, "x21", "x20", foff, status.label_counter = (status.label_counter ?? 0) + 1);
+	emit_transfer_owning_fields$1(status, "x21", transfer_fields);
 	emit_asm(status, `ldr x22, [sp], #16\n`);
 	emit_asm(status, `ldp x20, x21, [sp], #16\n`);
 }
@@ -19996,7 +20264,7 @@ function build_function_node$1(node, status) {
 	status.code = "";
 	node.return_type = resolve_mono_type(node.return_type, status);
 	const return_struct = !node.return_type.is_view && !node.return_type.is_array && (!!status.structs.find((s) => s.name === node.return_type.name && !s.is_simple_type && !s.is_class) || get_enum_sret_size(node.return_type.name, status) !== void 0);
-	const nullable_scalar_ret = is_nullable_scalar_type(node.return_type) && !node.return_type.is_ref;
+	const nullable_scalar_ret = is_nullable_scalar_type(node.return_type, status) && !node.return_type.is_ref;
 	const uses_sret = return_struct || nullable_scalar_ret;
 	if (uses_sret) status.struct_return_buffer = "x8";
 	status.function_return_type = node.return_type;
@@ -20083,7 +20351,7 @@ function build_function_node$1(node, status) {
 				first_pass_slot += 2;
 				continue;
 			}
-			if (is_nullable_scalar_type(param.type)) {
+			if (is_nullable_scalar_type(param.type, status)) {
 				first_pass_slot += 2;
 				continue;
 			}
@@ -20250,7 +20518,7 @@ function build_function_node$1(node, status) {
 				param_idx += 2;
 				continue;
 			}
-			if (is_nullable_scalar_type(param.type) && !param.type.is_ref && !param.type.is_array) {
+			if (is_nullable_scalar_type(param.type, status) && !param.type.is_ref && !param.type.is_array) {
 				const size = aarch64_size(param.type.name);
 				const offset = allocate_stack_space(status, size, size);
 				status.stack_offsets.set(param.name, offset);
@@ -20467,6 +20735,7 @@ function build_function_node$1(node, status) {
 	} else status.nir_emit_ctx = void 0;
 	const old_raw_param_reloads = status.raw_param_reloads;
 	install_raw_reload_plan(status, raw_reload_plan_lines);
+	emit_ref_param_entry_dups$1(node, status);
 	try {
 		build_block_node$1(node, status);
 	} finally {
@@ -20612,6 +20881,49 @@ function build_function_node$1(node, status) {
 	status.return_buffer_stack_offset = void 0;
 	status.function_return_type = void 0;
 }
+/**
+* Entry-dup the ref-param string fields the body stores through
+* CONDITIONALLY (see ref_param_entry_dup_fields): load the field pair's
+* ptr half, strdup it, store the fresh pointer back — with the field
+* recorded in heap_string_fields — so the field is heap-owned on every
+* path out of the function and the call-site record transfer is sound.
+* Mirrors the C backend's emit_ref_param_entry_dups; the len half is
+* unchanged by a dup, so only the ptr half is rewritten. A nullable
+* string field guards the dup (strdup(NULL) traps; a null pair stores as
+* null and every reclaim path no-ops on free(NULL)).
+*/
+function emit_ref_param_entry_dups$1(node, status) {
+	const dups = ref_param_entry_dup_fields(node, status.structs);
+	if (!dups.size) return;
+	for (const param of node.params ?? []) {
+		if (param.is_self_param) continue;
+		if (!(param.is_ref || param.type.is_ref)) continue;
+		const fields = dups.get(param.name);
+		if (!fields?.size) continue;
+		const struct = status.structs.find((s) => s.name === param.type.name && !s.is_simple_type && !s.is_class);
+		for (const field of fields) {
+			const offset = get_field_offset(param.type.name, field, status);
+			const paramReg = status.function_param_regs?.get(param.name);
+			if (paramReg) emit_asm(status, `mov x0, ${paramReg}\n`);
+			else if (is_local_ref_var(param.name, status)) emit_deref_var_address(status, "x0", param.name);
+			else emit_var_address(status, "x0", param.name);
+			emit_asm(status, `str x0, [sp, #-16]!\n`);
+			emit_asm(status, `ldr x0, [x0, #${offset}]\n`);
+			const nullable = !!struct?.fields.find((f) => f.name === field)?.type.is_nullable;
+			let skip_label;
+			if (nullable) {
+				skip_label = `.Lentry_dup_${status.label_counter = (status.label_counter ?? 0) + 1}`;
+				emit_asm(status, `cbz x0, ${skip_label}\n`);
+			}
+			emit_strdup(status);
+			if (skip_label) emit_asm(status, `${skip_label}:\n`);
+			emit_asm(status, `ldr x1, [sp], #16\n`);
+			emit_asm(status, `str x0, [x1, #${offset}]\n`);
+			if (!status.heap_string_fields) status.heap_string_fields = /* @__PURE__ */ new Set();
+			status.heap_string_fields.add(`${param.name}.${field}`);
+		}
+	}
+}
 //#endregion
 //#region ../src/build_aarch64/build_struct_node.ts
 let field_strdup_guard_counter = 0;
@@ -20666,7 +20978,7 @@ function init_enum_shorthand_field_default(node, field, base_reg, status) {
 * struct base register (`x0` for auto-init, `x19` for custom-init).
 */
 function init_nullable_field_default(node, field, base_reg, status) {
-	const scalar_nullable = is_nullable_scalar_type(field.type);
+	const scalar_nullable = is_nullable_scalar_type(field.type, status);
 	if (!is_nullable_struct_type(field.type, status) && !scalar_nullable) return false;
 	if (!field.value) return false;
 	const offset = get_field_offset(node.name, field.name, status);
@@ -21008,7 +21320,7 @@ function build_init_function(node, status) {
 		const slot = ctor_slot;
 		const field_is_view = !!field.type.is_view && !field.type.is_array;
 		const field_is_fat_string = field.type.name === "string" && !field.type.is_view && !field.type.is_ref && !field.type.is_array;
-		const field_is_nullable_scalar = is_nullable_scalar_type(field.type);
+		const field_is_nullable_scalar = is_nullable_scalar_type(field.type, status);
 		if (field_is_view || field_is_fat_string || field_is_nullable_scalar) ctor_slot += 2;
 		else ctor_slot += 1;
 		let src_reg;
@@ -21186,9 +21498,9 @@ function build_init_function(node, status) {
 			if (node.fields.find((nf) => nf.name === field.name)) continue;
 			const offset = get_field_offset(node.name, field.name, status);
 			const val = field.value.node_type === "value" ? field.value.value : void 0;
-			if (val === "null" && (is_nullable_scalar_type(field.type) || is_nullable_struct_type(field.type, status))) {
+			if (val === "null" && (is_nullable_scalar_type(field.type, status) || is_nullable_struct_type(field.type, status))) {
 				const has_off = get_field_has_offset(node.name, field.name, status);
-				if (is_nullable_scalar_type(field.type)) emit_asm(status, `strb wzr, [x19, #${has_off}]\n`);
+				if (is_nullable_scalar_type(field.type, status)) emit_asm(status, `strb wzr, [x19, #${has_off}]\n`);
 				else emit_asm(status, `str xzr, [x19, #${has_off}]\n`);
 				continue;
 			}
@@ -21329,7 +21641,7 @@ function build_custom_init_function(node, func, status) {
 			param_idx += 2;
 			continue;
 		}
-		if (is_nullable_scalar_type(param.type) && !param.type.is_ref && !param.type.is_array) {
+		if (is_nullable_scalar_type(param.type, status) && !param.type.is_ref && !param.type.is_array) {
 			const size = aarch64_size(param.type.name);
 			const offset = allocate_stack_space(status, size, size);
 			status.stack_offsets.set(param.name, offset);
@@ -21620,7 +21932,7 @@ function build_struct_functions$1(node, status) {
 		status.function_view_params = /* @__PURE__ */ new Set();
 		status.struct_return_buffer = void 0;
 		const return_struct = !func.return_type?.is_array && (!!status.structs.find((s) => s.name === func.return_type?.name && !s.is_simple_type && !s.is_class) || get_enum_sret_size(func.return_type?.name, status) !== void 0);
-		const nullable_scalar_ret = !!func.return_type && is_nullable_scalar_type(func.return_type) && !func.return_type.is_ref;
+		const nullable_scalar_ret = !!func.return_type && is_nullable_scalar_type(func.return_type, status) && !func.return_type.is_ref;
 		const uses_sret = return_struct || nullable_scalar_ret;
 		let return_buffer_stack_offset;
 		status.current_function_name = func.name;
@@ -21647,7 +21959,7 @@ function build_struct_functions$1(node, status) {
 				slot_idx += 2;
 				continue;
 			}
-			if (is_nullable_scalar_type(param.type) && !param.type.is_ref) {
+			if (is_nullable_scalar_type(param.type, status) && !param.type.is_ref) {
 				if (param.declaration === "var") status.function_param_vars.add(param.name);
 				slot_idx += 2;
 				continue;
@@ -21730,7 +22042,7 @@ function build_struct_functions$1(node, status) {
 				second_slot_idx += 2;
 				continue;
 			}
-			if (is_nullable_scalar_type(param.type) && !param.type.is_ref) {
+			if (is_nullable_scalar_type(param.type, status) && !param.type.is_ref) {
 				const size = aarch64_size(param.type.name);
 				const offset = allocate_stack_space(status, size, size);
 				status.stack_offsets.set(param.name, offset);
@@ -23189,11 +23501,11 @@ function build_constructor_params(fc, param_regs, status) {
 		let nullable_scalar = false;
 		if (fc.nullable_param_indices?.includes(i)) {
 			const cp = ctor_callee_params?.[i];
-			if (cp && is_nullable_scalar_type(cp.type)) nullable_scalar = true;
-			else if (is_nullable_scalar_type(p.type)) nullable_scalar = true;
+			if (cp && is_nullable_scalar_type(cp.type, status)) nullable_scalar = true;
+			else if (is_nullable_scalar_type(p.type, status)) nullable_scalar = true;
 			else if (!cp) {
 				const field = (status.structs.find((s) => s.name === fc.name && !s.is_simple_type)?.fields.filter((f) => f.value == null))?.[i];
-				if (field && is_nullable_scalar_type(field.type)) nullable_scalar = true;
+				if (field && is_nullable_scalar_type(field.type, status)) nullable_scalar = true;
 			}
 		}
 		const is_pair = pt === "string" || lit || is_view || nullable_scalar;
@@ -23220,7 +23532,7 @@ function build_constructor_params(fc, param_regs, status) {
 			if (arg.node_type === "value" && arg.value === "null") {
 				emit_asm(status, `mov x0, #0\n`);
 				emit_asm(status, `mov x1, #0\n`);
-			} else if (arg.node_type === "value" && is_nullable_scalar_type(arg.type)) {
+			} else if (arg.node_type === "value" && is_nullable_scalar_type(arg.type, status)) {
 				const vname = arg.value;
 				emit_var_load(status, "x0", vname, aarch64_size(arg.type.name));
 				emit_var_load(status, "x1", has_flag_name(vname), 8);
@@ -23610,7 +23922,7 @@ function build_declaration_node$1(node, status, nir_init, nir_swap) {
 		emit_var_store(status, "x0", node.name, 8);
 		return;
 	}
-	if (is_nullable_scalar_type(node.type)) {
+	if (is_nullable_scalar_type(node.type, status)) {
 		if (status.function_return_label) {
 			const offset = allocate_stack_space(status, 16, 16);
 			status.stack_offsets.set(node.name, offset);
@@ -23621,14 +23933,23 @@ function build_declaration_node$1(node, status, nir_init, nir_swap) {
 			}
 			const init_value = node.value;
 			const init_type = call_result_type(init_value) ?? type_from_value_node$1(init_value);
-			const value_is_nullable_call = init_value.node_type === "func_call" && is_nullable_scalar_type(init_type);
-			if (init_value.node_type === "access" && is_nullable_scalar_type(init_type)) {
+			const value_is_nullable_call = init_value.node_type === "func_call" && is_nullable_scalar_type(init_type, status);
+			const value_is_nullable_method = init_value.node_type === "access" && init_value.access.node_type === "access_func" && is_nullable_scalar_type(init_type, status);
+			const value_is_nullable_field = init_value.node_type === "access" && init_value.access.node_type === "access_field" && is_nullable_scalar_type(init_type, status);
+			if (value_is_nullable_method) {
 				emit_init_value$1(init_value, nir_init, status);
 				ensure_newline(status);
 				emit_asm(status, `ldr x9, [x0]\n`);
 				emit_asm(status, `str x9, [x29, #${offset}]\n`);
 				emit_asm(status, `ldr x9, [x0, #8]\n`);
 				emit_asm(status, `str x9, [x29, #${offset + 8}]\n`);
+			} else if (value_is_nullable_field) {
+				emit_init_value$1(init_value, nir_init, status);
+				ensure_newline(status);
+				emit_var_store(status, "x0", node.name, 8);
+				load_nullable_has(init_value, "x9", status);
+				ensure_newline(status);
+				emit_asm(status, `str x9, [x29, #${offset + 8}]\n`);
 			} else if (value_is_nullable_call) {
 				const old_buffer = status.struct_return_buffer;
 				const old_buffer_var = status.struct_return_buffer_var;
@@ -23650,8 +23971,13 @@ function build_declaration_node$1(node, status, nir_init, nir_swap) {
 			}
 			return;
 		}
-		emit_data(status, `${node.name}: .space 16\n`);
-		status.stack_offsets.set(has_flag_name(node.name), -1);
+		const global_is_null = !node.value || node.value.node_type === "value" && node.value.value === "null";
+		if (global_is_null) emit_data(status, `${node.name}: .space 8\n`);
+		else {
+			emit_data(status, `${node.name}: ${aarch64_type(node.type.name)} ${get_raw_value$1(node.value, status)}\n`);
+			if (aarch64_size(node.type.name) < 8) emit_data(status, `.p2align 3\n`);
+		}
+		emit_data(status, `${has_flag_name(node.name)}: .quad ${global_is_null ? 0 : 1}\n`);
 		return;
 	}
 	const directive = aarch64_type(node.type.name);
@@ -23839,6 +24165,14 @@ function build_declaration_node$1(node, status, nir_init, nir_swap) {
 						if (element_size === 1) emit_asm(status, `strb w0, [x9, #${slot}]\n`);
 						else if (element_size === 4) emit_asm(status, `str w0, [x9, #${slot}]\n`);
 						else emit_asm(status, `str x0, [x9, #${slot}]\n`);
+					} else if (element_size > 8 && struct_element && !struct_element.is_class) {
+						emit_struct_address_param(value, status);
+						ensure_newline(status);
+						emit_asm(status, `ldr x9, [x29, #${offset}]\n`);
+						emit_asm(status, `mov x1, x0\n`);
+						emit_asm(status, `add x0, x9, #${slot}\n`);
+						emit_asm(status, `mov x2, #${element_size}\n`);
+						emit_asm(status, `bl _memcpy\n`);
 					} else {
 						emit_init_value$1(value, nir_array_element(nir_init, array_literal_node, i), status);
 						ensure_newline(status);
@@ -23878,6 +24212,14 @@ function build_declaration_node$1(node, status, nir_init, nir_swap) {
 						if (element_size === 1) emit_asm(status, `strb w0, [x9, #${slot}]\n`);
 						else if (element_size === 4) emit_asm(status, `str w0, [x9, #${slot}]\n`);
 						else emit_asm(status, `str x0, [x9, #${slot}]\n`);
+					} else if (element_size > 8 && struct_element && !struct_element.is_class) {
+						emit_struct_address_param(value, status);
+						ensure_newline(status);
+						emit_asm(status, `ldr x9, [${node.name}]\n`);
+						emit_asm(status, `mov x1, x0\n`);
+						emit_asm(status, `add x0, x9, #${slot}\n`);
+						emit_asm(status, `mov x2, #${element_size}\n`);
+						emit_asm(status, `bl _memcpy\n`);
 					} else {
 						emit_init_value$1(value, nir_array_element(nir_init, array_literal_node, i), status);
 						ensure_newline(status);
@@ -23984,6 +24326,13 @@ function build_declaration_node$1(node, status, nir_init, nir_swap) {
 								if (element_size === 1) emit_asm(status, `strb w0, [x29, #${slot_offset}]\n`);
 								else if (element_size === 4) emit_asm(status, `str w0, [x29, #${slot_offset}]\n`);
 								else emit_asm(status, `str x0, [x29, #${slot_offset}]\n`);
+							} else if (element_size > 8 && struct_element && !struct_element.is_class) {
+								emit_struct_address_param(value, status);
+								ensure_newline(status);
+								emit_asm(status, `mov x1, x0\n`);
+								emit_asm(status, `add x0, x29, #${slot_offset}\n`);
+								emit_asm(status, `mov x2, #${element_size}\n`);
+								emit_asm(status, `bl _memcpy\n`);
 							} else {
 								emit_init_value$1(value, nir_array_element(nir_init, array_values, i), status);
 								ensure_newline(status);
@@ -24009,6 +24358,13 @@ function build_declaration_node$1(node, status, nir_init, nir_swap) {
 								if (element_size === 1) emit_asm(status, `strb w0, [${node.name} + ${i * element_size}]\n`);
 								else if (element_size === 4) emit_asm(status, `str w0, [${node.name} + ${i * element_size}]\n`);
 								else emit_asm(status, `str x0, [${node.name} + ${i * element_size}]\n`);
+							} else if (element_size > 8 && struct_element && !struct_element.is_class) {
+								emit_struct_address_param(value, status);
+								ensure_newline(status);
+								emit_asm(status, `mov x1, x0\n`);
+								emit_global_slot_addr(status, node.name, i * element_size);
+								emit_asm(status, `mov x2, #${element_size}\n`);
+								emit_asm(status, `bl _memcpy\n`);
 							} else {
 								emit_init_value$1(value, nir_array_element(nir_init, array_values, i), status);
 								ensure_newline(status);
@@ -26115,7 +26471,7 @@ function build_return_node$1(node, status, nir_value) {
 	hoist_field_overrides(node.value, build_node, status);
 	if (node.from_inline) return;
 	const returns_nullable_struct = is_nullable_struct_type(status.function_return_type, status);
-	const returns_nullable_scalar = is_nullable_scalar_type(status.function_return_type);
+	const returns_nullable_scalar = is_nullable_scalar_type(status.function_return_type, status);
 	if ((returns_nullable_struct || returns_nullable_scalar) && (!node.value || node.value.node_type === "value" && node.value.value === "null")) {
 		if (status.return_buffer_stack_offset !== void 0) {
 			const struct_size = get_struct_size(status.function_return_type.name, status);
@@ -26305,7 +26661,7 @@ function build_return_node$1(node, status, nir_value) {
 		if (status.return_buffer_stack_offset !== void 0) emit_asm(status, `ldr x8, [x29, #${status.return_buffer_stack_offset}]\n`);
 		emit_typed_store(status, "x0", "x8", 0, aarch64_size(status.function_return_type.name));
 		const value_type = node.value ? type_from_value_node$1(node.value) : void 0;
-		if (node.value && value_type?.is_nullable && is_nullable_scalar_type(value_type)) {
+		if (node.value && value_type?.is_nullable && is_nullable_scalar_type(value_type, status)) {
 			load_nullable_has(node.value, "x9", status);
 			ensure_newline(status);
 			emit_asm(status, `str x9, [x8, #8]\n`);
@@ -29935,7 +30291,7 @@ function build_function_call_node$1(node, status) {
 				if (!node.nullable_param_indices?.includes(i)) continue;
 				const arg_type = node.params[i].type;
 				const callee_param = node.resolved_function?.params?.[i];
-				if (is_nullable_scalar_type(arg_type) || callee_param && is_nullable_scalar_type(callee_param.type)) nullable_scalar_arg_set.add(i);
+				if (is_nullable_scalar_type(arg_type, status) || callee_param && is_nullable_scalar_type(callee_param.type, status)) nullable_scalar_arg_set.add(i);
 			}
 			const arg_slot = [];
 			let total_slots = 0;
@@ -30033,7 +30389,7 @@ function build_function_call_node$1(node, status) {
 					if (arg.node_type === "value" && arg.value === "null") {
 						emit_asm(status, `mov x0, #0\n`);
 						emit_asm(status, `mov x1, #0\n`);
-					} else if (arg.node_type === "value" && is_nullable_scalar_type(arg.type)) {
+					} else if (arg.node_type === "value" && is_nullable_scalar_type(arg.type, status)) {
 						const vname = arg.value;
 						emit_var_load(status, "x0", vname, aarch64_size(param_type.name));
 						emit_var_load(status, "x1", has_flag_name(vname), 8);
@@ -30147,7 +30503,7 @@ function build_function_call_node$1(node, status) {
 		} else if (!is_struct && node.type?.name && !status.call_x8_preset) {
 			const return_struct = status.structs.find((s) => s.name === node.type.name && !s.is_simple_type && !s.is_class);
 			const return_enum_size = get_enum_sret_size(node.type?.name, status);
-			const nullable_scalar_ret = is_nullable_scalar_type(node.type);
+			const nullable_scalar_ret = is_nullable_scalar_type(node.type, status);
 			if (return_struct || return_enum_size !== void 0 || nullable_scalar_ret) {
 				const nullable_ret = is_nullable_struct_type(node.type, status);
 				const struct_size = return_struct ? get_struct_size(node.type.name, status) : nullable_scalar_ret ? 8 : return_enum_size;
@@ -30203,7 +30559,7 @@ function build_function_call_node$1(node, status) {
 		if (!is_struct && node.type?.name && !status.call_x8_preset) {
 			const return_struct = status.structs.find((s) => s.name === node.type.name && !s.is_simple_type && !s.is_class);
 			const return_enum_size = get_enum_sret_size(node.type?.name, status);
-			const nullable_scalar_ret = is_nullable_scalar_type(node.type);
+			const nullable_scalar_ret = is_nullable_scalar_type(node.type, status);
 			if (return_struct || return_enum_size !== void 0 || nullable_scalar_ret) {
 				const temp_name = `_call_ret_${temp_counter - 1}`;
 				emit_asm(status, `add x0, x29, #${status.stack_offsets.get(temp_name)}\n`);
@@ -31078,7 +31434,7 @@ function build_struct_body(node, status) {
 		status.code += `];\n`;
 	} else {
 		status.code += `${field_c_type(field.type, status)} ${field.name};\n`;
-		if (is_nullable_struct_type(field.type, status) || is_nullable_scalar_type(field.type)) status.code += `unsigned char ${has_flag_name(field.name)};\n`;
+		if (is_nullable_struct_type(field.type, status) || is_nullable_scalar_type(field.type, status)) status.code += `unsigned char ${has_flag_name(field.name)};\n`;
 	}
 	for (let traitName of node.traits) {
 		const trait = status.traits.find((n) => n.name === traitName);
@@ -31210,8 +31566,8 @@ function build_operation_node$1(node, status) {
 			build_node$1(node.right_value, status);
 			status.code += `); })`;
 			ns_tmp_counter++;
-		} else if (is_nullable_scalar_type(left_type)) {
-			if (node.left_value.node_type === "func_call" && is_nullable_scalar_type(node.left_value.type)) {
+		} else if (is_nullable_scalar_type(left_type, status)) {
+			if (node.left_value.node_type === "func_call" && is_nullable_scalar_type(node.left_value.type, status)) {
 				const id = ns_tmp_counter++;
 				const flag = `_nsh_${id}`;
 				const val = `_nsv_${id}`;
@@ -31273,8 +31629,8 @@ function build_operation_node$1(node, status) {
 			else status.code += `((`;
 			build_node$1(nullable_side, status);
 			status.code += `.ptr != 0))`;
-		} else if (is_nullable_scalar_type(type_from_value_node$1(nullable_side)) && type?.is_nullable && type.name !== "string") {
-			if (nullable_side.node_type === "func_call" && is_nullable_scalar_type(nullable_side.type)) {
+		} else if (is_nullable_scalar_type(type_from_value_node$1(nullable_side), status) && type?.is_nullable && type.name !== "string") {
+			if (nullable_side.node_type === "func_call" && is_nullable_scalar_type(nullable_side.type, status)) {
 				const id = ns_tmp_counter++;
 				const flag = `_nsh_${id}`;
 				const val = `_nsv_${id}`;
@@ -31438,7 +31794,7 @@ function is_null_comparison(node) {
 }
 function is_nullable_struct_side(node, status) {
 	const t = type_from_value_node$1(node);
-	return is_nullable_struct_type(t, status) || is_nullable_scalar_type(t);
+	return is_nullable_struct_type(t, status) || is_nullable_scalar_type(t, status);
 }
 /**
 * Build the companion `_has` flag expression for a nullable-struct or
@@ -31456,8 +31812,8 @@ function is_nullable_struct_side(node, status) {
 function build_nullable_has(node, status) {
 	if (node.node_type === "value") {
 		const name = node.value;
-		if (status.function_ref_params?.has(name) && (is_nullable_struct_type(node.type, status) || is_nullable_scalar_type(node.type))) return has_flag_name(name);
-		if (is_nullable_struct_type(node.type, status) || is_nullable_scalar_type(node.type)) return has_flag_name(name);
+		if (status.function_ref_params?.has(name) && (is_nullable_struct_type(node.type, status) || is_nullable_scalar_type(node.type, status))) return has_flag_name(name);
+		if (is_nullable_struct_type(node.type, status) || is_nullable_scalar_type(node.type, status)) return has_flag_name(name);
 	}
 	const saved = begin_code_scratch(status);
 	build_node$1(node, status);
@@ -33122,7 +33478,7 @@ function build_assignment_node$1(node, status, nir_rhs, nir_swap) {
 		if (rhs_is_null) status.code += `${flag} = 0`;
 		else {
 			const call_ret = call_result_type(node.right_value);
-			if (!!call_ret && (is_nullable_struct_type(call_ret, status) || is_nullable_scalar_type(call_ret))) {
+			if (!!call_ret && (is_nullable_struct_type(call_ret, status) || is_nullable_scalar_type(call_ret, status))) {
 				const old = status.current_nullable_call_flag;
 				status.current_nullable_call_flag = flag;
 				status.code += `${lhs_expr} = `;
@@ -33592,11 +33948,11 @@ function lhs_nullable_struct_type(node, status) {
 	if (node.left_value.node_type === "value") {
 		const name = node.left_value.value;
 		const t = status.scoped_declarations.find((d) => d.name === name)?.type || status.variable_types?.get(name);
-		return is_nullable_struct_type(t, status) || is_nullable_scalar_type(t);
+		return is_nullable_struct_type(t, status) || is_nullable_scalar_type(t, status);
 	}
 	if (node.left_value.node_type === "access" && node.left_value.access.node_type === "access_field") {
 		const field_type = node.left_value.access.type;
-		return is_nullable_struct_type(field_type, status) || is_nullable_scalar_type(field_type);
+		return is_nullable_struct_type(field_type, status) || is_nullable_scalar_type(field_type, status);
 	}
 	return false;
 }
@@ -33609,7 +33965,7 @@ function lhs_nullable_struct_type(node, status) {
 function nullable_value_flag_expr(value, status) {
 	const t = type_from_value_node$1(value);
 	if (!t?.is_nullable) return void 0;
-	if (!is_nullable_struct_type(t, status) && !is_nullable_scalar_type(t)) return void 0;
+	if (!is_nullable_struct_type(t, status) && !is_nullable_scalar_type(t, status)) return void 0;
 	if (value.node_type === "value") return has_flag_name(value.value);
 	if (value.node_type === "access" && value.access.node_type === "access_field") {
 		const saved = begin_code_scratch(status);
@@ -34340,32 +34696,37 @@ function build_declaration_node(node, status, nir_init, nir_swap) {
 				status.stack_array_lengths.set(safe_name, len_text);
 			}
 		}
-		if (is_nullable_struct_type(node.type, status) || is_nullable_scalar_type(node.type)) {
+		if (is_nullable_struct_type(node.type, status) || is_nullable_scalar_type(node.type, status)) {
 			const flag = has_flag_name(safe_name);
 			const is_null = !node.value || node.value.node_type === "value" && node.value.value === "null";
-			if (!status.current_function && is_nullable_scalar_type(node.type)) {
-				status.code += `;\nunsigned char ${flag} = ${is_null ? 0 : 1}`;
-				if (is_null) return;
-			} else {
-				status.code += `;\nunsigned char ${flag} = 0`;
-				if (node.value && !is_null) {
-					const call_ret = call_result_type(node.value);
-					const value_is_nullable_call = !!call_ret && (is_nullable_struct_type(call_ret, status) || is_nullable_scalar_type(call_ret));
-					status.code += `;\n${safe_name} = `;
-					if (value_is_nullable_call) {
-						const old = status.current_nullable_call_flag;
-						status.current_nullable_call_flag = flag;
-						emit_init_value(node.value, nir_init, status);
-						status.current_nullable_call_flag = old;
-						record_call_init_string_fields(node, status);
-					} else {
-						const rhs_flag = nullable_value_flag_expr(node.value, status);
-						emit_init_value(node.value, nir_init, status);
-						status.code += `;\n${flag} = ${rhs_flag ?? "1"}`;
-					}
+			if (!status.current_function && is_nullable_scalar_type(node.type, status)) {
+				if (is_null) {
+					status.code += `;\nunsigned char ${flag} = 0`;
+					return;
 				}
+				status.code += ` = `;
+				emit_init_value(node.value, nir_init, status);
+				status.code += `;\nunsigned char ${flag} = 1`;
 				return;
 			}
+			status.code += `;\nunsigned char ${flag} = 0`;
+			if (node.value && !is_null) {
+				const call_ret = call_result_type(node.value);
+				const value_is_nullable_call = !!call_ret && (is_nullable_struct_type(call_ret, status) || is_nullable_scalar_type(call_ret, status));
+				status.code += `;\n${safe_name} = `;
+				if (value_is_nullable_call) {
+					const old = status.current_nullable_call_flag;
+					status.current_nullable_call_flag = flag;
+					emit_init_value(node.value, nir_init, status);
+					status.current_nullable_call_flag = old;
+					record_call_init_string_fields(node, status);
+				} else {
+					const rhs_flag = nullable_value_flag_expr(node.value, status);
+					emit_init_value(node.value, nir_init, status);
+					status.code += `;\n${flag} = ${rhs_flag ?? "1"}`;
+				}
+			}
+			return;
 		}
 		if (node.value) {
 			const is_heap_literal_init = node.is_heap_array_literal || node.type.storage_kind === "heap_array" && (node.value.node_type === "array" || node.value.node_type === "range");
@@ -34790,6 +35151,7 @@ function build_if_else_node(node, status, nir) {
 	status.code += `) {\n`;
 	let then_fields;
 	if (node.if_branch) {
+		status.heap_string_fields = new Set(pre_heap_string_fields ?? []);
 		build_block_with_cursor(node.if_branch, nir?.then_branch, status);
 		build_auto_free(status);
 	}
@@ -34798,7 +35160,7 @@ function build_if_else_node(node, status, nir) {
 	if (node.else_branch) {
 		status.scoped_declarations = enter_c_scope(status);
 		status.deferred_frees = [];
-		status.heap_string_fields = pre_heap_string_fields;
+		status.heap_string_fields = new Set(pre_heap_string_fields ?? []);
 		status.code += `} else {\n`;
 		build_block_with_cursor(node.else_branch, nir?.else_branch, status);
 		build_auto_free(status);
@@ -34982,7 +35344,7 @@ function build_return_node(node, status, nir_value) {
 			emit_nursery_joins_on_return_c(status);
 			reclaim_all_c_scopes(status);
 			status.code += `*${ret_has} = 0;\n`;
-			if (status.function_return_type && is_nullable_scalar_type(status.function_return_type)) status.code += `return (${c_type(status.function_return_type.name)})0;\n`;
+			if (status.function_return_type && is_nullable_scalar_type(status.function_return_type, status)) status.code += `return (${c_type(status.function_return_type.name)})0;\n`;
 			else status.code += `return (struct ${status.function_return_type.name}){0};\n`;
 			return;
 		}
@@ -35215,7 +35577,7 @@ function nullable_flag_expr_of_value(value, status) {
 	if (!value) return void 0;
 	const t = type_from_value_node$1(value);
 	if (!t?.is_nullable) return void 0;
-	if (!(is_nullable_struct_type(t, status) || is_nullable_scalar_type(t))) return void 0;
+	if (!(is_nullable_struct_type(t, status) || is_nullable_scalar_type(t, status))) return void 0;
 	if (value.node_type === "value") return has_flag_name(value.value);
 	if (value.node_type === "access") {
 		const saved = begin_code_scratch(status);
@@ -35232,7 +35594,7 @@ function build_switch_node(node, status, nir) {
 	for (let i = 0; i < node.cases.length; i++) {
 		const c = node.cases[i];
 		status.scoped_declarations = enter_c_scope(status);
-		status.heap_string_fields = pre_heap_string_fields;
+		status.heap_string_fields = new Set(pre_heap_string_fields ?? []);
 		const saved_code = begin_code_scratch(status);
 		build_node$1(c.condition, status);
 		let cond_code = end_code_scratch(status, saved_code);
@@ -35278,7 +35640,7 @@ function build_switch_node(node, status, nir) {
 	if (node.else_branch) {
 		status.code += "} else ";
 		status.scoped_declarations = enter_c_scope(status);
-		status.heap_string_fields = pre_heap_string_fields;
+		status.heap_string_fields = new Set(pre_heap_string_fields ?? []);
 		status.code += `{\n`;
 		build_block_with_cursor(node.else_branch, nir?.otherwise ?? void 0, status);
 		build_auto_free(status);
@@ -35657,20 +36019,80 @@ function has_owning_fields(node, status) {
 }
 /**
 * The names of Buffer methods that get specialized for owning value structs.
-* load_T and move_T are NOT specialized: load_T returns a shallow copy (a
-* borrow — the caller's struct local is not destroyed, so no double-free);
-* move_T transfers ownership (the slot is zeroed, the caller takes the
-* pointers).
+* load_T IS specialized when the element has owning container fields (a
+* `List<T>` member): the returned copy must own independent containers, or
+* the caller's scope-exit destroy would free the slot's buffer (double-free
+* at container teardown). String fields stay BORROWED on load (struct-local
+* teardown only frees RECORDED heap strings, so strdup'ing them would leak);
+* container fields have no such borrow convention — a struct local's
+* container fields are ALWAYS destroyed — so they must be deep-copied.
+* move_T is NOT specialized: it transfers ownership (the slot is zeroed, the
+* caller takes the pointers).
 */
 const OWNING_BUFFER_METHODS = /* @__PURE__ */ new Set([
 	"store",
 	"replace",
+	"load",
 	"modify",
 	"shift",
 	"destroy",
 	"#destroy"
 ]);
 /**
+* Emit the transfer half of owning store_T/replace_T: the slot bytes were
+* already memcpy'd from the source, so zeroing each owned CONTAINER field
+* of the SOURCE completes the move — the slot is the sole owner, and the
+* source's own teardown (when it still runs: an unstamped generic-body
+* local) finds zeroed fields and reclaims nothing. Nested value struct
+* fields recurse so their container leaves are zeroed at their own paths;
+* their string fields are untouched (the slot aliases them — the pre-existing
+* nested-string convention). Class/enum payload fields are left alone
+* (recorded in FOLLOWUP.md).
+*/
+function emit_transfer_owning_fields(elem, src, status, prefix = "") {
+	for (const field of elem.fields) {
+		if (field.type.is_ref || field.type.is_view) continue;
+		if (field.type.is_array || field.type.is_nullable) continue;
+		const field_struct = resolve_struct_type(field.type, status);
+		if (!field_struct || field_struct.is_class) continue;
+		const src_field = `${prefix}${src}${arrow(src)}${field.name}`;
+		if (has_destroy(field_struct)) status.code += `memset((void*)&${src_field}, 0, sizeof(${src_field}));\n`;
+		else if (struct_needs_destroy(field_struct, status)) emit_transfer_owning_fields(field_struct, src_field, status, "");
+	}
+}
+/**
+* Emit the deep-copy half of owning load_T: for each field whose type has a
+* monomorphized `copy` helper that yields an independent value (a `List<T>`
+* /`Buffer<T>`/`Map`/`Set` field — `<Mono>_copy` deep-copies the slots or
+* member buffers — or an enum-with-data field whose string payloads
+* `<E>_copy` duplicates), overwrite the shallow-copied bytes with an owned
+* copy. A struct local's CONTAINER fields are reclaimed unconditionally at
+* scope exit, so a shallow return would double-free the slot's slab. Fields
+* without a copyable shape (class fields, nested owning user structs without
+* a synthesized copy) stay shallow — recorded in FOLLOWUP.md.
+*/
+function emit_load_deep_copy_fields(elem, dst, status) {
+	for (const field of elem.fields) {
+		if (field.type.is_ref || field.type.is_view || field.type.is_array) continue;
+		if (field.type.is_nullable) continue;
+		if (field.type.name === "string") continue;
+		const field_struct = resolve_struct_type(field.type, status);
+		if (field_struct && !field_struct.is_class && is_load_deep_copy_container(field_struct.name) && struct_needs_destroy(field_struct, status) && field_struct.functions.find((f) => f.name === "copy")) {
+			status.code += `${dst}.${field.name} = ${field_struct.name}_copy(&${dst}.${field.name});\n`;
+			continue;
+		}
+		const field_enum = status.enums.find((e) => e.name === field.type.name && e.has_associated_data);
+		if (field_enum && enum_copy_is_deep(field_enum, status)) status.code += `${dst}.${field.name} = ${field_enum.name}_copy(${dst}.${field.name});\n`;
+	}
+}
+/** Whether `<E>_copy` yields a fully independent value: no case payload is a
+*  class/trait reference (those are shared pointers the copy cannot
+*  duplicate — mirroring owning_buffer_enum_element's gate). */
+function enum_copy_is_deep(elem, status) {
+	for (const c of elem.cases) for (const p of c.params) if (status.structs.find((s) => s.name === p.type.name)?.is_class || status.traits.find((t) => t.name === p.type.name)) return false;
+	return true;
+}
+/**
 * A `Buffer<string>` owns an independent heap copy of each slot (strdup on
 * store_T, free+strdup on replace_T, per-slot free on #destroy). The element
 * is a primitive, so this is a separate path from the value-struct
@@ -35833,6 +36255,13 @@ function emit_owning_buffer_body(func_name, elem, status) {
 		status.code += `struct ${elem.name} _old = _slots[i];\n`;
 		status.code += `_slots[i] = (*val);\n`;
 		emit_deep_copy_fields(elem, "_slots[i]", "val", status, "_old");
+		emit_transfer_owning_fields(elem, "val", status);
+		return true;
+	}
+	if (func_name === "load") {
+		status.code += `struct ${elem.name} _loaded = ((struct ${elem.name} *)(unsigned long long)self->data)[i];\n`;
+		emit_load_deep_copy_fields(elem, "_loaded", status);
+		status.code += `return _loaded;\n`;
 		return true;
 	}
 	if (func_name === "modify") {
@@ -35847,6 +36276,7 @@ function emit_owning_buffer_body(func_name, elem, status) {
 		status.code += `${elem.name}_destroy(&_slots[i]);\n`;
 		status.code += `_slots[i] = (*val);\n`;
 		emit_deep_copy_fields(elem, "_slots[i]", "val", status);
+		emit_transfer_owning_fields(elem, "val", status);
 		return true;
 	}
 	if (func_name === "shift") {
@@ -35873,12 +36303,13 @@ function emit_owning_buffer_body(func_name, elem, status) {
 	return false;
 }
 /**
-* For each string field on the element struct, overwrite the shallow-copied
-* pointer in `dst` with a fresh strdup of `src`'s field. This breaks the
-* pointer aliasing between the source and the slot so each can be destroyed
-* independently. For nested owning value struct fields, recursively call the
-* nested struct's destroy + deep-copy (the nested destroy frees the
-* shallow-copied owned sub-fields, then the deep-copy re-strdup's them).
+* For each DIRECT string field on the element struct, overwrite the
+* shallow-copied pointer in `dst` with a fresh strdup of `src`'s field. This
+* breaks the pointer aliasing between the source and the slot so each can be
+* destroyed independently. Nested value struct fields are NOT walked: their
+* string fields stay aliased (the pre-existing convention — a spliced
+* `move` donor has no teardown, so the slot is the sole owner), and their
+* container leaves are transferred by `emit_transfer_owning_fields`.
 *
 * `old_expr` (optional) is the slot's PRE-copy value expression. When the
 * source field pointer equals the old slot field pointer, the slot already
@@ -35896,12 +36327,6 @@ function emit_deep_copy_fields(elem, dst, src, status, old_expr) {
 			const src_field = `${src}${arrow(src)}${field.name}`;
 			if (old_expr) status.code += `${dst}.${field.name} = (${src_field}.ptr && ${src_field}.ptr != ${old_expr}.${field.name}.ptr) ? nomen_str_dup(${src_field}) : ${src_field};\n`;
 			else status.code += `${dst}.${field.name} = ${src_field}.ptr ? nomen_str_dup(${src_field}) : ${src_field};\n`;
-		} else if (field.type.name && !field.type.is_array) {
-			const field_struct = status.structs.find((s) => s.name === field.type.name && !s.is_simple_type && !s.is_generic);
-			if (field_struct && !field_struct.is_class && struct_needs_destroy(field_struct, status)) {
-				status.code += `${field_struct.name}_destroy(&${dst}.${field.name});\n`;
-				emit_deep_copy_fields(field_struct, `${dst}.${field.name}`, `${src}${arrow(src)}${field.name}`, status);
-			}
 		}
 	}
 }
@@ -36049,7 +36474,7 @@ function build_struct_node(node, status) {
 	const ctor_return = is_class ? `struct ${node.name}*` : `struct ${node.name}`;
 	const field_params = node.fields.filter((f) => f.value == null).map((f) => {
 		let decl = c_param_decl(f.type, f.name, status);
-		if (is_nullable_struct_type(f.type, status) || is_nullable_scalar_type(f.type)) decl += `, unsigned char ${has_flag_name(f.name)}`;
+		if (is_nullable_struct_type(f.type, status) || is_nullable_scalar_type(f.type, status)) decl += `, unsigned char ${has_flag_name(f.name)}`;
 		return decl;
 	}).join(", ");
 	const ctor_sig = (init) => {
@@ -36060,7 +36485,7 @@ function build_struct_node(node, status) {
 				is_ref: p.is_ref || p.type.is_ref,
 				declaration: p.declaration
 			});
-			if (!p.is_variadic && (is_nullable_struct_type(p.type, status) || is_nullable_scalar_type(p.type))) decl += `, unsigned char ${has_flag_name(p.name)}`;
+			if (!p.is_variadic && (is_nullable_struct_type(p.type, status) || is_nullable_scalar_type(p.type, status))) decl += `, unsigned char ${has_flag_name(p.name)}`;
 			return decl;
 		}).join(", ");
 		const label = is_overloaded(node, "#init") ? mangled_label(init, node.name) : `${node.name}_init`;
@@ -36088,7 +36513,7 @@ function build_struct_node(node, status) {
 						build_node$1(field.value, status);
 						status.code += `; self${accessor}${field.name} = (nomen_view){ _p.ptr, _p.len }; }\n`;
 					} else status.code += `self${accessor}${field.name} = (nomen_view){0};\n`;
-				} else if (is_nullable_struct_type(field.type, status) || is_nullable_scalar_type(field.type)) {
+				} else if (is_nullable_struct_type(field.type, status) || is_nullable_scalar_type(field.type, status)) {
 					if (field.value.node_type === "value" && field.value.value === "null") status.code += `self${accessor}${has_flag_name(field.name)} = 0;\n`;
 					else {
 						status.code += `self${accessor}${field.name} = `;
@@ -36166,7 +36591,7 @@ function build_struct_node(node, status) {
 				status.code += `; ${object_name}${accessor}${field.name} = (nomen_view){ _p.ptr, _p.len }; }\n`;
 			} else status.code += `${object_name}${accessor}${field.name} = (nomen_view){0};\n`;
 		} else if (field.type.storage_kind === "stack_array" && field.type.length) status.code += `memcpy(${object_name}${accessor}${field.name}, ${field.name}, sizeof(${object_name}${accessor}${field.name}));\n`;
-		else if ((is_nullable_struct_type(field.type, status) || is_nullable_scalar_type(field.type)) && field.value) {
+		else if ((is_nullable_struct_type(field.type, status) || is_nullable_scalar_type(field.type, status)) && field.value) {
 			if (field.value.node_type === "value" && field.value.value === "null") status.code += `${object_name}${accessor}${has_flag_name(field.name)} = 0;\n`;
 			else {
 				status.code += `${object_name}${accessor}${field.name} = `;
@@ -36176,7 +36601,7 @@ function build_struct_node(node, status) {
 		} else if (is_nullable_struct_type(field.type, status)) {
 			status.code += `${object_name}${accessor}${field.name} = *${field.name};\n`;
 			status.code += `${object_name}${accessor}${has_flag_name(field.name)} = ${has_flag_name(field.name)};\n`;
-		} else if (is_nullable_scalar_type(field.type)) {
+		} else if (is_nullable_scalar_type(field.type, status)) {
 			status.code += `${object_name}${accessor}${field.name} = ${field.name};\n`;
 			status.code += `${object_name}${accessor}${has_flag_name(field.name)} = ${has_flag_name(field.name)};\n`;
 		} else if (!field.type.is_ref && !field.type.is_view && status.enums.find((e) => e.name === field.type.name && e.has_associated_data)) {
@@ -36314,7 +36739,7 @@ function build_struct_functions(node, status, skip_init = false) {
 		status.force_heap_strings = scan_force_heap_strings(func.statements ?? [], status.structs);
 		status.function_return_type = func.return_type;
 		const old_nullable_ret_has = status.nullable_ret_has_param;
-		if (is_nullable_struct_type(func.return_type, status) || is_nullable_scalar_type(func.return_type)) status.nullable_ret_has_param = "_ret_has";
+		if (is_nullable_struct_type(func.return_type, status) || is_nullable_scalar_type(func.return_type, status)) status.nullable_ret_has_param = "_ret_has";
 		else status.nullable_ret_has_param = void 0;
 		const self_param = func.params[0]?.is_self_param ? func.params[0] : null;
 		status.self_is_ref = !!self_param?.is_ref || self_param?.declaration === "var";
@@ -36371,9 +36796,9 @@ function build_struct_functions(node, status, skip_init = false) {
 		for (let i = 0; i < func.params.length; i++) {
 			if (i > 0) status.code += ", ";
 			build_parameter_node(func.params[i], status);
-			if (!func.params[i].is_self_param && (is_nullable_struct_type(func.params[i].type, status) || is_nullable_scalar_type(func.params[i].type))) status.code += `, unsigned char ${has_flag_name(c_function_name(func.params[i].name))}`;
+			if (!func.params[i].is_self_param && (is_nullable_struct_type(func.params[i].type, status) || is_nullable_scalar_type(func.params[i].type, status))) status.code += `, unsigned char ${has_flag_name(c_function_name(func.params[i].name))}`;
 		}
-		if (is_nullable_struct_type(func.return_type, status) || is_nullable_scalar_type(func.return_type)) {
+		if (is_nullable_struct_type(func.return_type, status) || is_nullable_scalar_type(func.return_type, status)) {
 			if (func.params.length > 0) status.code += `, `;
 			status.code += `unsigned char *_ret_has`;
 		}
@@ -37134,9 +37559,9 @@ function build_function_node(node, status) {
 			first_param = false;
 			if (node.params[i].is_variadic) status.code += `long _${node.params[i].name}_len, `;
 			build_parameter_node(node.params[i], status);
-			if ((is_nullable_struct_type(node.params[i].type, status) || is_nullable_scalar_type(node.params[i].type)) && !node.params[i].is_self_param) status.code += `, unsigned char ${has_flag_name(c_function_name(node.params[i].name))}`;
+			if ((is_nullable_struct_type(node.params[i].type, status) || is_nullable_scalar_type(node.params[i].type, status)) && !node.params[i].is_self_param) status.code += `, unsigned char ${has_flag_name(c_function_name(node.params[i].name))}`;
 		}
-		if (is_nullable_struct_type(node.return_type, status) || is_nullable_scalar_type(node.return_type)) {
+		if (is_nullable_struct_type(node.return_type, status) || is_nullable_scalar_type(node.return_type, status)) {
 			if (!first_param) status.code += ", ";
 			status.code += `unsigned char *_ret_has`;
 		}
@@ -37189,7 +37614,7 @@ function build_function_node(node, status) {
 	const old_variable_types = status.variable_types;
 	status.variable_types = /* @__PURE__ */ new Map();
 	const old_nullable_ret_has = status.nullable_ret_has_param;
-	if (is_nullable_struct_type(node.return_type, status) || is_nullable_scalar_type(node.return_type)) status.nullable_ret_has_param = "_ret_has";
+	if (is_nullable_struct_type(node.return_type, status) || is_nullable_scalar_type(node.return_type, status)) status.nullable_ret_has_param = "_ret_has";
 	else status.nullable_ret_has_param = void 0;
 	const old_function_name = status.current_function_name;
 	status.current_function_name = emission_label(node);
@@ -37246,6 +37671,7 @@ function build_function_node(node, status) {
 		stmts: nir.body,
 		ast: node.statements
 	} : void 0;
+	emit_ref_param_entry_dups(node, status);
 	build_block_node(node, status, false);
 	status.nir_emit_ctx = old_nir_ctx;
 	status.function_ref_params = old_ref_params;
@@ -37291,6 +37717,37 @@ function build_function_node(node, status) {
 	status.stack_array_lengths = old_stack_array_lengths;
 	status.moved = old_moved;
 }
+/**
+* Emit the entry-dup for every `ref` value-struct param string field the
+* body stores through CONDITIONALLY (see ref_param_entry_dup_fields):
+* `{ field = nomen_str_dup(field) }` at function entry, recorded in
+* heap_string_fields, so the field is heap-owned on every path out of the
+* function and the call-site record transfer is sound. Nullable string
+* fields guard the dup (a null pair stores as null — free(NULL) is a
+* no-op on every reclaim path).
+*/
+function emit_ref_param_entry_dups(node, status) {
+	const dups = ref_param_entry_dup_fields(node, status.structs);
+	if (!dups.size) return;
+	for (const param of node.params ?? []) {
+		if (param.is_self_param) continue;
+		if (!(param.is_ref || param.type.is_ref)) continue;
+		const fields = dups.get(param.name);
+		if (!fields?.size) continue;
+		const struct = status.structs.find((s) => s.name === param.type.name && !s.is_simple_type && !s.is_class);
+		const base = c_function_name(param.name);
+		for (const field of fields) {
+			const nullable = !!struct?.fields.find((f) => f.name === field)?.type.is_nullable;
+			if (nullable) status.code += `if (${base}->${field}.ptr) {\n`;
+			const temp = `_dup_t_${status.label_counter = (status.label_counter ?? 0) + 1}`;
+			status.code += `nomen_string ${temp} = nomen_str_dup(${base}->${field});\n`;
+			status.code += `${base}->${field} = ${temp};\n`;
+			if (nullable) status.code += `}\n`;
+			if (!status.heap_string_fields) status.heap_string_fields = /* @__PURE__ */ new Set();
+			status.heap_string_fields.add(`${param.name}.${field}`);
+		}
+	}
+}
 function emit_nested_declarations(node, status) {
 	const block = node;
 	for (let child of block.statements) switch (child.node_type) {
@@ -37576,11 +38033,22 @@ function build_function_call_node(node, status) {
 	const lambda_ret_c = lambda_arg_temps.size > 0 ? c_return_type(node.type, status) : void 0;
 	const lambda_ret_tmp = lambda_ret_c && lambda_ret_c !== "void" ? next_lambda_ret_temp() : void 0;
 	if (lambda_ret_tmp) status.code += `${lambda_ret_c} ${lambda_ret_tmp} = `;
-	const saved_call = (is_nullable_struct_type(node.type, status) || is_nullable_scalar_type(node.type)) && !status.current_nullable_call_flag ? begin_code_scratch(status) : void 0;
+	const saved_call = (is_nullable_struct_type(node.type, status) || is_nullable_scalar_type(node.type, status)) && !status.current_nullable_call_flag ? begin_code_scratch(status) : void 0;
 	let wrap_tmp;
 	status.code += `${func_name}(${is_closure_callee ? "NULL" : ""}`;
 	if (is_closure_callee && node.params.length > 0) status.code += ", ";
 	const variadic_idx = node.variadic_param_name ? node.params.findIndex((p) => p.node_type === "array") : -1;
+	if (!node.variadic_param_name) {
+		const resolved = node.resolved_function ?? (is_struct ? status.structs.find((s) => s.name === node.name)?.functions.find((f) => f.name === "#init") : void 0);
+		const variadic_param = resolved?.params?.find((p) => p.is_variadic);
+		if (resolved && variadic_param) {
+			if (node.params.length === 1 && node.params[0].node_type === "array") node.variadic_param_name = variadic_param.name;
+			else if (node.params.length === 0 && resolved.params.filter((p) => !p.is_self_param && !p.is_variadic).length === 0) {
+				const elem_c = c_type(variadic_param.type.name);
+				status.code += `0, (${elem_c}[]){ }`;
+			}
+		}
+	}
 	for (let i = 0; i < node.params.length; i++) {
 		if (i > 0) status.code += ", ";
 		if (i === variadic_idx && node.params[i].node_type === "array") {
@@ -37617,7 +38085,7 @@ function build_function_call_node(node, status) {
 		}
 		if (node.nullable_param_indices?.includes(i) && node.params[i].node_type === "value" && node.params[i].value === "null") {
 			const callee_null_param_type = callee_params?.[i]?.type ?? param_type;
-			if (is_nullable_scalar_type(callee_null_param_type)) status.code += `0, 0`;
+			if (is_nullable_scalar_type(callee_null_param_type, status)) status.code += `0, 0`;
 			else status.code += `(void *)&(struct ${mono_type_name(callee_null_param_type)}){0}, 0`;
 			continue;
 		}
@@ -37703,7 +38171,7 @@ function build_function_call_node(node, status) {
 			emit_nullable_arg_flag(node.params[i], status);
 		}
 	}
-	if (is_nullable_struct_type(node.type, status) || is_nullable_scalar_type(node.type)) {
+	if (is_nullable_struct_type(node.type, status) || is_nullable_scalar_type(node.type, status)) {
 		const flag_name = status.current_nullable_call_flag;
 		const arg_list_empty = node.params.length === 0 && !is_closure_callee;
 		if (flag_name) status.code += `${arg_list_empty ? "" : ", "}&${flag_name}`;
@@ -37812,13 +38280,13 @@ function emit_nullable_arg_flag(arg, status) {
 	}
 	if (arg.node_type === "value") {
 		const vn = arg;
-		if (is_nullable_struct_type(vn.type, status) || is_nullable_scalar_type(vn.type)) status.code += `${has_flag_name(vn.value)}`;
+		if (is_nullable_struct_type(vn.type, status) || is_nullable_scalar_type(vn.type, status)) status.code += `${has_flag_name(vn.value)}`;
 		else status.code += `1`;
 		return;
 	}
 	if (arg.node_type === "access" && arg.access.node_type === "access_field") {
 		const t = type_from_value_node$1(arg);
-		if (is_nullable_struct_type(t, status) || is_nullable_scalar_type(t)) {
+		if (is_nullable_struct_type(t, status) || is_nullable_scalar_type(t, status)) {
 			const saved = begin_code_scratch(status);
 			build_node$1(arg, status);
 			const expr = end_code_scratch(status, saved);
@@ -38620,13 +39088,13 @@ function build_access_node$1(node, status) {
 						build_node$1(access_func.params[i], status);
 						status.suppress_dereference = false;
 					}
-					if (target_param && !target_param.is_self_param && (is_nullable_struct_type(target_param.type, status) || is_nullable_scalar_type(target_param.type))) {
+					if (target_param && !target_param.is_self_param && (is_nullable_struct_type(target_param.type, status) || is_nullable_scalar_type(target_param.type, status))) {
 						status.code += `, `;
 						emit_nullable_arg_flag(access_func.params[i], status);
 					}
 				}
 				const method_ret_type = (target_method ?? trait_default_func)?.return_type ?? access_func.type;
-				if (is_nullable_struct_type(method_ret_type, status) || is_nullable_scalar_type(method_ret_type)) {
+				if (is_nullable_struct_type(method_ret_type, status) || is_nullable_scalar_type(method_ret_type, status)) {
 					const flag_name = status.current_nullable_call_flag;
 					status.code += `, `;
 					status.code += flag_name ? `&${flag_name}` : `(unsigned char *)&(unsigned char){0}`;
@@ -40371,11 +40839,11 @@ function is_nullable_struct_assignment(node, status) {
 	if (node.left_value.node_type === "value") {
 		const name = node.left_value.value;
 		const t = status.scoped_declarations.find((d) => d.name === name)?.type || status.variable_types?.get(name);
-		return is_nullable_struct_type(t, status) || is_nullable_scalar_type(t);
+		return is_nullable_struct_type(t, status) || is_nullable_scalar_type(t, status);
 	}
 	if (node.left_value.node_type === "access" && node.left_value.access.node_type === "access_field") {
 		const field_type = node.left_value.access.type;
-		return is_nullable_struct_type(field_type, status) || is_nullable_scalar_type(field_type);
+		return is_nullable_struct_type(field_type, status) || is_nullable_scalar_type(field_type, status);
 	}
 	return false;
 }
@@ -40430,7 +40898,7 @@ function build_nullable_struct_assignment(node, status, nir_rhs) {
 		const flag_name = has_flag_name(name);
 		const decl_type = status.scoped_declarations.find((d) => d.name === name)?.type || status.variable_types?.get(name);
 		const type_name = decl_type?.name || "";
-		const is_scalar = is_nullable_scalar_type(decl_type);
+		const is_scalar = is_nullable_scalar_type(decl_type, status);
 		const scalar_size = is_scalar ? aarch64_size(type_name) : 0;
 		const reclaimable = !(node.right_value.node_type === "value" && node.right_value.value === name) && !!status.heap_string_fields?.size && Array.from(status.heap_string_fields).some((k) => k.startsWith(`${name}.`));
 		if (rhs_is_null) {
@@ -40449,9 +40917,11 @@ function build_nullable_struct_assignment(node, status, nir_rhs) {
 				}
 			}
 		};
-		const value_is_nullable_call = node.right_value.node_type === "func_call" && (is_nullable_struct_type(node.right_value.type, status) || is_nullable_scalar_type(node.right_value.type));
+		const value_is_nullable_call = node.right_value.node_type === "func_call" && (is_nullable_struct_type(node.right_value.type, status) || is_nullable_scalar_type(node.right_value.type, status));
 		const rhs_value_type = call_result_type(node.right_value) ?? type_from_value_node$1(node.right_value);
-		if (node.right_value.node_type === "access" && rhs_value_type?.is_nullable && (is_nullable_struct_type(rhs_value_type, status) || is_nullable_scalar_type(rhs_value_type))) {
+		const value_is_nullable_access = node.right_value.node_type === "access" && rhs_value_type?.is_nullable && (is_nullable_struct_type(rhs_value_type, status) || is_nullable_scalar_type(rhs_value_type, status));
+		const rhs_is_field_read = value_is_nullable_access && is_nullable_scalar_type(rhs_value_type, status) && node.right_value.access.node_type === "access_field";
+		if (value_is_nullable_access && !rhs_is_field_read) {
 			if (reclaimable) emit_recorded_field_reclaim_for_slot(status, name, type_name);
 			retarget_records();
 			emit_rhs_value(node.right_value, nir_rhs, status);
@@ -40468,6 +40938,17 @@ function build_nullable_struct_assignment(node, status, nir_rhs) {
 			emit_var_store(status, "x9", flag_name, 8);
 			return;
 		}
+		if (rhs_is_field_read) {
+			if (reclaimable) emit_recorded_field_reclaim_for_slot(status, name, type_name);
+			retarget_records();
+			emit_rhs_value(node.right_value, nir_rhs, status);
+			ensure_newline(status);
+			emit_var_store(status, "x0", name, scalar_size);
+			load_nullable_has(node.right_value, "x9", status);
+			ensure_newline(status);
+			emit_var_store(status, "x9", flag_name, 8);
+			return;
+		}
 		if (value_is_nullable_call) {
 			if (reclaimable) emit_recorded_field_reclaim_for_slot(status, name, type_name);
 			retarget_records();
@@ -40484,7 +40965,7 @@ function build_nullable_struct_assignment(node, status, nir_rhs) {
 			status.call_x8_preset = old_preset;
 			return;
 		}
-		const rhs_is_nullable_value = !!rhs_value_type?.is_nullable && (is_nullable_struct_type(rhs_value_type, status) || is_nullable_scalar_type(rhs_value_type));
+		const rhs_is_nullable_value = !!rhs_value_type?.is_nullable && (is_nullable_struct_type(rhs_value_type, status) || is_nullable_scalar_type(rhs_value_type, status));
 		let rhs_flag_slot;
 		if (rhs_is_nullable_value) {
 			load_nullable_has(node.right_value, "x9", status);
@@ -40521,7 +41002,7 @@ function build_nullable_struct_assignment(node, status, nir_rhs) {
 	const field_offset = get_field_offset(target_type.name, field_name, status);
 	const has_offset = get_field_has_offset(target_type.name, field_name, status);
 	const struct_size = get_struct_size(type_name, status);
-	const field_is_scalar = is_nullable_scalar_type(field_access.type);
+	const field_is_scalar = is_nullable_scalar_type(field_access.type, status);
 	get_source_address(access.target, status);
 	ensure_newline(status);
 	emit_asm(status, `str x0, [sp, #-16]!\n`);
@@ -40532,7 +41013,7 @@ function build_nullable_struct_assignment(node, status, nir_rhs) {
 		return;
 	}
 	const rhs_t = call_result_type(node.right_value) ?? type_from_value_node$1(node.right_value);
-	const rhs_is_nullable_value = !!rhs_t?.is_nullable && (is_nullable_struct_type(rhs_t, status) || is_nullable_scalar_type(rhs_t));
+	const rhs_is_nullable_value = !!rhs_t?.is_nullable && (is_nullable_struct_type(rhs_t, status) || is_nullable_scalar_type(rhs_t, status));
 	let rhs_flag_slot;
 	if (rhs_is_nullable_value) {
 		load_nullable_has(node.right_value, "x10", status);
@@ -41175,7 +41656,11 @@ function build_assignment_node(node, status, nir_rhs, nir_swap) {
 				if (name === "self" && status.current_struct) target_type = new Type(status.current_struct.name);
 				else if (status.variable_types?.has(name)) target_type = status.variable_types.get(name);
 			}
-			const field_type = access.access.type;
+			let field_type = access.access.type;
+			if (!field_type?.name && target_type?.name) {
+				const tf = status.structs.find((s) => s.name === target_type.name)?.fields.find((f) => f.name === field_name);
+				if (tf) field_type = tf.type;
+			}
 			const field_is_struct = is_struct_type$2(field_type, status);
 			if (access.target.node_type === "value") {
 				const name = access.target.value;
@@ -42357,7 +42842,7 @@ function build_operation_node(node, status) {
 	if (node.op === "??") {
 		const left_t = type_from_value_node$1(node.left_value);
 		const left_is_nullable_struct = is_nullable_struct_type(left_t, status);
-		const left_is_nullable_scalar = is_nullable_scalar_type(left_t);
+		const left_is_nullable_scalar = is_nullable_scalar_type(left_t, status);
 		if (left_is_nullable_scalar && node.left_value.node_type === "func_call") {
 			build_operand(node.left_value, "x0", status);
 			ensure_newline(status);
@@ -42409,11 +42894,11 @@ function build_operation_node(node, status) {
 	if ((node.op === "==" || node.op === "!=") && is_null_literal$1(node.left_value) !== is_null_literal$1(node.right_value)) {
 		const nullable_flagged_side = (n) => {
 			const t = type_from_value_node$1(n);
-			return is_nullable_struct_type(t, status) || is_nullable_scalar_type(t);
+			return is_nullable_struct_type(t, status) || is_nullable_scalar_type(t, status);
 		};
 		const nullable_side = nullable_flagged_side(node.left_value) ? node.left_value : node.right_value;
 		const side_type = type_from_value_node$1(nullable_side);
-		if (is_nullable_struct_type(side_type, status) || is_nullable_scalar_type(side_type)) {
+		if (is_nullable_struct_type(side_type, status) || is_nullable_scalar_type(side_type, status)) {
 			load_nullable_has(nullable_side, "x1", status);
 			ensure_newline(status);
 			emit_asm(status, `cmp x1, #0\n`);
@@ -42931,7 +43416,7 @@ function load_nullable_has(node, target_reg, status) {
 			get_source_address(access.target, status);
 			ensure_newline(status);
 			if (target_reg !== "x0") emit_asm(status, `mov ${target_reg}, x0\n`);
-			const scalar_field = is_nullable_scalar_type(access.access.type);
+			const scalar_field = is_nullable_scalar_type(access.access.type, status);
 			const wreg = target_reg.replace("x", "w");
 			const load_op = scalar_field ? `ldrb ${wreg}` : `ldr ${target_reg}`;
 			if (has_off === 0) emit_asm(status, `${load_op}, [${target_reg}]\n`);
@@ -45133,7 +45618,7 @@ function build_access_method(node, access_func, status) {
 	const access_callee_params = access_callee_method?.params?.filter((p) => !p.is_self_param);
 	const return_struct = !access_func.type.is_view && !access_func.type.is_array && (!!status.structs.find((s) => s.name === access_func.type.name && !s.is_simple_type && !s.is_class) || get_enum_sret_size(access_func.type.name, status) !== void 0);
 	const method_ret_type = access_callee_method?.return_type ?? access_func.type;
-	const nullable_scalar_ret = is_nullable_scalar_type(method_ret_type) && !method_ret_type.is_ref;
+	const nullable_scalar_ret = is_nullable_scalar_type(method_ret_type, status) && !method_ret_type.is_ref;
 	let temp_addr = "";
 	let temp_offset = 0;
 	if (return_struct || nullable_scalar_ret) {
@@ -45253,7 +45738,7 @@ function build_access_method(node, access_func, status) {
 	for (let i = 0; i < access_func.params.length; i++) {
 		if ((access_func.ref_param_indices ?? []).includes(i)) continue;
 		const cp = access_callee_params?.[i];
-		if (cp && is_nullable_scalar_type(cp.type) || is_nullable_scalar_type(access_func.params[i].type)) nullable_scalar_arg_set.add(i);
+		if (cp && is_nullable_scalar_type(cp.type, status) || is_nullable_scalar_type(access_func.params[i].type, status)) nullable_scalar_arg_set.add(i);
 	}
 	const arg_slot = [];
 	let total_arg_slots = 0;
@@ -45308,7 +45793,7 @@ function build_access_method(node, access_func, status) {
 			if (arg.node_type === "value" && arg.value === "null") {
 				emit_asm(status, `mov x0, #0\n`);
 				emit_asm(status, `mov x1, #0\n`);
-			} else if (arg.node_type === "value" && is_nullable_scalar_type(arg.type)) {
+			} else if (arg.node_type === "value" && is_nullable_scalar_type(arg.type, status)) {
 				const vname = arg.value;
 				emit_var_load(status, "x0", vname, aarch64_size(arg.type.name));
 				emit_var_load(status, "x1", has_flag_name(vname), 8);
@@ -49572,13 +50057,33 @@ function can_class_int_coerce(target, value, status) {
 }
 //#endregion
 //#region ../src/check/utils/check_type_exists.ts
+/**
+* Containers whose elements live in raw T-sized slots (the `#arch` generic
+* bodies size each slot from the type name alone). A flagged-nullable
+* element type (`List<int?>`) has no per-slot null flag there, so `0`/`false`
+* would read back as null — rejected instead of silently misbehaving.
+* Element types with an in-band null (`string?`, class/trait `?`) stay legal.
+*/
+const RAW_ELEMENT_CONTAINERS = /* @__PURE__ */ new Set([
+	"Array",
+	"Buffer",
+	"List",
+	"Set",
+	"Map",
+	"Graph",
+	"LinkedList",
+	"Tree",
+	"Arena"
+]);
 function check_type_exists(type, status, start) {
+	if (type.is_nullable && type.is_array && !type.is_ref && !type.is_pointer && is_nullable_scalar_name(type.name, status)) add_error(status, `Nullable element type '${type.name}?' is not supported in an array: element storage has no per-element null flag`, start);
 	if (type.name === "tuple" && type.tuple_types?.length) {
 		let ok = true;
 		for (const elem of type.tuple_types) if (!check_type_exists(elem, status, start)) ok = false;
 		return ok;
 	}
 	if (type.name === "anon_enum" && type.enum_cases?.length) {
+		if (type.is_nullable && type.enum_cases.some((c) => c.types.length > 0)) add_error(status, `Nullable type '${type_name(type)}' is not supported: enums with associated data have no separate null flag`, start);
 		let ok = true;
 		for (const c of type.enum_cases) for (const t of c.types) if (!check_type_exists(t, status, start)) ok = false;
 		return ok;
@@ -49595,19 +50100,26 @@ function check_type_exists(type, status, start) {
 			}
 		}
 		type.name = declared.name;
+		if (type.is_nullable) {
+			if (status.enums.findLast((e) => (e.name === declared.name || e.source_name === declared.name) && !e.is_generic)?.has_associated_data) add_error(status, `Nullable type '${type_name(type)}' is not supported: enums with associated data have no separate null flag`, start);
+		}
 	} else if (!status.types.includes(type.name)) {
 		add_error(status, `Unknown type: ${type_name(type)}`, start);
 		return false;
 	}
 	if (type.tuple_types) for (const elem of type.tuple_types) check_type_exists(elem, status, start);
-	if (type.type_args) for (const arg of type.type_args) {
-		if (arg.name === "func") {
-			add_error(status, `func types cannot be used as type arguments ('${type.name}<...>')`, start);
-			continue;
+	if (type.type_args) {
+		if (RAW_ELEMENT_CONTAINERS.has(type.name)) {
+			for (const arg of type.type_args) if (is_nullable_flagged_type(arg, status)) add_error(status, `Nullable element type '${type_name(arg)}' is not supported in '${type.name}<...>': container element storage has no per-element null flag`, start);
 		}
-		check_type_exists(arg, status, start);
-	}
-	else {
+		for (const arg of type.type_args) {
+			if (arg.name === "func") {
+				add_error(status, `func types cannot be used as type arguments ('${type.name}<...>')`, start);
+				continue;
+			}
+			check_type_exists(arg, status, start);
+		}
+	} else {
 		const struct = status.structs.findLast((s) => s.name === type.name);
 		if (struct?.is_generic) {
 			if (!struct.type_params.every((tp) => status.type_params.includes(tp))) add_error(status, `Generic type '${type.name}' requires type arguments (expected <${struct.type_params.join(", ")}>)`, start);
@@ -52486,20 +52998,57 @@ function build_hash(struct, fields) {
 }
 /**
 * Whether `struct` is eligible for a synthesized `copy` method: a value
-* struct whose only ownership is its DIRECT string fields — the same set
-* the pass-by-value argument convention covers. A struct that additionally
-* owns non-string heap (a resource-releasing `#destroy`, a class field, a
-* nested requiring-move struct) cannot be deep-copied by "byte copy +
-* strdup the strings" — its copy stays unwritten (move/swap remains the
-* escape hatch) — and a struct with no string fields is already soundly
-* byte-copyable, so it needs no method.
+* struct whose every field is independently deep-copyable — direct string
+* fields (strdup'd), scalars/arrays (byte copies), `List<T>` fields whose
+* element is itself deep-copyable (the library `List.copy` deep-copies slots
+* via the owning store contract), and nested copyable structs (recursing
+* through their own `copy`). Class fields, enum-with-data fields (their
+* stores transfer payload ownership), class/trait-carrying `List` elements,
+* and resource-releasing `#destroy`s cannot be deep-copied by synthesis —
+* the copy stays unwritten (move/swap remains the escape hatch) — and a
+* struct with nothing to deep-copy (no string, `List`, or nested-copyable
+* field) is already soundly byte-copyable, so it needs no method.
 */
 function struct_is_copyable(struct, status) {
 	if (struct.is_class || struct.is_generic || struct.is_simple_type) return false;
-	if (direct_string_fields(struct).length === 0) return false;
-	if (struct_owns_non_string_heap(struct, status, /* @__PURE__ */ new Set())) return false;
+	if (struct_owns_resource(struct, status, /* @__PURE__ */ new Set())) return false;
+	if (!struct_needs_copy(struct, status)) return false;
 	return struct_copy_ctor_args(struct) !== null;
 }
+/** Whether any field of `struct` actually needs the synthesized deep copy:
+*  a direct string field, a deep-copyable `List<T>` field, or a nested
+*  copyable struct field. A struct of flat values byte-copies soundly
+*  without a method. */
+function struct_needs_copy(struct, status) {
+	if (direct_string_fields(struct).length > 0) return true;
+	for (const field of struct.fields) {
+		if (field.type.is_ref || field.type.is_view || field.type.is_array) continue;
+		if (field_copy_call(field.type, status)) return true;
+	}
+	return false;
+}
+/**
+* Whether `struct` owns a resource a synthesized copy CANNOT duplicate: a
+* `#destroy` that releases something (a raw block / extern free), or a field
+* whose type has no deep-copy story (a class instance, a `List` of
+* class/trait elements, a nested struct with such a field). Fields that DO
+* have a deep-copy story (strings, nested copyables, copyable `List`s,
+* payload-copyable enums) don't block synthesis. Mirrors the old
+* `struct_owns_non_string_heap` gate but understands container deep copies.
+*/
+function struct_owns_resource(struct, status, visited) {
+	if (visited.has(struct.name)) return false;
+	visited.add(struct.name);
+	const destroy = struct.functions.find((f) => f.name === "#destroy");
+	if (destroy && destroy_releases(destroy)) return true;
+	for (const field of struct.fields) {
+		if (field.type.is_ref || field.type.is_view) continue;
+		if (field.type.name === "string" && !field.type.is_array) continue;
+		if (field.type.is_nullable) return true;
+		if (!field_copyable(field.type, status)) return true;
+	}
+	return false;
+}
 /**
 * How a synthesized `copy` constructs the fresh value: the zero-argument
 * `#init` overload when one exists (auto or user), else the bodyless AUTO
@@ -52515,14 +53064,49 @@ function struct_copy_ctor_args(struct) {
 	if (!auto) return null;
 	return auto.params.filter((p) => !p.is_self_param).map((p) => p.name);
 }
-/** Whether `type` names a struct that has (or will get) a `copy` method.
-*  Order-independent: it re-evaluates the eligibility predicate instead of
-*  looking for an already-synthesized method, so an outer struct nested in
-*  the same pre-pass resolves a later-declared field struct. */
-function field_type_is_copyable(type, status) {
+/** Whether `type` has (or will get) a deep-copy story: a struct with a
+*  synthesized `copy`, a `List<T>` whose element is deep-copyable (the
+*  library `List.copy` deep-copies slots via the owning store contract), or
+*  a primitive / plain (payload-free) enum. Order-independent: it
+*  re-evaluates the eligibility predicate instead of looking for an
+*  already-synthesized method, so an outer struct nested in the same
+*  pre-pass resolves a later-declared field struct. */
+function field_copyable(type, status) {
 	if (!type.name || type.is_array || type.is_ref || type.is_view || type.is_nullable) return false;
+	if (type.name === "List" && type.type_args?.length === 1) return element_copyable(type.type_args[0], status);
+	const nested_struct = status.structs.find((s) => s.name === type.name);
+	if (nested_struct) {
+		if (nested_struct.is_simple_type) return true;
+		return struct_is_copyable(nested_struct, status);
+	}
+	const en = status.enums.find((e) => e.name === type.name);
+	if (en) return !en.has_associated_data;
+	return !status.traits.some((t) => t.name === type.name);
+}
+/** Whether a `List<T>` element type is deep-copyable (see
+*  `field_copyable`). */
+function element_copyable(type, status) {
+	if (!type.name || type.is_array || type.is_ref || type.is_view || type.is_nullable) return false;
+	if (type.name === "string") return true;
+	if (type.name === "List" && type.type_args?.length === 1) return element_copyable(type.type_args[0], status);
 	const nested = status.structs.find((s) => s.name === type.name);
-	return !!nested && struct_is_copyable(nested, status);
+	if (nested) {
+		if (nested.is_simple_type) return true;
+		return !nested.is_class && struct_is_copyable(nested, status);
+	}
+	const en = status.enums.find((e) => e.name === type.name);
+	if (en) return !en.has_associated_data;
+	return !status.traits.some((t) => t.name === type.name);
+}
+/** Whether `build_copy` must route the field through a `.copy()` call (a
+*  nested copyable struct, or a `List<T>` field): everything else byte
+*  copies through plain field assignment (strings strdup via the field-write
+*  path, primitives/plain enums are flat values). */
+function field_copy_call(type, status) {
+	if (!type.name || type.is_array || type.is_ref || type.is_view || type.is_nullable) return false;
+	if (type.name === "List" && type.type_args?.length === 1) return element_copyable(type.type_args[0], status);
+	const nested_struct = status.structs.find((s) => s.name === type.name);
+	return !!nested_struct && !nested_struct.is_simple_type && struct_is_copyable(nested_struct, status);
 }
 /**
 * Synthesize `pub func copy(self) -> Struct` for owning value structs: a
@@ -52538,8 +53122,8 @@ function build_copy(struct, status) {
 	const ctor = new FunctionCallNode(-1, struct.name, new Type(struct.name), ctor_args.map((name) => field_access("self", name)));
 	const statements = [new DeclarationNode(-1, "private", "var", "c", new Type(struct.name), ctor)];
 	for (const field of struct.fields) {
-		const right = field_type_is_copyable(field.type, status) ? method_call(field_access("self", field.name), "copy") : field_access("self", field.name);
-		statements.push(new AssignmentNode(-1, field_access("c", field.name), right, "="));
+		const right = field_copy_call(field.type, status) ? method_call(field_access("self", field.name), "copy") : field_access("self", field.name);
+		statements.push(new AssignmentNode(-1, field_access("c", field.name), right));
 	}
 	statements.push(new ReturnNode(-1, new ValueNode(-1, "c")));
 	return new FunctionNode(-1, "pub", "copy", new Type(struct.name), [self_param(struct)], statements);
@@ -53618,7 +54202,10 @@ function monomorphize(generic_struct, type_args, status) {
 					mono_field.type = constructed;
 				}
 			}
-			substitute_raw_in_node(mono_field.value, substitution, status.structs, void 0, status.traits, status.enums);
+			substitute_raw_in_node(mono_field.value, substitution, status.structs, void 0, status.traits, {
+				enums: status.enums,
+				bitsets: status.bitsets
+			});
 		}
 		mono_field.is_library = field.is_library;
 		mono_field.is_readonly = field.is_readonly;
@@ -53653,7 +54240,10 @@ function monomorphize(generic_struct, type_args, status) {
 	for (const func of generic_struct.functions) {
 		if (func.name === "#init") continue;
 		const cloned = clone_node(func);
-		substitute_raw_types(cloned, substitution, status.structs, status.traits, status.enums);
+		substitute_raw_types(cloned, substitution, status.structs, status.traits, {
+			enums: status.enums,
+			bitsets: status.bitsets
+		});
 		fold_substituted_constant_ifs(cloned.statements);
 		rename_local_labels(cloned, mono_name);
 		const retype_roots = [...cloned.statements, ...cloned.allocations ?? []];
@@ -53666,7 +54256,10 @@ function monomorphize(generic_struct, type_args, status) {
 			param.type = substitute_type(param.type, substitution);
 			substitute_param_signature(param, substitution);
 			if (param.type.type_args?.length) param.type = materialize_generic_enum_type(param.type, status);
-			if (param.constraint) substitute_raw_in_node(param.constraint, substitution, status.structs, void 0, status.traits, status.enums);
+			if (param.constraint) substitute_raw_in_node(param.constraint, substitution, status.structs, void 0, status.traits, {
+				enums: status.enums,
+				bitsets: status.bitsets
+			});
 		}
 		retype_param_references(retype_roots, cloned.params);
 		retype_local_references(retype_roots);
@@ -53694,7 +54287,10 @@ function monomorphize(generic_struct, type_args, status) {
 		if (variadic_init_unsupported(generic_init)) continue;
 		if (!generic_init.statements.some((s) => s.node_type !== "raw")) continue;
 		const cloned = clone_node(generic_init);
-		substitute_raw_types(cloned, substitution, status.structs, status.traits, status.enums);
+		substitute_raw_types(cloned, substitution, status.structs, status.traits, {
+			enums: status.enums,
+			bitsets: status.bitsets
+		});
 		fold_substituted_constant_ifs(cloned.statements);
 		rename_local_labels(cloned, mono_name);
 		cloned.return_type = new Type(mono_name);
@@ -53702,7 +54298,10 @@ function monomorphize(generic_struct, type_args, status) {
 		for (const param of cloned.params) {
 			param.type = substitute_type(param.type, substitution);
 			substitute_param_signature(param, substitution);
-			if (param.constraint) substitute_raw_in_node(param.constraint, substitution, status.structs, void 0, status.traits, status.enums);
+			if (param.constraint) substitute_raw_in_node(param.constraint, substitution, status.structs, void 0, status.traits, {
+				enums: status.enums,
+				bitsets: status.bitsets
+			});
 		}
 		const cloned_self = cloned.params.find((p) => p.is_self_param);
 		if (cloned_self) cloned_self.type = new Type(mono_name);
@@ -54207,7 +54806,7 @@ function derive_annotations_for_access_func(access_node, fc, status) {
 		const p = func.params[i];
 		if (p.is_self_param) continue;
 		if (!p.type?.is_nullable) continue;
-		if (status.structs.find((s) => s.name === p.type.name && !s.is_class) || is_nullable_scalar_type(p.type)) nullable_indices.push(i - (self_offset >= 0 ? self_offset + 1 : 0));
+		if (status.structs.find((s) => s.name === p.type.name && !s.is_class) || is_nullable_scalar_type(p.type, status)) nullable_indices.push(i - (self_offset >= 0 ? self_offset + 1 : 0));
 	}
 	if (nullable_indices.length > 0) fc.nullable_param_indices = nullable_indices;
 	if (func.return_constraint && !fc.return_bounds) {
@@ -54586,7 +55185,7 @@ function fold_substituted_constant_ifs(statements) {
 		statements.splice(i, 1, ...kept);
 	}
 }
-function substitute_raw_types(func, substitution, structs, traits, enums) {
+function substitute_raw_types(func, substitution, structs, traits, tables) {
 	const deref_params = /* @__PURE__ */ new Set();
 	for (const param of func.params) {
 		const resolved = substitution.get(param.type.name);
@@ -54595,7 +55194,7 @@ function substitute_raw_types(func, substitution, structs, traits, enums) {
 		const s = structs.find((x) => x.name === resolved);
 		if (s && !s.is_simple_type && !s.is_class) deref_params.add(param.name);
 	}
-	for (const stmt of func.statements) substitute_raw_in_node(stmt, substitution, structs, deref_params, traits, enums);
+	for (const stmt of func.statements) substitute_raw_in_node(stmt, substitution, structs, deref_params, traits, tables);
 }
 function rename_local_labels(node, prefix) {
 	if (node.node_type === "raw") {
@@ -54628,7 +55227,7 @@ function raw_type_alignment(name) {
 function raw_align_to(offset, alignment) {
 	return Math.ceil(offset / alignment) * alignment;
 }
-function raw_type_size(name, structs, enums) {
+function raw_type_size(name, structs, tables) {
 	switch (name) {
 		case "bool":
 		case "int8":
@@ -54639,13 +55238,13 @@ function raw_type_size(name, structs, enums) {
 		case "int32":
 		case "uint32": return 4;
 	}
-	const enum_node = enums?.find((e) => e.name === name && !e.is_generic);
+	const enum_node = tables.enums.find((e) => e.name === name && !e.is_generic);
 	if (enum_node) {
 		if (!enum_node.has_associated_data) return 8;
 		let max_payload = 0;
 		for (const c of enum_node.cases) {
 			let case_size = 0;
-			for (const p of c.params) case_size += raw_type_size(p.type.name, structs, enums);
+			for (const p of c.params) case_size += raw_type_size(p.type.name, structs, tables);
 			max_payload = Math.max(max_payload, case_size);
 		}
 		return 8 + Math.ceil(max_payload / 8) * 8;
@@ -54660,9 +55259,9 @@ function raw_type_size(name, structs, enums) {
 			size += 16;
 			continue;
 		}
-		size += raw_type_size(field.type.name, structs, enums);
+		size += raw_type_size(field.type.name, structs, tables);
 		if (field.type.is_nullable && structs.find((s) => s.name === field.type.name && !s.is_simple_type && !s.is_class)) size += 8;
-		else if (is_nullable_scalar_type(field.type)) size += 1;
+		else if (is_nullable_scalar_type(field.type, tables)) size += 1;
 	}
 	return raw_align_to(size, 8);
 }
@@ -54707,12 +55306,15 @@ function raw_block_is_pure_asm(value) {
 function is_reference_type_arg(t, structs, traits) {
 	return !!traits.some((tr) => tr.name === t.name) || !!structs.find((s) => s.name === t.name && s.is_class);
 }
-function substitute_raw_in_node(node, substitution, structs, deref_params = /* @__PURE__ */ new Set(), traits = [], enums = []) {
+function substitute_raw_in_node(node, substitution, structs, deref_params = /* @__PURE__ */ new Set(), traits = [], tables = {
+	enums: [],
+	bitsets: []
+}) {
 	if (node.node_type === "value") {
 		const vn = node;
 		for (const [param, type] of substitution) {
 			if (vn.value === `${param}_SIZE`) {
-				vn.value = String(raw_type_size(type, structs, enums));
+				vn.value = String(raw_type_size(type, structs, tables));
 				vn.type = new Type("int", true);
 				return;
 			}
@@ -54737,7 +55339,7 @@ function substitute_raw_in_node(node, substitution, structs, deref_params = /* @
 			else if (struct_node) c_type_name = `struct ${type}`;
 			else c_type_name = raw_c_type_name(type);
 			value = value.replace(new RegExp(`\\b${param}\\b`, "g"), c_type_name);
-			const size = raw_type_size(type, structs, enums);
+			const size = raw_type_size(type, structs, tables);
 			const size_expr = raw_block_is_pure_asm(value) ? String(size) : `sizeof(${c_type_name})`;
 			value = value.replace(new RegExp(`\\b${param}_SIZE\\b`, "g"), size_expr);
 			value = value.replace(new RegExp(`\\b${param}_destroy\\b`, "g"), `${type}_destroy`);
@@ -54773,22 +55375,22 @@ function substitute_raw_in_node(node, substitution, structs, deref_params = /* @
 		if (any_node.func_return_type?.name) any_node.func_return_type = substitute_type(any_node.func_return_type, substitution);
 	}
 	if (any_node.allocations && Array.isArray(any_node.allocations)) {
-		for (const child of any_node.allocations) if (child && typeof child === "object" && "node_type" in child) substitute_raw_in_node(child, substitution, structs, deref_params, traits, enums);
+		for (const child of any_node.allocations) if (child && typeof child === "object" && "node_type" in child) substitute_raw_in_node(child, substitution, structs, deref_params, traits, tables);
 	}
 	if (any_node.statements && Array.isArray(any_node.statements)) {
-		for (const child of any_node.statements) if (child && typeof child === "object" && "node_type" in child) substitute_raw_in_node(child, substitution, structs, deref_params, traits, enums);
+		for (const child of any_node.statements) if (child && typeof child === "object" && "node_type" in child) substitute_raw_in_node(child, substitution, structs, deref_params, traits, tables);
 	}
 	if (any_node.params && Array.isArray(any_node.params)) {
-		for (const child of any_node.params) if (child && typeof child === "object" && "node_type" in child) substitute_raw_in_node(child, substitution, structs, deref_params, traits, enums);
+		for (const child of any_node.params) if (child && typeof child === "object" && "node_type" in child) substitute_raw_in_node(child, substitution, structs, deref_params, traits, tables);
 	}
-	if (any_node.value && any_node.value.node_type) substitute_raw_in_node(any_node.value, substitution, structs, deref_params, traits, enums);
-	if (any_node.left_value?.node_type) substitute_raw_in_node(any_node.left_value, substitution, structs, deref_params, traits, enums);
-	if (any_node.right_value?.node_type) substitute_raw_in_node(any_node.right_value, substitution, structs, deref_params, traits, enums);
-	if (any_node.target?.node_type) substitute_raw_in_node(any_node.target, substitution, structs, deref_params, traits, enums);
-	if (any_node.access?.node_type) substitute_raw_in_node(any_node.access, substitution, structs, deref_params, traits, enums);
-	if (any_node.swap?.node_type) substitute_raw_in_node(any_node.swap, substitution, structs, deref_params, traits, enums);
-	if (any_node.condition?.node_type) substitute_raw_in_node(any_node.condition, substitution, structs, deref_params, traits, enums);
-	if (any_node.index?.node_type) substitute_raw_in_node(any_node.index, substitution, structs, deref_params, traits, enums);
+	if (any_node.value && any_node.value.node_type) substitute_raw_in_node(any_node.value, substitution, structs, deref_params, traits, tables);
+	if (any_node.left_value?.node_type) substitute_raw_in_node(any_node.left_value, substitution, structs, deref_params, traits, tables);
+	if (any_node.right_value?.node_type) substitute_raw_in_node(any_node.right_value, substitution, structs, deref_params, traits, tables);
+	if (any_node.target?.node_type) substitute_raw_in_node(any_node.target, substitution, structs, deref_params, traits, tables);
+	if (any_node.access?.node_type) substitute_raw_in_node(any_node.access, substitution, structs, deref_params, traits, tables);
+	if (any_node.swap?.node_type) substitute_raw_in_node(any_node.swap, substitution, structs, deref_params, traits, tables);
+	if (any_node.condition?.node_type) substitute_raw_in_node(any_node.condition, substitution, structs, deref_params, traits, tables);
+	if (any_node.index?.node_type) substitute_raw_in_node(any_node.index, substitution, structs, deref_params, traits, tables);
 }
 function specialize_function(generic_func, call_node, status) {
 	const substitution = /* @__PURE__ */ new Map();
@@ -55760,6 +56362,14 @@ function check_function_call(node, status, func, target_type, self_value, self_p
 	}
 	node.type = func.return_type;
 	node.is_static = func.is_static;
+	if (target_type?.type_args?.length && node.type?.type_args?.length) {
+		const owner = func.scope;
+		if (owner && owner.node_type === "struct" && owner.is_generic && owner.type_params.length === target_type.type_args.length) {
+			const rebind = /* @__PURE__ */ new Map();
+			owner.type_params.forEach((tp, i) => rebind.set(tp, target_type.type_args[i].name));
+			node.type = substitute_type(node.type, rebind);
+		}
+	}
 	if (node.type?.type_args?.length) instantiate_generic_type(node.type, status);
 	if (node.type && node.type.name && self_value && is_class_type$1(node.type.name, status) && receiver_is_const(target_type, self_value, status)) {
 		node.type = clone_type$2(node.type);
@@ -55807,7 +56417,7 @@ function check_function_call(node, status, func, target_type, self_value, self_p
 	for (let [i, param] of node.params.entries()) {
 		const func_param = func.params[i + self_offset];
 		if (func_param && func_param.type.is_nullable && !func_param.is_self_param && !func_param.type.is_ref && !func_param.type.is_array) {
-			if (status.structs.find((st) => st.name === func_param.type.name && !st.is_class && !st.is_simple_type) || is_nullable_scalar_type(func_param.type)) {
+			if (status.structs.find((st) => st.name === func_param.type.name && !st.is_class && !st.is_simple_type) || is_nullable_scalar_type(func_param.type, status)) {
 				if (!node.nullable_param_indices) node.nullable_param_indices = [];
 				if (!node.nullable_param_indices.includes(i)) node.nullable_param_indices.push(i);
 			}
@@ -55943,7 +56553,10 @@ function check_function_call(node, status, func, target_type, self_value, self_p
 			else {
 				const stamped = String(func_param.type.length.value);
 				const incoming = String(param_type.length.value);
-				if (stamped !== incoming) add_error(status, `Call passes ${incoming} elements to array parameter '${func_param.name}' whose compile-time length is ${stamped} — the raw array ABI carries no runtime length, so one parameter serves one compile-time length; use Array<${func_param.type.name}> for varying lengths`, param.start);
+				if (stamped !== incoming) {
+					if (is_heap_array_type(func_param.type)) func_param.type.length = void 0;
+					else add_error(status, `Call passes ${incoming} elements to array parameter '${func_param.name}' whose compile-time length is ${stamped} — the raw array ABI carries no runtime length, so one parameter serves one compile-time length; use Array<${func_param.type.name}> for varying lengths`, param.start);
+				}
 			}
 		}
 		let arg_value;
@@ -56174,6 +56787,13 @@ function check_function_call(node, status, func, target_type, self_value, self_p
 			if (typeof size_val === "number" && size_val > 0) record_buffer_cap(self_path, size_val, status);
 		}
 	}
+	if (self_path && self_path !== "?" && is_bufferish && func.name === "copy") {
+		const source_cap = lookup_buffer_cap(self_path, status);
+		if (source_cap !== void 0) {
+			const lhs_name = find_lhs_var_name(status);
+			if (lhs_name) record_buffer_cap(lhs_name, source_cap, status);
+		}
+	}
 	if (func.return_constraint) {
 		const param_to_arg = /* @__PURE__ */ new Map();
 		if (self_path && self_path !== "?") param_to_arg.set("self", path_to_node(self_path));
@@ -60227,6 +60847,68 @@ function parse_case_branch(status) {
 	return null;
 }
 //#endregion
+//#region ../src/parse/utils/parse_embed_file.ts
+/**
+* `#embed_file("relative/path")` — a compile-time string literal whose value
+* is the contents of the file at parse time. The path resolves against the
+* package root (the directory containing package.jsonc, found by climbing
+* from the entry file), falling back to the entry file's folder; with no
+* known base it resolves against the process CWD.
+*
+* The parsed form is a plain string-literal ValueNode: escapes are encoded
+* with the source-level escape set (`\\`, `\"`, `\n`, `\r`, `\t`, and
+* three-digit octal for other control bytes — self-terminating, matching the
+* escape scanner), so every downstream consumer (length counting, C/asm
+* emission) treats it exactly like a hand-written literal.
+*/
+function parse_embed_file(status) {
+	const start = get_index(status);
+	consume(status);
+	const name = consume(status);
+	if (name !== "embed_file") {
+		add_error(status, `Unknown compiler directive '#${name}' — did you mean '#embed_file'?`, start);
+		return new ValueNode(start, "\"\"");
+	}
+	if (!expect("(", status)) return new ValueNode(start, "\"\"");
+	const path_token = status.tokens[status.i];
+	if (!path_token || !path_token.value.startsWith("\"")) {
+		add_error(status, "Expected a string literal path in #embed_file", start);
+		return new ValueNode(start, "\"\"");
+	}
+	status.i += 1;
+	const rel_path = path_token.value.slice(1, -1);
+	if (!expect(")", status)) return new ValueNode(start, "\"\"");
+	if (!rel_path) {
+		add_error(status, "#embed_file path is empty", start);
+		return new ValueNode(start, "\"\"");
+	}
+	const base = status.embed_root ?? process.cwd();
+	const full = path.isAbsolute(rel_path) ? rel_path : path.join(base, rel_path);
+	let content;
+	try {
+		content = fs.readFileSync(full, "utf8");
+	} catch {
+		add_error(status, `#embed_file could not read '${rel_path}' (resolved '${full}')`, start);
+		return new ValueNode(start, "\"\"");
+	}
+	return new ValueNode(start, `"${escape_embedded(content)}"`);
+}
+/** Encode file contents as a source-level string literal body. */
+function escape_embedded(content) {
+	let out = "";
+	for (const ch of content) {
+		const code = ch.charCodeAt(0);
+		if (ch === "\\") out += "\\\\";
+		else if (ch === "\"") out += "\\\"";
+		else if (ch === "\n") out += "\\n";
+		else if (ch === "\r") out += "\\r";
+		else if (ch === "	") out += "\\t";
+		else if (code < 32 || code === 127) out += `\\${code.toString(8).padStart(3, "0")}`;
+		else out += ch;
+	}
+	return out;
+}
+//#endregion
 //#region ../src/parse/parse_expression.ts
 function restructure_op(start, current_op, current_prec, current_node, expression) {
 	if (current_prec <= operator_precedence(expression.op)) {
@@ -60366,6 +61048,7 @@ function parse_primary(status, value) {
 			expect(")", status);
 			return node;
 		}
+		case "#": return parse_embed_file(status);
 		case "if": return parse_if_else(status);
 		case "match": return parse_match(status);
 		case "switch": return parse_switch(status);
@@ -61508,7 +62191,8 @@ function parse(source, library, file_path, options) {
 		qualified_paths: [],
 		library,
 		errors: [],
-		allow_user_raw: options?.allow_user_raw
+		allow_user_raw: options?.allow_user_raw,
+		embed_root: embed_root_for(file_path)
 	};
 	if (library) status.unsafe_boundary = user_source_length;
 	parse_statement(status);
@@ -61585,6 +62269,23 @@ function mark_library_nodes(root, boundary) {
 	walk(root);
 }
 /**
+* The base directory for `#embed_file` paths: the package root (the nearest
+* enclosing directory with a package.jsonc), falling back to the entry
+* file's folder. No file path — undefined, so `#embed_file` resolves
+* against the process CWD.
+*/
+function embed_root_for(file_path) {
+	if (!file_path) return void 0;
+	let dir = path.dirname(path.resolve(file_path));
+	for (let i = 0; i < 32; i++) {
+		if (fs.existsSync(path.join(dir, "package.jsonc"))) return dir;
+		const parent = path.dirname(dir);
+		if (parent === dir) break;
+		dir = parent;
+	}
+	return path.dirname(path.resolve(file_path));
+}
+/**
 * Append the library source that `source` needs, exactly as `parse` does.
 * Exported so tooling (e.g. the editor extension) can reproduce the combined
 * source that node offsets refer to.
@@ -61838,7 +62539,7 @@ function print_help() {
 		"  nomen check --in [file/folder]    Parse and check only",
 		"  nomen format [--in folder]        Reformat every .nm file",
 		"  nomen docs [--in file]            Generate markdown documentation",
-		"  nomen test [--in folder]          Discover and run *.test.nm files",
+		"  nomen test [--in folder]          Discover and run *.test.nm files (binary CWD = --in folder)",
 		"  nomen init <name>                 Scaffold a new project in ./<name>",
 		"  nomen lib-path                    Print the bundled System library path",
 		"",
@@ -62428,7 +63129,7 @@ function extract_leaks(stdout) {
 * Compile one `*.test.nm` file (with the generated harness) and run it,
 * returning its parsed records and any crash info.
 */
-function run_test_file(entry_path, lib_path, arch, audit = false, audit_runtime) {
+function run_test_file(entry_path, lib_path, arch, audit = false, audit_runtime, release = false, cwd) {
 	const start = performance.now();
 	const source_text = fs.readFileSync(entry_path, "utf8");
 	const harness = generate_harness(extract_test_functions(source_text), extract_bench_functions(source_text));
@@ -62455,7 +63156,8 @@ function run_test_file(entry_path, lib_path, arch, audit = false, audit_runtime)
 	}
 	const buildResult = build(parsed.root, {
 		arch,
-		audit
+		audit,
+		optimize: release
 	});
 	if (buildResult.errors && buildResult.errors.length) {
 		result.ok = false;
@@ -62490,11 +63192,19 @@ function run_test_file(entry_path, lib_path, arch, audit = false, audit_runtime)
 	const outfile = path.join(buildDir, path.basename(entry_path, ".nm"));
 	fs.writeFileSync(path.join(buildDir, "main.h"), buildResult.headers ?? "");
 	fs.writeFileSync(codefile, buildResult.code);
+	let companionfile;
+	if (buildResult.companion) {
+		const comp_ext = platform === "macos" || platform === "ios" ? ".m" : ".c";
+		companionfile = path.join(buildDir, path.basename(entry_path, ".nm") + "_companion" + comp_ext);
+		fs.writeFileSync(companionfile, buildResult.companion);
+	}
 	const link_args = [
 		"-o",
 		outfile,
 		codefile
 	];
+	if (companionfile) link_args.push(companionfile);
+	if (release) link_args.unshift("-O2");
 	if (audit_obj) link_args.push(audit_obj);
 	if (platform === "macos" || platform === "ios") link_args.push("-framework", "CoreGraphics", "-framework", "Foundation", "-framework", "AppKit", "-lobjc");
 	try {
@@ -62525,7 +63235,8 @@ function run_test_file(entry_path, lib_path, arch, audit = false, audit_runtime)
 				"pipe"
 			],
 			timeout: 3e4,
-			maxBuffer: 16777216
+			maxBuffer: 16777216,
+			cwd: cwd ?? process.cwd()
 		});
 	} catch (err) {
 		runStdout = err.stdout ? err.stdout.toString() : "";
@@ -62607,9 +63318,10 @@ function runTests(root, options = {}) {
 	const files = collect_test_files(root).filter((f) => !options.filter || options.filter.test(f));
 	console.log(`Found ${files.length} test file(s)\n`);
 	const startTime = performance.now();
+	const binary_cwd = path.resolve(root);
 	const results = [];
 	for (const file of files) {
-		const result = run_test_file(file, lib, arch, options.audit, options.audit_runtime);
+		const result = run_test_file(file, lib, arch, options.audit, options.audit_runtime, options.release, binary_cwd);
 		report_file(result);
 		results.push(result);
 	}
@@ -62717,7 +63429,8 @@ try {
 			arch: args.arch ?? "aarch64",
 			filter,
 			audit: args.audit,
-			audit_runtime: args.audit_runtime
+			audit_runtime: args.audit_runtime,
+			release: args.release
 		});
 		process.exit(ok ? 0 : 1);
 	}