nomen-lang 0.6.6 → 0.6.7

package/dist/index.mjs

@@ -7147,14 +7147,37 @@ function call_result_type(node) {
 * so `null == 0` conflates them. Nullable `string` (in-band fat zero) and
 * nullable `func`/class values (null pointer) keep their in-band null and
 * are NOT nullable scalars.
+*
+* The same holds for a nullable SIMPLE enum (`Color?`) or bitset
+* (`Permissions?`): the in-band zero (the first case's tag 0 / an empty
+* bitset) is a real value, so `null` needs the companion flag. Enum-with-data
+* and generic template enums are NOT nullable scalars — the checker rejects
+* `?` on enums with associated data, so every nullable enum that reaches the
+* backends is simple.
 */
-/** True if `type` is a nullable built-in scalar (`bool?`, `int?`, `float?`, …). */
-function is_nullable_scalar_type(type) {
+/** True if the TYPE NAME is a built-in scalar, simple enum, or bitset — the
+*  shapes that get the `<slot>_has` flag when nullable. */
+function is_nullable_scalar_name(name, tables) {
+	if (!name) return false;
+	const info = get_built_in_type(name);
+	if (info) return info.kind !== "string" && info.kind !== "func";
+	const enum_node = tables.enums.findLast((e) => (e.name === name || e.source_name === name) && !e.is_generic);
+	if (enum_node) return !enum_node.has_associated_data;
+	return tables.bitsets.some((b) => b.name === name || b.source_name === name);
+}
+/** True if `type` is a nullable built-in scalar, simple enum, or bitset. */
+function is_nullable_scalar_type(type, tables) {
 	if (!type?.is_nullable) return false;
 	if (type.is_array || type.is_ref || type.storage_kind === "view") return false;
 	if (type.is_pointer) return false;
-	const info = type.name ? get_built_in_type(type.name) : void 0;
-	return !!info && info.kind !== "string" && info.kind !== "func";
+	return is_nullable_scalar_name(type.name, tables);
+}
+/** True if `type` is a nullable struct (see nullable_struct.ts) or nullable scalar. */
+function is_nullable_flagged_type(type, status) {
+	if (!type?.is_nullable) return false;
+	if (type.name === "string") return false;
+	if (type.name === "func") return false;
+	return is_nullable_scalar_type(type, status) || !!status.structs.find((s) => s.name === type.name && !s.is_class && !s.is_simple_type);
 }
 //#endregion
 //#region ../src/build_common/nullable_struct.ts
@@ -8084,7 +8107,7 @@ var AssignmentNode = class extends BaseNode {
 		super("assign", start);
 		this.left_value = left_value;
 		this.right_value = right_value;
-		this.operator = operator;
+		this.operator = operator === "=" ? void 0 : operator;
 	}
 };
 //#endregion
@@ -12011,7 +12034,7 @@ function get_struct_size(name, status) {
 		size = align_to(size, get_type_alignment(field.type, status));
 		size += get_type_size(field.type, status);
 		if (is_nullable_struct_type(field.type, status)) size += 8;
-		else if (is_nullable_scalar_type(field.type)) size += 1;
+		else if (is_nullable_scalar_type(field.type, status)) size += 1;
 	}
 	size = align_to(size, 8);
 	return size;
@@ -12063,7 +12086,7 @@ function get_field_offset_of_fields(fields, field_name, status) {
 		if (field.name === field_name) return offset;
 		offset += get_type_size(field.type, status);
 		if (is_nullable_struct_type(field.type, status)) offset += 8;
-		else if (is_nullable_scalar_type(field.type)) offset += 1;
+		else if (is_nullable_scalar_type(field.type, status)) offset += 1;
 	}
 	return offset;
 }
@@ -17729,7 +17752,7 @@ function owning_buffer_element_aarch64(node, status) {
 	const elem_name = node.name.substring(7);
 	const elem = status.structs.find((s) => s.name === elem_name && !s.is_simple_type && !s.is_generic);
 	if (!elem || elem.is_class) return void 0;
-	if (!has_string_fields(elem, status)) return void 0;
+	if (!has_string_fields(elem, status) && !struct_needs_destroy(elem, status)) return void 0;
 	return elem;
 }
 /**
@@ -17875,6 +17898,75 @@ function collect_string_fields(elem, status, base_offset = 0) {
 	return result;
 }
 /**
+* Collect the (offset, size) pairs of every owned CONTAINER field (`List<T>`/
+* `Buffer<T>`/… mono with a `#destroy`) the element's teardown would reclaim.
+* The owning store_T/replace_T memcpy the source's bytes into the slot, so
+* zeroing these fields of the SOURCE completes the ownership transfer: the
+* slot is the sole owner and the source's own teardown (when it still runs)
+* finds zeroed fields. Nested value struct fields recurse so their container
+* leaves are zeroed at their own flat offsets; their string fields are
+* untouched (the slot owns the strdup'd copies via collect_string_fields).
+* Mirrors the C backend's `emit_transfer_owning_fields`. `view T`/nullable
+* fields are skipped; class/enum payload fields are left alone (recorded in
+* FOLLOWUP.md).
+*/
+function collect_transfer_fields(elem, status, base_offset = 0) {
+	const result = [];
+	let offset = 8;
+	for (const field of elem.fields) {
+		const size = get_type_size(field.type, status);
+		if (!field.type.is_ref && !field.type.is_view && !field.type.is_array && !field.type.is_nullable) {
+			const field_struct = resolve_struct_type(field.type, status);
+			if (field_struct && !field_struct.is_class) {
+				if (has_destroy(field_struct)) result.push({
+					offset: base_offset + offset,
+					size
+				});
+				else if (struct_needs_destroy(field_struct, status)) result.push(...collect_transfer_fields(field_struct, status, base_offset + offset));
+			}
+		}
+		offset += size;
+	}
+	return result;
+}
+/**
+* Emit `memset(&src.field, 0, size)` for every owned field collected by
+* `collect_transfer_fields`. `src` is the register holding the SOURCE struct
+* address (x2 inline / x21 standalone for store_T). Clobbers x0-x2.
+*/
+function emit_transfer_owning_fields$1(status, src, fields) {
+	for (const { offset, size } of fields) {
+		emit_asm(status, `add x0, ${src}, #${offset}\n`);
+		emit_asm(status, `mov x1, #0\n`);
+		emit_asm(status, `mov x2, #${size}\n`);
+		emit_asm(status, `bl _memset\n`);
+	}
+}
+/**
+* Emit the deep-copy half of owning load_T into the sret buffer (x8): for
+* each `List<T>` field whose mono has a `copy` method, replace the
+* shallow-copied field with `<List_T>_copy(&slot.field)` (sret → the sret
+* buffer's field; self == x8 is safe — the copy reads its input before the
+* final result write). Mirrors the C backend's `emit_load_deep_copy_fields`.
+* `sret` is the register holding the returned struct's address; `slot` holds
+* the source slot's address (the copy reads from the slot, writes to sret).
+*/
+function emit_load_deep_copy_fields$1(elem, status, sret, slot) {
+	let offset = 8;
+	for (const field of elem.fields) {
+		const size = get_type_size(field.type, status);
+		if (!field.type.is_ref && !field.type.is_view && !field.type.is_array && !field.type.is_nullable && field.type.name !== "string") {
+			const field_struct = resolve_struct_type(field.type, status);
+			if (field_struct && !field_struct.is_class && field_struct.name.startsWith("List_") && struct_needs_destroy(field_struct, status) && field_struct.functions.find((f) => f.name === "copy")) {
+				emit_asm(status, `add x8, ${sret}, #${offset}\n`);
+				emit_asm(status, `add x0, ${slot}, #${offset}\n`);
+				emit_asm(status, `bl ${field_struct.name}_copy\n`);
+			}
+		}
+		offset += size;
+	}
+}
+/**
 * Emit `slot.field = strdup(src.field)` guarded against a NULL source field
 * (e.g. JsonTree's "no text" sentinel): a NULL field is copied as NULL —
 * strdup(NULL) would crash. `src`/`dst` are the register names holding the
@@ -17912,6 +18004,10 @@ function emit_owning_buffer_inline_aarch64(struct_node, func_name, status) {
 			emit_owning_shift_T(elem, status, "x0");
 			return true;
 		}
+		if (func_name === "load") {
+			emit_owning_load_T(elem, status, "x0");
+			return true;
+		}
 		return false;
 	}
 	const enum_elem = owning_buffer_enum_element_aarch64(struct_node, status);
@@ -17973,7 +18069,7 @@ function emit_owning_buffer_inline_aarch64(struct_node, func_name, status) {
 function emit_owning_buffer_standalone_aarch64(node, func_name, status) {
 	const elem = owning_buffer_element_aarch64(node, status);
 	if (elem) {
-		if (func_name !== "store" && func_name !== "replace" && func_name !== "shift" && func_name !== "modify") return false;
+		if (func_name !== "store" && func_name !== "replace" && func_name !== "shift" && func_name !== "modify" && func_name !== "load") return false;
 		emit_owning_standalone_struct(elem, func_name, status);
 		return true;
 	}
@@ -18032,6 +18128,7 @@ function emit_owning_buffer_standalone_aarch64(node, func_name, status) {
 function emit_owning_standalone_struct(elem, func_name, status) {
 	const T_SIZE = get_struct_size(elem.name, status);
 	const string_fields = collect_string_fields(elem, status);
+	const transfer_fields = collect_transfer_fields(elem, status);
 	if (func_name === "shift") {
 		emit_owning_shift_T(elem, status, "x19");
 		return true;
@@ -18040,6 +18137,23 @@ function emit_owning_standalone_struct(elem, func_name, status) {
 		emit_owning_modify_T(elem, status, T_SIZE, string_fields);
 		return true;
 	}
+	if (func_name === "load") {
+		emit_asm(status, `stp x20, x21, [sp, #-16]!\n`);
+		emit_asm(status, `stp x22, x23, [sp, #-16]!\n`);
+		emit_asm(status, `ldr x20, [x19, #8]\n`);
+		emit_asm(status, `mov x9, #${T_SIZE}\n`);
+		emit_asm(status, `madd x21, x1, x9, x20\n`);
+		emit_asm(status, `mov x22, x8\n`);
+		emit_asm(status, `mov x0, x22\n`);
+		emit_asm(status, `mov x1, x21\n`);
+		emit_asm(status, `mov x2, x9\n`);
+		emit_asm(status, `bl _memcpy\n`);
+		emit_load_deep_copy_fields$1(elem, status, "x22", "x21");
+		emit_asm(status, `mov x0, x22\n`);
+		emit_asm(status, `ldp x22, x23, [sp], #16\n`);
+		emit_asm(status, `ldp x20, x21, [sp], #16\n`);
+		return true;
+	}
 	emit_asm(status, `stp x20, x21, [sp, #-16]!\n`);
 	emit_asm(status, `str x22, [sp, #-16]!\n`);
 	emit_asm(status, `ldr x20, [x19, #8]\n`);
@@ -18077,6 +18191,7 @@ function emit_owning_standalone_struct(elem, func_name, status) {
 		}
 		if (string_fields.length) emit_asm(status, `add sp, sp, #${Math.ceil(string_fields.length * 8 / 16) * 16}\n`);
 	} else for (const { offset: foff } of string_fields) emit_strdup_field(status, "x21", "x20", foff, status.label_counter = (status.label_counter ?? 0) + 1);
+	emit_transfer_owning_fields$1(status, "x21", transfer_fields);
 	emit_asm(status, `ldr x22, [sp], #16\n`);
 	emit_asm(status, `ldp x20, x21, [sp], #16\n`);
 	return true;
@@ -18278,9 +18393,35 @@ function emit_owning_shift_T(elem, status, self_reg) {
 	emit_asm(status, `ldr x22, [sp], #16\n`);
 	emit_asm(status, `ldp x20, x21, [sp], #16\n`);
 }
+/**
+* Specialized owning-value-struct load_T (inline context: x0 = self, x1 = i,
+* x8 = sret). The caller's scope-exit destroy ALWAYS reclaims a struct
+* local's container fields, so the returned copy must own independent
+* containers — a shallow return would double-free the slot's buffer at the
+* caller's teardown. String fields stay borrowed (struct-local teardown only
+* frees RECORDED heap strings, so a strdup here would leak).
+*/
+function emit_owning_load_T(elem, status, self_reg) {
+	const T_SIZE = get_struct_size(elem.name, status);
+	emit_asm(status, `stp x20, x21, [sp, #-16]!\n`);
+	emit_asm(status, `stp x22, x23, [sp, #-16]!\n`);
+	emit_asm(status, `ldr x20, [${self_reg}, #8]\n`);
+	emit_asm(status, `mov x9, #${T_SIZE}\n`);
+	emit_asm(status, `madd x21, x1, x9, x20\n`);
+	emit_asm(status, `mov x22, x8\n`);
+	emit_asm(status, `mov x0, x22\n`);
+	emit_asm(status, `mov x1, x21\n`);
+	emit_asm(status, `mov x2, x9\n`);
+	emit_asm(status, `bl _memcpy\n`);
+	emit_load_deep_copy_fields$1(elem, status, "x22", "x21");
+	emit_asm(status, `mov x0, x22\n`);
+	emit_asm(status, `ldp x22, x23, [sp], #16\n`);
+	emit_asm(status, `ldp x20, x21, [sp], #16\n`);
+}
 function emit_owning_store_T(elem, status) {
 	const T_SIZE = get_struct_size(elem.name, status);
 	const string_fields = collect_string_fields(elem, status);
+	const transfer_fields = collect_transfer_fields(elem, status);
 	emit_asm(status, `stp x20, x21, [sp, #-16]!\n`);
 	emit_asm(status, `str x22, [sp, #-16]!\n`);
 	emit_asm(status, `ldr x20, [x0, #8]\n`);
@@ -18312,12 +18453,14 @@ function emit_owning_store_T(elem, status) {
 		emit_asm(status, `${lbl}:\n`);
 	}
 	if (string_fields.length) emit_asm(status, `add sp, sp, #${Math.ceil(string_fields.length * 8 / 16) * 16}\n`);
+	emit_transfer_owning_fields$1(status, "x21", transfer_fields);
 	emit_asm(status, `ldr x22, [sp], #16\n`);
 	emit_asm(status, `ldp x20, x21, [sp], #16\n`);
 }
 function emit_owning_replace_T(elem, status) {
 	const T_SIZE = get_struct_size(elem.name, status);
 	const string_fields = collect_string_fields(elem, status);
+	const transfer_fields = collect_transfer_fields(elem, status);
 	emit_asm(status, `stp x20, x21, [sp, #-16]!\n`);
 	emit_asm(status, `str x22, [sp, #-16]!\n`);
 	emit_asm(status, `ldr x20, [x0, #8]\n`);
@@ -18332,6 +18475,7 @@ function emit_owning_replace_T(elem, status) {
 	emit_asm(status, `mov x2, x22\n`);
 	emit_asm(status, `bl _memcpy\n`);
 	for (const { offset: foff } of string_fields) emit_strdup_field(status, "x21", "x20", foff, status.label_counter = (status.label_counter ?? 0) + 1);
+	emit_transfer_owning_fields$1(status, "x21", transfer_fields);
 	emit_asm(status, `ldr x22, [sp], #16\n`);
 	emit_asm(status, `ldp x20, x21, [sp], #16\n`);
 }
@@ -19996,7 +20140,7 @@ function build_function_node$1(node, status) {
 	status.code = "";
 	node.return_type = resolve_mono_type(node.return_type, status);
 	const return_struct = !node.return_type.is_view && !node.return_type.is_array && (!!status.structs.find((s) => s.name === node.return_type.name && !s.is_simple_type && !s.is_class) || get_enum_sret_size(node.return_type.name, status) !== void 0);
-	const nullable_scalar_ret = is_nullable_scalar_type(node.return_type) && !node.return_type.is_ref;
+	const nullable_scalar_ret = is_nullable_scalar_type(node.return_type, status) && !node.return_type.is_ref;
 	const uses_sret = return_struct || nullable_scalar_ret;
 	if (uses_sret) status.struct_return_buffer = "x8";
 	status.function_return_type = node.return_type;
@@ -20083,7 +20227,7 @@ function build_function_node$1(node, status) {
 				first_pass_slot += 2;
 				continue;
 			}
-			if (is_nullable_scalar_type(param.type)) {
+			if (is_nullable_scalar_type(param.type, status)) {
 				first_pass_slot += 2;
 				continue;
 			}
@@ -20250,7 +20394,7 @@ function build_function_node$1(node, status) {
 				param_idx += 2;
 				continue;
 			}
-			if (is_nullable_scalar_type(param.type) && !param.type.is_ref && !param.type.is_array) {
+			if (is_nullable_scalar_type(param.type, status) && !param.type.is_ref && !param.type.is_array) {
 				const size = aarch64_size(param.type.name);
 				const offset = allocate_stack_space(status, size, size);
 				status.stack_offsets.set(param.name, offset);
@@ -20666,7 +20810,7 @@ function init_enum_shorthand_field_default(node, field, base_reg, status) {
 * struct base register (`x0` for auto-init, `x19` for custom-init).
 */
 function init_nullable_field_default(node, field, base_reg, status) {
-	const scalar_nullable = is_nullable_scalar_type(field.type);
+	const scalar_nullable = is_nullable_scalar_type(field.type, status);
 	if (!is_nullable_struct_type(field.type, status) && !scalar_nullable) return false;
 	if (!field.value) return false;
 	const offset = get_field_offset(node.name, field.name, status);
@@ -21008,7 +21152,7 @@ function build_init_function(node, status) {
 		const slot = ctor_slot;
 		const field_is_view = !!field.type.is_view && !field.type.is_array;
 		const field_is_fat_string = field.type.name === "string" && !field.type.is_view && !field.type.is_ref && !field.type.is_array;
-		const field_is_nullable_scalar = is_nullable_scalar_type(field.type);
+		const field_is_nullable_scalar = is_nullable_scalar_type(field.type, status);
 		if (field_is_view || field_is_fat_string || field_is_nullable_scalar) ctor_slot += 2;
 		else ctor_slot += 1;
 		let src_reg;
@@ -21186,9 +21330,9 @@ function build_init_function(node, status) {
 			if (node.fields.find((nf) => nf.name === field.name)) continue;
 			const offset = get_field_offset(node.name, field.name, status);
 			const val = field.value.node_type === "value" ? field.value.value : void 0;
-			if (val === "null" && (is_nullable_scalar_type(field.type) || is_nullable_struct_type(field.type, status))) {
+			if (val === "null" && (is_nullable_scalar_type(field.type, status) || is_nullable_struct_type(field.type, status))) {
 				const has_off = get_field_has_offset(node.name, field.name, status);
-				if (is_nullable_scalar_type(field.type)) emit_asm(status, `strb wzr, [x19, #${has_off}]\n`);
+				if (is_nullable_scalar_type(field.type, status)) emit_asm(status, `strb wzr, [x19, #${has_off}]\n`);
 				else emit_asm(status, `str xzr, [x19, #${has_off}]\n`);
 				continue;
 			}
@@ -21329,7 +21473,7 @@ function build_custom_init_function(node, func, status) {
 			param_idx += 2;
 			continue;
 		}
-		if (is_nullable_scalar_type(param.type) && !param.type.is_ref && !param.type.is_array) {
+		if (is_nullable_scalar_type(param.type, status) && !param.type.is_ref && !param.type.is_array) {
 			const size = aarch64_size(param.type.name);
 			const offset = allocate_stack_space(status, size, size);
 			status.stack_offsets.set(param.name, offset);
@@ -21620,7 +21764,7 @@ function build_struct_functions$1(node, status) {
 		status.function_view_params = /* @__PURE__ */ new Set();
 		status.struct_return_buffer = void 0;
 		const return_struct = !func.return_type?.is_array && (!!status.structs.find((s) => s.name === func.return_type?.name && !s.is_simple_type && !s.is_class) || get_enum_sret_size(func.return_type?.name, status) !== void 0);
-		const nullable_scalar_ret = !!func.return_type && is_nullable_scalar_type(func.return_type) && !func.return_type.is_ref;
+		const nullable_scalar_ret = !!func.return_type && is_nullable_scalar_type(func.return_type, status) && !func.return_type.is_ref;
 		const uses_sret = return_struct || nullable_scalar_ret;
 		let return_buffer_stack_offset;
 		status.current_function_name = func.name;
@@ -21647,7 +21791,7 @@ function build_struct_functions$1(node, status) {
 				slot_idx += 2;
 				continue;
 			}
-			if (is_nullable_scalar_type(param.type) && !param.type.is_ref) {
+			if (is_nullable_scalar_type(param.type, status) && !param.type.is_ref) {
 				if (param.declaration === "var") status.function_param_vars.add(param.name);
 				slot_idx += 2;
 				continue;
@@ -21730,7 +21874,7 @@ function build_struct_functions$1(node, status) {
 				second_slot_idx += 2;
 				continue;
 			}
-			if (is_nullable_scalar_type(param.type) && !param.type.is_ref) {
+			if (is_nullable_scalar_type(param.type, status) && !param.type.is_ref) {
 				const size = aarch64_size(param.type.name);
 				const offset = allocate_stack_space(status, size, size);
 				status.stack_offsets.set(param.name, offset);
@@ -23189,11 +23333,11 @@ function build_constructor_params(fc, param_regs, status) {
 		let nullable_scalar = false;
 		if (fc.nullable_param_indices?.includes(i)) {
 			const cp = ctor_callee_params?.[i];
-			if (cp && is_nullable_scalar_type(cp.type)) nullable_scalar = true;
-			else if (is_nullable_scalar_type(p.type)) nullable_scalar = true;
+			if (cp && is_nullable_scalar_type(cp.type, status)) nullable_scalar = true;
+			else if (is_nullable_scalar_type(p.type, status)) nullable_scalar = true;
 			else if (!cp) {
 				const field = (status.structs.find((s) => s.name === fc.name && !s.is_simple_type)?.fields.filter((f) => f.value == null))?.[i];
-				if (field && is_nullable_scalar_type(field.type)) nullable_scalar = true;
+				if (field && is_nullable_scalar_type(field.type, status)) nullable_scalar = true;
 			}
 		}
 		const is_pair = pt === "string" || lit || is_view || nullable_scalar;
@@ -23220,7 +23364,7 @@ function build_constructor_params(fc, param_regs, status) {
 			if (arg.node_type === "value" && arg.value === "null") {
 				emit_asm(status, `mov x0, #0\n`);
 				emit_asm(status, `mov x1, #0\n`);
-			} else if (arg.node_type === "value" && is_nullable_scalar_type(arg.type)) {
+			} else if (arg.node_type === "value" && is_nullable_scalar_type(arg.type, status)) {
 				const vname = arg.value;
 				emit_var_load(status, "x0", vname, aarch64_size(arg.type.name));
 				emit_var_load(status, "x1", has_flag_name(vname), 8);
@@ -23610,7 +23754,7 @@ function build_declaration_node$1(node, status, nir_init, nir_swap) {
 		emit_var_store(status, "x0", node.name, 8);
 		return;
 	}
-	if (is_nullable_scalar_type(node.type)) {
+	if (is_nullable_scalar_type(node.type, status)) {
 		if (status.function_return_label) {
 			const offset = allocate_stack_space(status, 16, 16);
 			status.stack_offsets.set(node.name, offset);
@@ -23621,14 +23765,23 @@ function build_declaration_node$1(node, status, nir_init, nir_swap) {
 			}
 			const init_value = node.value;
 			const init_type = call_result_type(init_value) ?? type_from_value_node$1(init_value);
-			const value_is_nullable_call = init_value.node_type === "func_call" && is_nullable_scalar_type(init_type);
-			if (init_value.node_type === "access" && is_nullable_scalar_type(init_type)) {
+			const value_is_nullable_call = init_value.node_type === "func_call" && is_nullable_scalar_type(init_type, status);
+			const value_is_nullable_method = init_value.node_type === "access" && init_value.access.node_type === "access_func" && is_nullable_scalar_type(init_type, status);
+			const value_is_nullable_field = init_value.node_type === "access" && init_value.access.node_type === "access_field" && is_nullable_scalar_type(init_type, status);
+			if (value_is_nullable_method) {
 				emit_init_value$1(init_value, nir_init, status);
 				ensure_newline(status);
 				emit_asm(status, `ldr x9, [x0]\n`);
 				emit_asm(status, `str x9, [x29, #${offset}]\n`);
 				emit_asm(status, `ldr x9, [x0, #8]\n`);
 				emit_asm(status, `str x9, [x29, #${offset + 8}]\n`);
+			} else if (value_is_nullable_field) {
+				emit_init_value$1(init_value, nir_init, status);
+				ensure_newline(status);
+				emit_var_store(status, "x0", node.name, 8);
+				load_nullable_has(init_value, "x9", status);
+				ensure_newline(status);
+				emit_asm(status, `str x9, [x29, #${offset + 8}]\n`);
 			} else if (value_is_nullable_call) {
 				const old_buffer = status.struct_return_buffer;
 				const old_buffer_var = status.struct_return_buffer_var;
@@ -23650,8 +23803,13 @@ function build_declaration_node$1(node, status, nir_init, nir_swap) {
 			}
 			return;
 		}
-		emit_data(status, `${node.name}: .space 16\n`);
-		status.stack_offsets.set(has_flag_name(node.name), -1);
+		const global_is_null = !node.value || node.value.node_type === "value" && node.value.value === "null";
+		if (global_is_null) emit_data(status, `${node.name}: .space 8\n`);
+		else {
+			emit_data(status, `${node.name}: ${aarch64_type(node.type.name)} ${get_raw_value$1(node.value, status)}\n`);
+			if (aarch64_size(node.type.name) < 8) emit_data(status, `.p2align 3\n`);
+		}
+		emit_data(status, `${has_flag_name(node.name)}: .quad ${global_is_null ? 0 : 1}\n`);
 		return;
 	}
 	const directive = aarch64_type(node.type.name);
@@ -26115,7 +26273,7 @@ function build_return_node$1(node, status, nir_value) {
 	hoist_field_overrides(node.value, build_node, status);
 	if (node.from_inline) return;
 	const returns_nullable_struct = is_nullable_struct_type(status.function_return_type, status);
-	const returns_nullable_scalar = is_nullable_scalar_type(status.function_return_type);
+	const returns_nullable_scalar = is_nullable_scalar_type(status.function_return_type, status);
 	if ((returns_nullable_struct || returns_nullable_scalar) && (!node.value || node.value.node_type === "value" && node.value.value === "null")) {
 		if (status.return_buffer_stack_offset !== void 0) {
 			const struct_size = get_struct_size(status.function_return_type.name, status);
@@ -26305,7 +26463,7 @@ function build_return_node$1(node, status, nir_value) {
 		if (status.return_buffer_stack_offset !== void 0) emit_asm(status, `ldr x8, [x29, #${status.return_buffer_stack_offset}]\n`);
 		emit_typed_store(status, "x0", "x8", 0, aarch64_size(status.function_return_type.name));
 		const value_type = node.value ? type_from_value_node$1(node.value) : void 0;
-		if (node.value && value_type?.is_nullable && is_nullable_scalar_type(value_type)) {
+		if (node.value && value_type?.is_nullable && is_nullable_scalar_type(value_type, status)) {
 			load_nullable_has(node.value, "x9", status);
 			ensure_newline(status);
 			emit_asm(status, `str x9, [x8, #8]\n`);
@@ -29935,7 +30093,7 @@ function build_function_call_node$1(node, status) {
 				if (!node.nullable_param_indices?.includes(i)) continue;
 				const arg_type = node.params[i].type;
 				const callee_param = node.resolved_function?.params?.[i];
-				if (is_nullable_scalar_type(arg_type) || callee_param && is_nullable_scalar_type(callee_param.type)) nullable_scalar_arg_set.add(i);
+				if (is_nullable_scalar_type(arg_type, status) || callee_param && is_nullable_scalar_type(callee_param.type, status)) nullable_scalar_arg_set.add(i);
 			}
 			const arg_slot = [];
 			let total_slots = 0;
@@ -30033,7 +30191,7 @@ function build_function_call_node$1(node, status) {
 					if (arg.node_type === "value" && arg.value === "null") {
 						emit_asm(status, `mov x0, #0\n`);
 						emit_asm(status, `mov x1, #0\n`);
-					} else if (arg.node_type === "value" && is_nullable_scalar_type(arg.type)) {
+					} else if (arg.node_type === "value" && is_nullable_scalar_type(arg.type, status)) {
 						const vname = arg.value;
 						emit_var_load(status, "x0", vname, aarch64_size(param_type.name));
 						emit_var_load(status, "x1", has_flag_name(vname), 8);
@@ -30147,7 +30305,7 @@ function build_function_call_node$1(node, status) {
 		} else if (!is_struct && node.type?.name && !status.call_x8_preset) {
 			const return_struct = status.structs.find((s) => s.name === node.type.name && !s.is_simple_type && !s.is_class);
 			const return_enum_size = get_enum_sret_size(node.type?.name, status);
-			const nullable_scalar_ret = is_nullable_scalar_type(node.type);
+			const nullable_scalar_ret = is_nullable_scalar_type(node.type, status);
 			if (return_struct || return_enum_size !== void 0 || nullable_scalar_ret) {
 				const nullable_ret = is_nullable_struct_type(node.type, status);
 				const struct_size = return_struct ? get_struct_size(node.type.name, status) : nullable_scalar_ret ? 8 : return_enum_size;
@@ -30203,7 +30361,7 @@ function build_function_call_node$1(node, status) {
 		if (!is_struct && node.type?.name && !status.call_x8_preset) {
 			const return_struct = status.structs.find((s) => s.name === node.type.name && !s.is_simple_type && !s.is_class);
 			const return_enum_size = get_enum_sret_size(node.type?.name, status);
-			const nullable_scalar_ret = is_nullable_scalar_type(node.type);
+			const nullable_scalar_ret = is_nullable_scalar_type(node.type, status);
 			if (return_struct || return_enum_size !== void 0 || nullable_scalar_ret) {
 				const temp_name = `_call_ret_${temp_counter - 1}`;
 				emit_asm(status, `add x0, x29, #${status.stack_offsets.get(temp_name)}\n`);
@@ -31078,7 +31236,7 @@ function build_struct_body(node, status) {
 		status.code += `];\n`;
 	} else {
 		status.code += `${field_c_type(field.type, status)} ${field.name};\n`;
-		if (is_nullable_struct_type(field.type, status) || is_nullable_scalar_type(field.type)) status.code += `unsigned char ${has_flag_name(field.name)};\n`;
+		if (is_nullable_struct_type(field.type, status) || is_nullable_scalar_type(field.type, status)) status.code += `unsigned char ${has_flag_name(field.name)};\n`;
 	}
 	for (let traitName of node.traits) {
 		const trait = status.traits.find((n) => n.name === traitName);
@@ -31210,8 +31368,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 +31431,8 @@ function build_operation_node$1(node, status) {
 			else status.code += `((`;
 			build_node$1(nullable_side, status);
 			status.code += `.ptr != 0))`;
-		} else if (is_nullable_scalar_type(type_from_value_node$1(nullable_side)) && type?.is_nullable && type.name !== "string") {
-			if (nullable_side.node_type === "func_call" && is_nullable_scalar_type(nullable_side.type)) {
+		} else if (is_nullable_scalar_type(type_from_value_node$1(nullable_side), status) && type?.is_nullable && type.name !== "string") {
+			if (nullable_side.node_type === "func_call" && is_nullable_scalar_type(nullable_side.type, status)) {
 				const id = ns_tmp_counter++;
 				const flag = `_nsh_${id}`;
 				const val = `_nsv_${id}`;
@@ -31438,7 +31596,7 @@ function is_null_comparison(node) {
 }
 function is_nullable_struct_side(node, status) {
 	const t = type_from_value_node$1(node);
-	return is_nullable_struct_type(t, status) || is_nullable_scalar_type(t);
+	return is_nullable_struct_type(t, status) || is_nullable_scalar_type(t, status);
 }
 /**
 * Build the companion `_has` flag expression for a nullable-struct or
@@ -31456,8 +31614,8 @@ function is_nullable_struct_side(node, status) {
 function build_nullable_has(node, status) {
 	if (node.node_type === "value") {
 		const name = node.value;
-		if (status.function_ref_params?.has(name) && (is_nullable_struct_type(node.type, status) || is_nullable_scalar_type(node.type))) return has_flag_name(name);
-		if (is_nullable_struct_type(node.type, status) || is_nullable_scalar_type(node.type)) return has_flag_name(name);
+		if (status.function_ref_params?.has(name) && (is_nullable_struct_type(node.type, status) || is_nullable_scalar_type(node.type, status))) return has_flag_name(name);
+		if (is_nullable_struct_type(node.type, status) || is_nullable_scalar_type(node.type, status)) return has_flag_name(name);
 	}
 	const saved = begin_code_scratch(status);
 	build_node$1(node, status);
@@ -33122,7 +33280,7 @@ function build_assignment_node$1(node, status, nir_rhs, nir_swap) {
 		if (rhs_is_null) status.code += `${flag} = 0`;
 		else {
 			const call_ret = call_result_type(node.right_value);
-			if (!!call_ret && (is_nullable_struct_type(call_ret, status) || is_nullable_scalar_type(call_ret))) {
+			if (!!call_ret && (is_nullable_struct_type(call_ret, status) || is_nullable_scalar_type(call_ret, status))) {
 				const old = status.current_nullable_call_flag;
 				status.current_nullable_call_flag = flag;
 				status.code += `${lhs_expr} = `;
@@ -33592,11 +33750,11 @@ function lhs_nullable_struct_type(node, status) {
 	if (node.left_value.node_type === "value") {
 		const name = node.left_value.value;
 		const t = status.scoped_declarations.find((d) => d.name === name)?.type || status.variable_types?.get(name);
-		return is_nullable_struct_type(t, status) || is_nullable_scalar_type(t);
+		return is_nullable_struct_type(t, status) || is_nullable_scalar_type(t, status);
 	}
 	if (node.left_value.node_type === "access" && node.left_value.access.node_type === "access_field") {
 		const field_type = node.left_value.access.type;
-		return is_nullable_struct_type(field_type, status) || is_nullable_scalar_type(field_type);
+		return is_nullable_struct_type(field_type, status) || is_nullable_scalar_type(field_type, status);
 	}
 	return false;
 }
@@ -33609,7 +33767,7 @@ function lhs_nullable_struct_type(node, status) {
 function nullable_value_flag_expr(value, status) {
 	const t = type_from_value_node$1(value);
 	if (!t?.is_nullable) return void 0;
-	if (!is_nullable_struct_type(t, status) && !is_nullable_scalar_type(t)) return void 0;
+	if (!is_nullable_struct_type(t, status) && !is_nullable_scalar_type(t, status)) return void 0;
 	if (value.node_type === "value") return has_flag_name(value.value);
 	if (value.node_type === "access" && value.access.node_type === "access_field") {
 		const saved = begin_code_scratch(status);
@@ -34340,32 +34498,37 @@ function build_declaration_node(node, status, nir_init, nir_swap) {
 				status.stack_array_lengths.set(safe_name, len_text);
 			}
 		}
-		if (is_nullable_struct_type(node.type, status) || is_nullable_scalar_type(node.type)) {
+		if (is_nullable_struct_type(node.type, status) || is_nullable_scalar_type(node.type, status)) {
 			const flag = has_flag_name(safe_name);
 			const is_null = !node.value || node.value.node_type === "value" && node.value.value === "null";
-			if (!status.current_function && is_nullable_scalar_type(node.type)) {
-				status.code += `;\nunsigned char ${flag} = ${is_null ? 0 : 1}`;
-				if (is_null) return;
-			} else {
-				status.code += `;\nunsigned char ${flag} = 0`;
-				if (node.value && !is_null) {
-					const call_ret = call_result_type(node.value);
-					const value_is_nullable_call = !!call_ret && (is_nullable_struct_type(call_ret, status) || is_nullable_scalar_type(call_ret));
-					status.code += `;\n${safe_name} = `;
-					if (value_is_nullable_call) {
-						const old = status.current_nullable_call_flag;
-						status.current_nullable_call_flag = flag;
-						emit_init_value(node.value, nir_init, status);
-						status.current_nullable_call_flag = old;
-						record_call_init_string_fields(node, status);
-					} else {
-						const rhs_flag = nullable_value_flag_expr(node.value, status);
-						emit_init_value(node.value, nir_init, status);
-						status.code += `;\n${flag} = ${rhs_flag ?? "1"}`;
-					}
+			if (!status.current_function && is_nullable_scalar_type(node.type, status)) {
+				if (is_null) {
+					status.code += `;\nunsigned char ${flag} = 0`;
+					return;
 				}
+				status.code += ` = `;
+				emit_init_value(node.value, nir_init, status);
+				status.code += `;\nunsigned char ${flag} = 1`;
 				return;
 			}
+			status.code += `;\nunsigned char ${flag} = 0`;
+			if (node.value && !is_null) {
+				const call_ret = call_result_type(node.value);
+				const value_is_nullable_call = !!call_ret && (is_nullable_struct_type(call_ret, status) || is_nullable_scalar_type(call_ret, status));
+				status.code += `;\n${safe_name} = `;
+				if (value_is_nullable_call) {
+					const old = status.current_nullable_call_flag;
+					status.current_nullable_call_flag = flag;
+					emit_init_value(node.value, nir_init, status);
+					status.current_nullable_call_flag = old;
+					record_call_init_string_fields(node, status);
+				} else {
+					const rhs_flag = nullable_value_flag_expr(node.value, status);
+					emit_init_value(node.value, nir_init, status);
+					status.code += `;\n${flag} = ${rhs_flag ?? "1"}`;
+				}
+			}
+			return;
 		}
 		if (node.value) {
 			const is_heap_literal_init = node.is_heap_array_literal || node.type.storage_kind === "heap_array" && (node.value.node_type === "array" || node.value.node_type === "range");
@@ -34982,7 +35145,7 @@ function build_return_node(node, status, nir_value) {
 			emit_nursery_joins_on_return_c(status);
 			reclaim_all_c_scopes(status);
 			status.code += `*${ret_has} = 0;\n`;
-			if (status.function_return_type && is_nullable_scalar_type(status.function_return_type)) status.code += `return (${c_type(status.function_return_type.name)})0;\n`;
+			if (status.function_return_type && is_nullable_scalar_type(status.function_return_type, status)) status.code += `return (${c_type(status.function_return_type.name)})0;\n`;
 			else status.code += `return (struct ${status.function_return_type.name}){0};\n`;
 			return;
 		}
@@ -35215,7 +35378,7 @@ function nullable_flag_expr_of_value(value, status) {
 	if (!value) return void 0;
 	const t = type_from_value_node$1(value);
 	if (!t?.is_nullable) return void 0;
-	if (!(is_nullable_struct_type(t, status) || is_nullable_scalar_type(t))) return void 0;
+	if (!(is_nullable_struct_type(t, status) || is_nullable_scalar_type(t, status))) return void 0;
 	if (value.node_type === "value") return has_flag_name(value.value);
 	if (value.node_type === "access") {
 		const saved = begin_code_scratch(status);
@@ -35657,20 +35820,78 @@ function has_owning_fields(node, status) {
 }
 /**
 * The names of Buffer methods that get specialized for owning value structs.
-* load_T and move_T are NOT specialized: load_T returns a shallow copy (a
-* borrow — the caller's struct local is not destroyed, so no double-free);
-* move_T transfers ownership (the slot is zeroed, the caller takes the
-* pointers).
+* load_T IS specialized when the element has owning container fields (a
+* `List<T>` member): the returned copy must own independent containers, or
+* the caller's scope-exit destroy would free the slot's buffer (double-free
+* at container teardown). String fields stay BORROWED on load (struct-local
+* teardown only frees RECORDED heap strings, so strdup'ing them would leak);
+* container fields have no such borrow convention — a struct local's
+* container fields are ALWAYS destroyed — so they must be deep-copied.
+* move_T is NOT specialized: it transfers ownership (the slot is zeroed, the
+* caller takes the pointers).
 */
 const OWNING_BUFFER_METHODS = /* @__PURE__ */ new Set([
 	"store",
 	"replace",
+	"load",
 	"modify",
 	"shift",
 	"destroy",
 	"#destroy"
 ]);
 /**
+* Emit the transfer half of owning store_T/replace_T: the slot bytes were
+* already memcpy'd from the source, so zeroing each owned CONTAINER field
+* of the SOURCE completes the move — the slot is the sole owner, and the
+* source's own teardown (when it still runs: an unstamped generic-body
+* local) finds zeroed fields and reclaims nothing. Nested value struct
+* fields recurse so their container leaves are zeroed at their own paths;
+* their string fields are untouched (the slot aliases them — the pre-existing
+* nested-string convention). Class/enum payload fields are left alone
+* (recorded in FOLLOWUP.md).
+*/
+function emit_transfer_owning_fields(elem, src, status, prefix = "") {
+	for (const field of elem.fields) {
+		if (field.type.is_ref || field.type.is_view) continue;
+		if (field.type.is_array || field.type.is_nullable) continue;
+		const field_struct = resolve_struct_type(field.type, status);
+		if (!field_struct || field_struct.is_class) continue;
+		const src_field = `${prefix}${src}${arrow(src)}${field.name}`;
+		if (has_destroy(field_struct)) status.code += `memset((void*)&${src_field}, 0, sizeof(${src_field}));\n`;
+		else if (struct_needs_destroy(field_struct, status)) emit_transfer_owning_fields(field_struct, src_field, status, "");
+	}
+}
+/**
+* Emit the deep-copy half of owning load_T: for each field whose type has a
+* monomorphized `copy` helper that yields an independent value (a `List<T>`
+* field — `<List_T>_copy` deep-copies slots per the owning store contract —
+* or an enum-with-data field whose string payloads `<E>_copy` duplicates),
+* overwrite the shallow-copied bytes with an owned copy. Fields without a
+* copyable shape (nested owning user structs, class fields) stay shallow —
+* recorded in FOLLOWUP.md ("remaining shallow container-field shapes").
+*/
+function emit_load_deep_copy_fields(elem, dst, status) {
+	for (const field of elem.fields) {
+		if (field.type.is_ref || field.type.is_view || field.type.is_array) continue;
+		if (field.type.is_nullable) continue;
+		if (field.type.name === "string") continue;
+		const field_struct = resolve_struct_type(field.type, status);
+		if (field_struct && !field_struct.is_class && field_struct.name.startsWith("List_") && struct_needs_destroy(field_struct, status) && field_struct.functions.find((f) => f.name === "copy")) {
+			status.code += `${dst}.${field.name} = ${field_struct.name}_copy(&${dst}.${field.name});\n`;
+			continue;
+		}
+		const field_enum = status.enums.find((e) => e.name === field.type.name && e.has_associated_data);
+		if (field_enum && enum_copy_is_deep(field_enum, status)) status.code += `${dst}.${field.name} = ${field_enum.name}_copy(${dst}.${field.name});\n`;
+	}
+}
+/** Whether `<E>_copy` yields a fully independent value: no case payload is a
+*  class/trait reference (those are shared pointers the copy cannot
+*  duplicate — mirroring owning_buffer_enum_element's gate). */
+function enum_copy_is_deep(elem, status) {
+	for (const c of elem.cases) for (const p of c.params) if (status.structs.find((s) => s.name === p.type.name)?.is_class || status.traits.find((t) => t.name === p.type.name)) return false;
+	return true;
+}
+/**
 * A `Buffer<string>` owns an independent heap copy of each slot (strdup on
 * store_T, free+strdup on replace_T, per-slot free on #destroy). The element
 * is a primitive, so this is a separate path from the value-struct
@@ -35833,6 +36054,13 @@ function emit_owning_buffer_body(func_name, elem, status) {
 		status.code += `struct ${elem.name} _old = _slots[i];\n`;
 		status.code += `_slots[i] = (*val);\n`;
 		emit_deep_copy_fields(elem, "_slots[i]", "val", status, "_old");
+		emit_transfer_owning_fields(elem, "val", status);
+		return true;
+	}
+	if (func_name === "load") {
+		status.code += `struct ${elem.name} _loaded = ((struct ${elem.name} *)(unsigned long long)self->data)[i];\n`;
+		emit_load_deep_copy_fields(elem, "_loaded", status);
+		status.code += `return _loaded;\n`;
 		return true;
 	}
 	if (func_name === "modify") {
@@ -35847,6 +36075,7 @@ function emit_owning_buffer_body(func_name, elem, status) {
 		status.code += `${elem.name}_destroy(&_slots[i]);\n`;
 		status.code += `_slots[i] = (*val);\n`;
 		emit_deep_copy_fields(elem, "_slots[i]", "val", status);
+		emit_transfer_owning_fields(elem, "val", status);
 		return true;
 	}
 	if (func_name === "shift") {
@@ -35873,12 +36102,13 @@ function emit_owning_buffer_body(func_name, elem, status) {
 	return false;
 }
 /**
-* For each string field on the element struct, overwrite the shallow-copied
-* pointer in `dst` with a fresh strdup of `src`'s field. This breaks the
-* pointer aliasing between the source and the slot so each can be destroyed
-* independently. For nested owning value struct fields, recursively call the
-* nested struct's destroy + deep-copy (the nested destroy frees the
-* shallow-copied owned sub-fields, then the deep-copy re-strdup's them).
+* For each DIRECT string field on the element struct, overwrite the
+* shallow-copied pointer in `dst` with a fresh strdup of `src`'s field. This
+* breaks the pointer aliasing between the source and the slot so each can be
+* destroyed independently. Nested value struct fields are NOT walked: their
+* string fields stay aliased (the pre-existing convention — a spliced
+* `move` donor has no teardown, so the slot is the sole owner), and their
+* container leaves are transferred by `emit_transfer_owning_fields`.
 *
 * `old_expr` (optional) is the slot's PRE-copy value expression. When the
 * source field pointer equals the old slot field pointer, the slot already
@@ -35896,12 +36126,6 @@ function emit_deep_copy_fields(elem, dst, src, status, old_expr) {
 			const src_field = `${src}${arrow(src)}${field.name}`;
 			if (old_expr) status.code += `${dst}.${field.name} = (${src_field}.ptr && ${src_field}.ptr != ${old_expr}.${field.name}.ptr) ? nomen_str_dup(${src_field}) : ${src_field};\n`;
 			else status.code += `${dst}.${field.name} = ${src_field}.ptr ? nomen_str_dup(${src_field}) : ${src_field};\n`;
-		} else if (field.type.name && !field.type.is_array) {
-			const field_struct = status.structs.find((s) => s.name === field.type.name && !s.is_simple_type && !s.is_generic);
-			if (field_struct && !field_struct.is_class && struct_needs_destroy(field_struct, status)) {
-				status.code += `${field_struct.name}_destroy(&${dst}.${field.name});\n`;
-				emit_deep_copy_fields(field_struct, `${dst}.${field.name}`, `${src}${arrow(src)}${field.name}`, status);
-			}
 		}
 	}
 }
@@ -36049,7 +36273,7 @@ function build_struct_node(node, status) {
 	const ctor_return = is_class ? `struct ${node.name}*` : `struct ${node.name}`;
 	const field_params = node.fields.filter((f) => f.value == null).map((f) => {
 		let decl = c_param_decl(f.type, f.name, status);
-		if (is_nullable_struct_type(f.type, status) || is_nullable_scalar_type(f.type)) decl += `, unsigned char ${has_flag_name(f.name)}`;
+		if (is_nullable_struct_type(f.type, status) || is_nullable_scalar_type(f.type, status)) decl += `, unsigned char ${has_flag_name(f.name)}`;
 		return decl;
 	}).join(", ");
 	const ctor_sig = (init) => {
@@ -36060,7 +36284,7 @@ function build_struct_node(node, status) {
 				is_ref: p.is_ref || p.type.is_ref,
 				declaration: p.declaration
 			});
-			if (!p.is_variadic && (is_nullable_struct_type(p.type, status) || is_nullable_scalar_type(p.type))) decl += `, unsigned char ${has_flag_name(p.name)}`;
+			if (!p.is_variadic && (is_nullable_struct_type(p.type, status) || is_nullable_scalar_type(p.type, status))) decl += `, unsigned char ${has_flag_name(p.name)}`;
 			return decl;
 		}).join(", ");
 		const label = is_overloaded(node, "#init") ? mangled_label(init, node.name) : `${node.name}_init`;
@@ -36088,7 +36312,7 @@ function build_struct_node(node, status) {
 						build_node$1(field.value, status);
 						status.code += `; self${accessor}${field.name} = (nomen_view){ _p.ptr, _p.len }; }\n`;
 					} else status.code += `self${accessor}${field.name} = (nomen_view){0};\n`;
-				} else if (is_nullable_struct_type(field.type, status) || is_nullable_scalar_type(field.type)) {
+				} else if (is_nullable_struct_type(field.type, status) || is_nullable_scalar_type(field.type, status)) {
 					if (field.value.node_type === "value" && field.value.value === "null") status.code += `self${accessor}${has_flag_name(field.name)} = 0;\n`;
 					else {
 						status.code += `self${accessor}${field.name} = `;
@@ -36166,7 +36390,7 @@ function build_struct_node(node, status) {
 				status.code += `; ${object_name}${accessor}${field.name} = (nomen_view){ _p.ptr, _p.len }; }\n`;
 			} else status.code += `${object_name}${accessor}${field.name} = (nomen_view){0};\n`;
 		} else if (field.type.storage_kind === "stack_array" && field.type.length) status.code += `memcpy(${object_name}${accessor}${field.name}, ${field.name}, sizeof(${object_name}${accessor}${field.name}));\n`;
-		else if ((is_nullable_struct_type(field.type, status) || is_nullable_scalar_type(field.type)) && field.value) {
+		else if ((is_nullable_struct_type(field.type, status) || is_nullable_scalar_type(field.type, status)) && field.value) {
 			if (field.value.node_type === "value" && field.value.value === "null") status.code += `${object_name}${accessor}${has_flag_name(field.name)} = 0;\n`;
 			else {
 				status.code += `${object_name}${accessor}${field.name} = `;
@@ -36176,7 +36400,7 @@ function build_struct_node(node, status) {
 		} else if (is_nullable_struct_type(field.type, status)) {
 			status.code += `${object_name}${accessor}${field.name} = *${field.name};\n`;
 			status.code += `${object_name}${accessor}${has_flag_name(field.name)} = ${has_flag_name(field.name)};\n`;
-		} else if (is_nullable_scalar_type(field.type)) {
+		} else if (is_nullable_scalar_type(field.type, status)) {
 			status.code += `${object_name}${accessor}${field.name} = ${field.name};\n`;
 			status.code += `${object_name}${accessor}${has_flag_name(field.name)} = ${has_flag_name(field.name)};\n`;
 		} else if (!field.type.is_ref && !field.type.is_view && status.enums.find((e) => e.name === field.type.name && e.has_associated_data)) {
@@ -36314,7 +36538,7 @@ function build_struct_functions(node, status, skip_init = false) {
 		status.force_heap_strings = scan_force_heap_strings(func.statements ?? [], status.structs);
 		status.function_return_type = func.return_type;
 		const old_nullable_ret_has = status.nullable_ret_has_param;
-		if (is_nullable_struct_type(func.return_type, status) || is_nullable_scalar_type(func.return_type)) status.nullable_ret_has_param = "_ret_has";
+		if (is_nullable_struct_type(func.return_type, status) || is_nullable_scalar_type(func.return_type, status)) status.nullable_ret_has_param = "_ret_has";
 		else status.nullable_ret_has_param = void 0;
 		const self_param = func.params[0]?.is_self_param ? func.params[0] : null;
 		status.self_is_ref = !!self_param?.is_ref || self_param?.declaration === "var";
@@ -36371,9 +36595,9 @@ function build_struct_functions(node, status, skip_init = false) {
 		for (let i = 0; i < func.params.length; i++) {
 			if (i > 0) status.code += ", ";
 			build_parameter_node(func.params[i], status);
-			if (!func.params[i].is_self_param && (is_nullable_struct_type(func.params[i].type, status) || is_nullable_scalar_type(func.params[i].type))) status.code += `, unsigned char ${has_flag_name(c_function_name(func.params[i].name))}`;
+			if (!func.params[i].is_self_param && (is_nullable_struct_type(func.params[i].type, status) || is_nullable_scalar_type(func.params[i].type, status))) status.code += `, unsigned char ${has_flag_name(c_function_name(func.params[i].name))}`;
 		}
-		if (is_nullable_struct_type(func.return_type, status) || is_nullable_scalar_type(func.return_type)) {
+		if (is_nullable_struct_type(func.return_type, status) || is_nullable_scalar_type(func.return_type, status)) {
 			if (func.params.length > 0) status.code += `, `;
 			status.code += `unsigned char *_ret_has`;
 		}
@@ -37134,9 +37358,9 @@ function build_function_node(node, status) {
 			first_param = false;
 			if (node.params[i].is_variadic) status.code += `long _${node.params[i].name}_len, `;
 			build_parameter_node(node.params[i], status);
-			if ((is_nullable_struct_type(node.params[i].type, status) || is_nullable_scalar_type(node.params[i].type)) && !node.params[i].is_self_param) status.code += `, unsigned char ${has_flag_name(c_function_name(node.params[i].name))}`;
+			if ((is_nullable_struct_type(node.params[i].type, status) || is_nullable_scalar_type(node.params[i].type, status)) && !node.params[i].is_self_param) status.code += `, unsigned char ${has_flag_name(c_function_name(node.params[i].name))}`;
 		}
-		if (is_nullable_struct_type(node.return_type, status) || is_nullable_scalar_type(node.return_type)) {
+		if (is_nullable_struct_type(node.return_type, status) || is_nullable_scalar_type(node.return_type, status)) {
 			if (!first_param) status.code += ", ";
 			status.code += `unsigned char *_ret_has`;
 		}
@@ -37189,7 +37413,7 @@ function build_function_node(node, status) {
 	const old_variable_types = status.variable_types;
 	status.variable_types = /* @__PURE__ */ new Map();
 	const old_nullable_ret_has = status.nullable_ret_has_param;
-	if (is_nullable_struct_type(node.return_type, status) || is_nullable_scalar_type(node.return_type)) status.nullable_ret_has_param = "_ret_has";
+	if (is_nullable_struct_type(node.return_type, status) || is_nullable_scalar_type(node.return_type, status)) status.nullable_ret_has_param = "_ret_has";
 	else status.nullable_ret_has_param = void 0;
 	const old_function_name = status.current_function_name;
 	status.current_function_name = emission_label(node);
@@ -37576,7 +37800,7 @@ function build_function_call_node(node, status) {
 	const lambda_ret_c = lambda_arg_temps.size > 0 ? c_return_type(node.type, status) : void 0;
 	const lambda_ret_tmp = lambda_ret_c && lambda_ret_c !== "void" ? next_lambda_ret_temp() : void 0;
 	if (lambda_ret_tmp) status.code += `${lambda_ret_c} ${lambda_ret_tmp} = `;
-	const saved_call = (is_nullable_struct_type(node.type, status) || is_nullable_scalar_type(node.type)) && !status.current_nullable_call_flag ? begin_code_scratch(status) : void 0;
+	const saved_call = (is_nullable_struct_type(node.type, status) || is_nullable_scalar_type(node.type, status)) && !status.current_nullable_call_flag ? begin_code_scratch(status) : void 0;
 	let wrap_tmp;
 	status.code += `${func_name}(${is_closure_callee ? "NULL" : ""}`;
 	if (is_closure_callee && node.params.length > 0) status.code += ", ";
@@ -37617,7 +37841,7 @@ function build_function_call_node(node, status) {
 		}
 		if (node.nullable_param_indices?.includes(i) && node.params[i].node_type === "value" && node.params[i].value === "null") {
 			const callee_null_param_type = callee_params?.[i]?.type ?? param_type;
-			if (is_nullable_scalar_type(callee_null_param_type)) status.code += `0, 0`;
+			if (is_nullable_scalar_type(callee_null_param_type, status)) status.code += `0, 0`;
 			else status.code += `(void *)&(struct ${mono_type_name(callee_null_param_type)}){0}, 0`;
 			continue;
 		}
@@ -37703,7 +37927,7 @@ function build_function_call_node(node, status) {
 			emit_nullable_arg_flag(node.params[i], status);
 		}
 	}
-	if (is_nullable_struct_type(node.type, status) || is_nullable_scalar_type(node.type)) {
+	if (is_nullable_struct_type(node.type, status) || is_nullable_scalar_type(node.type, status)) {
 		const flag_name = status.current_nullable_call_flag;
 		const arg_list_empty = node.params.length === 0 && !is_closure_callee;
 		if (flag_name) status.code += `${arg_list_empty ? "" : ", "}&${flag_name}`;
@@ -37812,13 +38036,13 @@ function emit_nullable_arg_flag(arg, status) {
 	}
 	if (arg.node_type === "value") {
 		const vn = arg;
-		if (is_nullable_struct_type(vn.type, status) || is_nullable_scalar_type(vn.type)) status.code += `${has_flag_name(vn.value)}`;
+		if (is_nullable_struct_type(vn.type, status) || is_nullable_scalar_type(vn.type, status)) status.code += `${has_flag_name(vn.value)}`;
 		else status.code += `1`;
 		return;
 	}
 	if (arg.node_type === "access" && arg.access.node_type === "access_field") {
 		const t = type_from_value_node$1(arg);
-		if (is_nullable_struct_type(t, status) || is_nullable_scalar_type(t)) {
+		if (is_nullable_struct_type(t, status) || is_nullable_scalar_type(t, status)) {
 			const saved = begin_code_scratch(status);
 			build_node$1(arg, status);
 			const expr = end_code_scratch(status, saved);
@@ -38620,13 +38844,13 @@ function build_access_node$1(node, status) {
 						build_node$1(access_func.params[i], status);
 						status.suppress_dereference = false;
 					}
-					if (target_param && !target_param.is_self_param && (is_nullable_struct_type(target_param.type, status) || is_nullable_scalar_type(target_param.type))) {
+					if (target_param && !target_param.is_self_param && (is_nullable_struct_type(target_param.type, status) || is_nullable_scalar_type(target_param.type, status))) {
 						status.code += `, `;
 						emit_nullable_arg_flag(access_func.params[i], status);
 					}
 				}
 				const method_ret_type = (target_method ?? trait_default_func)?.return_type ?? access_func.type;
-				if (is_nullable_struct_type(method_ret_type, status) || is_nullable_scalar_type(method_ret_type)) {
+				if (is_nullable_struct_type(method_ret_type, status) || is_nullable_scalar_type(method_ret_type, status)) {
 					const flag_name = status.current_nullable_call_flag;
 					status.code += `, `;
 					status.code += flag_name ? `&${flag_name}` : `(unsigned char *)&(unsigned char){0}`;
@@ -40371,11 +40595,11 @@ function is_nullable_struct_assignment(node, status) {
 	if (node.left_value.node_type === "value") {
 		const name = node.left_value.value;
 		const t = status.scoped_declarations.find((d) => d.name === name)?.type || status.variable_types?.get(name);
-		return is_nullable_struct_type(t, status) || is_nullable_scalar_type(t);
+		return is_nullable_struct_type(t, status) || is_nullable_scalar_type(t, status);
 	}
 	if (node.left_value.node_type === "access" && node.left_value.access.node_type === "access_field") {
 		const field_type = node.left_value.access.type;
-		return is_nullable_struct_type(field_type, status) || is_nullable_scalar_type(field_type);
+		return is_nullable_struct_type(field_type, status) || is_nullable_scalar_type(field_type, status);
 	}
 	return false;
 }
@@ -40430,7 +40654,7 @@ function build_nullable_struct_assignment(node, status, nir_rhs) {
 		const flag_name = has_flag_name(name);
 		const decl_type = status.scoped_declarations.find((d) => d.name === name)?.type || status.variable_types?.get(name);
 		const type_name = decl_type?.name || "";
-		const is_scalar = is_nullable_scalar_type(decl_type);
+		const is_scalar = is_nullable_scalar_type(decl_type, status);
 		const scalar_size = is_scalar ? aarch64_size(type_name) : 0;
 		const reclaimable = !(node.right_value.node_type === "value" && node.right_value.value === name) && !!status.heap_string_fields?.size && Array.from(status.heap_string_fields).some((k) => k.startsWith(`${name}.`));
 		if (rhs_is_null) {
@@ -40449,9 +40673,11 @@ function build_nullable_struct_assignment(node, status, nir_rhs) {
 				}
 			}
 		};
-		const value_is_nullable_call = node.right_value.node_type === "func_call" && (is_nullable_struct_type(node.right_value.type, status) || is_nullable_scalar_type(node.right_value.type));
+		const value_is_nullable_call = node.right_value.node_type === "func_call" && (is_nullable_struct_type(node.right_value.type, status) || is_nullable_scalar_type(node.right_value.type, status));
 		const rhs_value_type = call_result_type(node.right_value) ?? type_from_value_node$1(node.right_value);
-		if (node.right_value.node_type === "access" && rhs_value_type?.is_nullable && (is_nullable_struct_type(rhs_value_type, status) || is_nullable_scalar_type(rhs_value_type))) {
+		const value_is_nullable_access = node.right_value.node_type === "access" && rhs_value_type?.is_nullable && (is_nullable_struct_type(rhs_value_type, status) || is_nullable_scalar_type(rhs_value_type, status));
+		const rhs_is_field_read = value_is_nullable_access && is_nullable_scalar_type(rhs_value_type, status) && node.right_value.access.node_type === "access_field";
+		if (value_is_nullable_access && !rhs_is_field_read) {
 			if (reclaimable) emit_recorded_field_reclaim_for_slot(status, name, type_name);
 			retarget_records();
 			emit_rhs_value(node.right_value, nir_rhs, status);
@@ -40468,6 +40694,17 @@ function build_nullable_struct_assignment(node, status, nir_rhs) {
 			emit_var_store(status, "x9", flag_name, 8);
 			return;
 		}
+		if (rhs_is_field_read) {
+			if (reclaimable) emit_recorded_field_reclaim_for_slot(status, name, type_name);
+			retarget_records();
+			emit_rhs_value(node.right_value, nir_rhs, status);
+			ensure_newline(status);
+			emit_var_store(status, "x0", name, scalar_size);
+			load_nullable_has(node.right_value, "x9", status);
+			ensure_newline(status);
+			emit_var_store(status, "x9", flag_name, 8);
+			return;
+		}
 		if (value_is_nullable_call) {
 			if (reclaimable) emit_recorded_field_reclaim_for_slot(status, name, type_name);
 			retarget_records();
@@ -40484,7 +40721,7 @@ function build_nullable_struct_assignment(node, status, nir_rhs) {
 			status.call_x8_preset = old_preset;
 			return;
 		}
-		const rhs_is_nullable_value = !!rhs_value_type?.is_nullable && (is_nullable_struct_type(rhs_value_type, status) || is_nullable_scalar_type(rhs_value_type));
+		const rhs_is_nullable_value = !!rhs_value_type?.is_nullable && (is_nullable_struct_type(rhs_value_type, status) || is_nullable_scalar_type(rhs_value_type, status));
 		let rhs_flag_slot;
 		if (rhs_is_nullable_value) {
 			load_nullable_has(node.right_value, "x9", status);
@@ -40521,7 +40758,7 @@ function build_nullable_struct_assignment(node, status, nir_rhs) {
 	const field_offset = get_field_offset(target_type.name, field_name, status);
 	const has_offset = get_field_has_offset(target_type.name, field_name, status);
 	const struct_size = get_struct_size(type_name, status);
-	const field_is_scalar = is_nullable_scalar_type(field_access.type);
+	const field_is_scalar = is_nullable_scalar_type(field_access.type, status);
 	get_source_address(access.target, status);
 	ensure_newline(status);
 	emit_asm(status, `str x0, [sp, #-16]!\n`);
@@ -40532,7 +40769,7 @@ function build_nullable_struct_assignment(node, status, nir_rhs) {
 		return;
 	}
 	const rhs_t = call_result_type(node.right_value) ?? type_from_value_node$1(node.right_value);
-	const rhs_is_nullable_value = !!rhs_t?.is_nullable && (is_nullable_struct_type(rhs_t, status) || is_nullable_scalar_type(rhs_t));
+	const rhs_is_nullable_value = !!rhs_t?.is_nullable && (is_nullable_struct_type(rhs_t, status) || is_nullable_scalar_type(rhs_t, status));
 	let rhs_flag_slot;
 	if (rhs_is_nullable_value) {
 		load_nullable_has(node.right_value, "x10", status);
@@ -42357,7 +42594,7 @@ function build_operation_node(node, status) {
 	if (node.op === "??") {
 		const left_t = type_from_value_node$1(node.left_value);
 		const left_is_nullable_struct = is_nullable_struct_type(left_t, status);
-		const left_is_nullable_scalar = is_nullable_scalar_type(left_t);
+		const left_is_nullable_scalar = is_nullable_scalar_type(left_t, status);
 		if (left_is_nullable_scalar && node.left_value.node_type === "func_call") {
 			build_operand(node.left_value, "x0", status);
 			ensure_newline(status);
@@ -42409,11 +42646,11 @@ function build_operation_node(node, status) {
 	if ((node.op === "==" || node.op === "!=") && is_null_literal$1(node.left_value) !== is_null_literal$1(node.right_value)) {
 		const nullable_flagged_side = (n) => {
 			const t = type_from_value_node$1(n);
-			return is_nullable_struct_type(t, status) || is_nullable_scalar_type(t);
+			return is_nullable_struct_type(t, status) || is_nullable_scalar_type(t, status);
 		};
 		const nullable_side = nullable_flagged_side(node.left_value) ? node.left_value : node.right_value;
 		const side_type = type_from_value_node$1(nullable_side);
-		if (is_nullable_struct_type(side_type, status) || is_nullable_scalar_type(side_type)) {
+		if (is_nullable_struct_type(side_type, status) || is_nullable_scalar_type(side_type, status)) {
 			load_nullable_has(nullable_side, "x1", status);
 			ensure_newline(status);
 			emit_asm(status, `cmp x1, #0\n`);
@@ -42931,7 +43168,7 @@ function load_nullable_has(node, target_reg, status) {
 			get_source_address(access.target, status);
 			ensure_newline(status);
 			if (target_reg !== "x0") emit_asm(status, `mov ${target_reg}, x0\n`);
-			const scalar_field = is_nullable_scalar_type(access.access.type);
+			const scalar_field = is_nullable_scalar_type(access.access.type, status);
 			const wreg = target_reg.replace("x", "w");
 			const load_op = scalar_field ? `ldrb ${wreg}` : `ldr ${target_reg}`;
 			if (has_off === 0) emit_asm(status, `${load_op}, [${target_reg}]\n`);
@@ -45133,7 +45370,7 @@ function build_access_method(node, access_func, status) {
 	const access_callee_params = access_callee_method?.params?.filter((p) => !p.is_self_param);
 	const return_struct = !access_func.type.is_view && !access_func.type.is_array && (!!status.structs.find((s) => s.name === access_func.type.name && !s.is_simple_type && !s.is_class) || get_enum_sret_size(access_func.type.name, status) !== void 0);
 	const method_ret_type = access_callee_method?.return_type ?? access_func.type;
-	const nullable_scalar_ret = is_nullable_scalar_type(method_ret_type) && !method_ret_type.is_ref;
+	const nullable_scalar_ret = is_nullable_scalar_type(method_ret_type, status) && !method_ret_type.is_ref;
 	let temp_addr = "";
 	let temp_offset = 0;
 	if (return_struct || nullable_scalar_ret) {
@@ -45253,7 +45490,7 @@ function build_access_method(node, access_func, status) {
 	for (let i = 0; i < access_func.params.length; i++) {
 		if ((access_func.ref_param_indices ?? []).includes(i)) continue;
 		const cp = access_callee_params?.[i];
-		if (cp && is_nullable_scalar_type(cp.type) || is_nullable_scalar_type(access_func.params[i].type)) nullable_scalar_arg_set.add(i);
+		if (cp && is_nullable_scalar_type(cp.type, status) || is_nullable_scalar_type(access_func.params[i].type, status)) nullable_scalar_arg_set.add(i);
 	}
 	const arg_slot = [];
 	let total_arg_slots = 0;
@@ -45308,7 +45545,7 @@ function build_access_method(node, access_func, status) {
 			if (arg.node_type === "value" && arg.value === "null") {
 				emit_asm(status, `mov x0, #0\n`);
 				emit_asm(status, `mov x1, #0\n`);
-			} else if (arg.node_type === "value" && is_nullable_scalar_type(arg.type)) {
+			} else if (arg.node_type === "value" && is_nullable_scalar_type(arg.type, status)) {
 				const vname = arg.value;
 				emit_var_load(status, "x0", vname, aarch64_size(arg.type.name));
 				emit_var_load(status, "x1", has_flag_name(vname), 8);
@@ -49572,13 +49809,33 @@ function can_class_int_coerce(target, value, status) {
 }
 //#endregion
 //#region ../src/check/utils/check_type_exists.ts
+/**
+* Containers whose elements live in raw T-sized slots (the `#arch` generic
+* bodies size each slot from the type name alone). A flagged-nullable
+* element type (`List<int?>`) has no per-slot null flag there, so `0`/`false`
+* would read back as null — rejected instead of silently misbehaving.
+* Element types with an in-band null (`string?`, class/trait `?`) stay legal.
+*/
+const RAW_ELEMENT_CONTAINERS = /* @__PURE__ */ new Set([
+	"Array",
+	"Buffer",
+	"List",
+	"Set",
+	"Map",
+	"Graph",
+	"LinkedList",
+	"Tree",
+	"Arena"
+]);
 function check_type_exists(type, status, start) {
+	if (type.is_nullable && type.is_array && !type.is_ref && !type.is_pointer && is_nullable_scalar_name(type.name, status)) add_error(status, `Nullable element type '${type.name}?' is not supported in an array: element storage has no per-element null flag`, start);
 	if (type.name === "tuple" && type.tuple_types?.length) {
 		let ok = true;
 		for (const elem of type.tuple_types) if (!check_type_exists(elem, status, start)) ok = false;
 		return ok;
 	}
 	if (type.name === "anon_enum" && type.enum_cases?.length) {
+		if (type.is_nullable && type.enum_cases.some((c) => c.types.length > 0)) add_error(status, `Nullable type '${type_name(type)}' is not supported: enums with associated data have no separate null flag`, start);
 		let ok = true;
 		for (const c of type.enum_cases) for (const t of c.types) if (!check_type_exists(t, status, start)) ok = false;
 		return ok;
@@ -49595,19 +49852,26 @@ function check_type_exists(type, status, start) {
 			}
 		}
 		type.name = declared.name;
+		if (type.is_nullable) {
+			if (status.enums.findLast((e) => (e.name === declared.name || e.source_name === declared.name) && !e.is_generic)?.has_associated_data) add_error(status, `Nullable type '${type_name(type)}' is not supported: enums with associated data have no separate null flag`, start);
+		}
 	} else if (!status.types.includes(type.name)) {
 		add_error(status, `Unknown type: ${type_name(type)}`, start);
 		return false;
 	}
 	if (type.tuple_types) for (const elem of type.tuple_types) check_type_exists(elem, status, start);
-	if (type.type_args) for (const arg of type.type_args) {
-		if (arg.name === "func") {
-			add_error(status, `func types cannot be used as type arguments ('${type.name}<...>')`, start);
-			continue;
+	if (type.type_args) {
+		if (RAW_ELEMENT_CONTAINERS.has(type.name)) {
+			for (const arg of type.type_args) if (is_nullable_flagged_type(arg, status)) add_error(status, `Nullable element type '${type_name(arg)}' is not supported in '${type.name}<...>': container element storage has no per-element null flag`, start);
 		}
-		check_type_exists(arg, status, start);
-	}
-	else {
+		for (const arg of type.type_args) {
+			if (arg.name === "func") {
+				add_error(status, `func types cannot be used as type arguments ('${type.name}<...>')`, start);
+				continue;
+			}
+			check_type_exists(arg, status, start);
+		}
+	} else {
 		const struct = status.structs.findLast((s) => s.name === type.name);
 		if (struct?.is_generic) {
 			if (!struct.type_params.every((tp) => status.type_params.includes(tp))) add_error(status, `Generic type '${type.name}' requires type arguments (expected <${struct.type_params.join(", ")}>)`, start);
@@ -52486,20 +52750,57 @@ function build_hash(struct, fields) {
 }
 /**
 * Whether `struct` is eligible for a synthesized `copy` method: a value
-* struct whose only ownership is its DIRECT string fields — the same set
-* the pass-by-value argument convention covers. A struct that additionally
-* owns non-string heap (a resource-releasing `#destroy`, a class field, a
-* nested requiring-move struct) cannot be deep-copied by "byte copy +
-* strdup the strings" — its copy stays unwritten (move/swap remains the
-* escape hatch) — and a struct with no string fields is already soundly
-* byte-copyable, so it needs no method.
+* struct whose every field is independently deep-copyable — direct string
+* fields (strdup'd), scalars/arrays (byte copies), `List<T>` fields whose
+* element is itself deep-copyable (the library `List.copy` deep-copies slots
+* via the owning store contract), and nested copyable structs (recursing
+* through their own `copy`). Class fields, enum-with-data fields (their
+* stores transfer payload ownership), class/trait-carrying `List` elements,
+* and resource-releasing `#destroy`s cannot be deep-copied by synthesis —
+* the copy stays unwritten (move/swap remains the escape hatch) — and a
+* struct with nothing to deep-copy (no string, `List`, or nested-copyable
+* field) is already soundly byte-copyable, so it needs no method.
 */
 function struct_is_copyable(struct, status) {
 	if (struct.is_class || struct.is_generic || struct.is_simple_type) return false;
-	if (direct_string_fields(struct).length === 0) return false;
-	if (struct_owns_non_string_heap(struct, status, /* @__PURE__ */ new Set())) return false;
+	if (struct_owns_resource(struct, status, /* @__PURE__ */ new Set())) return false;
+	if (!struct_needs_copy(struct, status)) return false;
 	return struct_copy_ctor_args(struct) !== null;
 }
+/** Whether any field of `struct` actually needs the synthesized deep copy:
+*  a direct string field, a deep-copyable `List<T>` field, or a nested
+*  copyable struct field. A struct of flat values byte-copies soundly
+*  without a method. */
+function struct_needs_copy(struct, status) {
+	if (direct_string_fields(struct).length > 0) return true;
+	for (const field of struct.fields) {
+		if (field.type.is_ref || field.type.is_view || field.type.is_array) continue;
+		if (field_copy_call(field.type, status)) return true;
+	}
+	return false;
+}
+/**
+* Whether `struct` owns a resource a synthesized copy CANNOT duplicate: a
+* `#destroy` that releases something (a raw block / extern free), or a field
+* whose type has no deep-copy story (a class instance, a `List` of
+* class/trait elements, a nested struct with such a field). Fields that DO
+* have a deep-copy story (strings, nested copyables, copyable `List`s,
+* payload-copyable enums) don't block synthesis. Mirrors the old
+* `struct_owns_non_string_heap` gate but understands container deep copies.
+*/
+function struct_owns_resource(struct, status, visited) {
+	if (visited.has(struct.name)) return false;
+	visited.add(struct.name);
+	const destroy = struct.functions.find((f) => f.name === "#destroy");
+	if (destroy && destroy_releases(destroy)) return true;
+	for (const field of struct.fields) {
+		if (field.type.is_ref || field.type.is_view) continue;
+		if (field.type.name === "string" && !field.type.is_array) continue;
+		if (field.type.is_nullable) return true;
+		if (!field_copyable(field.type, status)) return true;
+	}
+	return false;
+}
 /**
 * How a synthesized `copy` constructs the fresh value: the zero-argument
 * `#init` overload when one exists (auto or user), else the bodyless AUTO
@@ -52515,14 +52816,49 @@ function struct_copy_ctor_args(struct) {
 	if (!auto) return null;
 	return auto.params.filter((p) => !p.is_self_param).map((p) => p.name);
 }
-/** Whether `type` names a struct that has (or will get) a `copy` method.
-*  Order-independent: it re-evaluates the eligibility predicate instead of
-*  looking for an already-synthesized method, so an outer struct nested in
-*  the same pre-pass resolves a later-declared field struct. */
-function field_type_is_copyable(type, status) {
+/** Whether `type` has (or will get) a deep-copy story: a struct with a
+*  synthesized `copy`, a `List<T>` whose element is deep-copyable (the
+*  library `List.copy` deep-copies slots via the owning store contract), or
+*  a primitive / plain (payload-free) enum. Order-independent: it
+*  re-evaluates the eligibility predicate instead of looking for an
+*  already-synthesized method, so an outer struct nested in the same
+*  pre-pass resolves a later-declared field struct. */
+function field_copyable(type, status) {
 	if (!type.name || type.is_array || type.is_ref || type.is_view || type.is_nullable) return false;
+	if (type.name === "List" && type.type_args?.length === 1) return element_copyable(type.type_args[0], status);
+	const nested_struct = status.structs.find((s) => s.name === type.name);
+	if (nested_struct) {
+		if (nested_struct.is_simple_type) return true;
+		return struct_is_copyable(nested_struct, status);
+	}
+	const en = status.enums.find((e) => e.name === type.name);
+	if (en) return !en.has_associated_data;
+	return !status.traits.some((t) => t.name === type.name);
+}
+/** Whether a `List<T>` element type is deep-copyable (see
+*  `field_copyable`). */
+function element_copyable(type, status) {
+	if (!type.name || type.is_array || type.is_ref || type.is_view || type.is_nullable) return false;
+	if (type.name === "string") return true;
+	if (type.name === "List" && type.type_args?.length === 1) return element_copyable(type.type_args[0], status);
 	const nested = status.structs.find((s) => s.name === type.name);
-	return !!nested && struct_is_copyable(nested, status);
+	if (nested) {
+		if (nested.is_simple_type) return true;
+		return !nested.is_class && struct_is_copyable(nested, status);
+	}
+	const en = status.enums.find((e) => e.name === type.name);
+	if (en) return !en.has_associated_data;
+	return !status.traits.some((t) => t.name === type.name);
+}
+/** Whether `build_copy` must route the field through a `.copy()` call (a
+*  nested copyable struct, or a `List<T>` field): everything else byte
+*  copies through plain field assignment (strings strdup via the field-write
+*  path, primitives/plain enums are flat values). */
+function field_copy_call(type, status) {
+	if (!type.name || type.is_array || type.is_ref || type.is_view || type.is_nullable) return false;
+	if (type.name === "List" && type.type_args?.length === 1) return element_copyable(type.type_args[0], status);
+	const nested_struct = status.structs.find((s) => s.name === type.name);
+	return !!nested_struct && !nested_struct.is_simple_type && struct_is_copyable(nested_struct, status);
 }
 /**
 * Synthesize `pub func copy(self) -> Struct` for owning value structs: a
@@ -52538,8 +52874,8 @@ function build_copy(struct, status) {
 	const ctor = new FunctionCallNode(-1, struct.name, new Type(struct.name), ctor_args.map((name) => field_access("self", name)));
 	const statements = [new DeclarationNode(-1, "private", "var", "c", new Type(struct.name), ctor)];
 	for (const field of struct.fields) {
-		const right = field_type_is_copyable(field.type, status) ? method_call(field_access("self", field.name), "copy") : field_access("self", field.name);
-		statements.push(new AssignmentNode(-1, field_access("c", field.name), right, "="));
+		const right = field_copy_call(field.type, status) ? method_call(field_access("self", field.name), "copy") : field_access("self", field.name);
+		statements.push(new AssignmentNode(-1, field_access("c", field.name), right));
 	}
 	statements.push(new ReturnNode(-1, new ValueNode(-1, "c")));
 	return new FunctionNode(-1, "pub", "copy", new Type(struct.name), [self_param(struct)], statements);
@@ -53618,7 +53954,10 @@ function monomorphize(generic_struct, type_args, status) {
 					mono_field.type = constructed;
 				}
 			}
-			substitute_raw_in_node(mono_field.value, substitution, status.structs, void 0, status.traits, status.enums);
+			substitute_raw_in_node(mono_field.value, substitution, status.structs, void 0, status.traits, {
+				enums: status.enums,
+				bitsets: status.bitsets
+			});
 		}
 		mono_field.is_library = field.is_library;
 		mono_field.is_readonly = field.is_readonly;
@@ -53653,7 +53992,10 @@ function monomorphize(generic_struct, type_args, status) {
 	for (const func of generic_struct.functions) {
 		if (func.name === "#init") continue;
 		const cloned = clone_node(func);
-		substitute_raw_types(cloned, substitution, status.structs, status.traits, status.enums);
+		substitute_raw_types(cloned, substitution, status.structs, status.traits, {
+			enums: status.enums,
+			bitsets: status.bitsets
+		});
 		fold_substituted_constant_ifs(cloned.statements);
 		rename_local_labels(cloned, mono_name);
 		const retype_roots = [...cloned.statements, ...cloned.allocations ?? []];
@@ -53666,7 +54008,10 @@ function monomorphize(generic_struct, type_args, status) {
 			param.type = substitute_type(param.type, substitution);
 			substitute_param_signature(param, substitution);
 			if (param.type.type_args?.length) param.type = materialize_generic_enum_type(param.type, status);
-			if (param.constraint) substitute_raw_in_node(param.constraint, substitution, status.structs, void 0, status.traits, status.enums);
+			if (param.constraint) substitute_raw_in_node(param.constraint, substitution, status.structs, void 0, status.traits, {
+				enums: status.enums,
+				bitsets: status.bitsets
+			});
 		}
 		retype_param_references(retype_roots, cloned.params);
 		retype_local_references(retype_roots);
@@ -53694,7 +54039,10 @@ function monomorphize(generic_struct, type_args, status) {
 		if (variadic_init_unsupported(generic_init)) continue;
 		if (!generic_init.statements.some((s) => s.node_type !== "raw")) continue;
 		const cloned = clone_node(generic_init);
-		substitute_raw_types(cloned, substitution, status.structs, status.traits, status.enums);
+		substitute_raw_types(cloned, substitution, status.structs, status.traits, {
+			enums: status.enums,
+			bitsets: status.bitsets
+		});
 		fold_substituted_constant_ifs(cloned.statements);
 		rename_local_labels(cloned, mono_name);
 		cloned.return_type = new Type(mono_name);
@@ -53702,7 +54050,10 @@ function monomorphize(generic_struct, type_args, status) {
 		for (const param of cloned.params) {
 			param.type = substitute_type(param.type, substitution);
 			substitute_param_signature(param, substitution);
-			if (param.constraint) substitute_raw_in_node(param.constraint, substitution, status.structs, void 0, status.traits, status.enums);
+			if (param.constraint) substitute_raw_in_node(param.constraint, substitution, status.structs, void 0, status.traits, {
+				enums: status.enums,
+				bitsets: status.bitsets
+			});
 		}
 		const cloned_self = cloned.params.find((p) => p.is_self_param);
 		if (cloned_self) cloned_self.type = new Type(mono_name);
@@ -54207,7 +54558,7 @@ function derive_annotations_for_access_func(access_node, fc, status) {
 		const p = func.params[i];
 		if (p.is_self_param) continue;
 		if (!p.type?.is_nullable) continue;
-		if (status.structs.find((s) => s.name === p.type.name && !s.is_class) || is_nullable_scalar_type(p.type)) nullable_indices.push(i - (self_offset >= 0 ? self_offset + 1 : 0));
+		if (status.structs.find((s) => s.name === p.type.name && !s.is_class) || is_nullable_scalar_type(p.type, status)) nullable_indices.push(i - (self_offset >= 0 ? self_offset + 1 : 0));
 	}
 	if (nullable_indices.length > 0) fc.nullable_param_indices = nullable_indices;
 	if (func.return_constraint && !fc.return_bounds) {
@@ -54586,7 +54937,7 @@ function fold_substituted_constant_ifs(statements) {
 		statements.splice(i, 1, ...kept);
 	}
 }
-function substitute_raw_types(func, substitution, structs, traits, enums) {
+function substitute_raw_types(func, substitution, structs, traits, tables) {
 	const deref_params = /* @__PURE__ */ new Set();
 	for (const param of func.params) {
 		const resolved = substitution.get(param.type.name);
@@ -54595,7 +54946,7 @@ function substitute_raw_types(func, substitution, structs, traits, enums) {
 		const s = structs.find((x) => x.name === resolved);
 		if (s && !s.is_simple_type && !s.is_class) deref_params.add(param.name);
 	}
-	for (const stmt of func.statements) substitute_raw_in_node(stmt, substitution, structs, deref_params, traits, enums);
+	for (const stmt of func.statements) substitute_raw_in_node(stmt, substitution, structs, deref_params, traits, tables);
 }
 function rename_local_labels(node, prefix) {
 	if (node.node_type === "raw") {
@@ -54628,7 +54979,7 @@ function raw_type_alignment(name) {
 function raw_align_to(offset, alignment) {
 	return Math.ceil(offset / alignment) * alignment;
 }
-function raw_type_size(name, structs, enums) {
+function raw_type_size(name, structs, tables) {
 	switch (name) {
 		case "bool":
 		case "int8":
@@ -54639,13 +54990,13 @@ function raw_type_size(name, structs, enums) {
 		case "int32":
 		case "uint32": return 4;
 	}
-	const enum_node = enums?.find((e) => e.name === name && !e.is_generic);
+	const enum_node = tables.enums.find((e) => e.name === name && !e.is_generic);
 	if (enum_node) {
 		if (!enum_node.has_associated_data) return 8;
 		let max_payload = 0;
 		for (const c of enum_node.cases) {
 			let case_size = 0;
-			for (const p of c.params) case_size += raw_type_size(p.type.name, structs, enums);
+			for (const p of c.params) case_size += raw_type_size(p.type.name, structs, tables);
 			max_payload = Math.max(max_payload, case_size);
 		}
 		return 8 + Math.ceil(max_payload / 8) * 8;
@@ -54660,9 +55011,9 @@ function raw_type_size(name, structs, enums) {
 			size += 16;
 			continue;
 		}
-		size += raw_type_size(field.type.name, structs, enums);
+		size += raw_type_size(field.type.name, structs, tables);
 		if (field.type.is_nullable && structs.find((s) => s.name === field.type.name && !s.is_simple_type && !s.is_class)) size += 8;
-		else if (is_nullable_scalar_type(field.type)) size += 1;
+		else if (is_nullable_scalar_type(field.type, tables)) size += 1;
 	}
 	return raw_align_to(size, 8);
 }
@@ -54707,12 +55058,15 @@ function raw_block_is_pure_asm(value) {
 function is_reference_type_arg(t, structs, traits) {
 	return !!traits.some((tr) => tr.name === t.name) || !!structs.find((s) => s.name === t.name && s.is_class);
 }
-function substitute_raw_in_node(node, substitution, structs, deref_params = /* @__PURE__ */ new Set(), traits = [], enums = []) {
+function substitute_raw_in_node(node, substitution, structs, deref_params = /* @__PURE__ */ new Set(), traits = [], tables = {
+	enums: [],
+	bitsets: []
+}) {
 	if (node.node_type === "value") {
 		const vn = node;
 		for (const [param, type] of substitution) {
 			if (vn.value === `${param}_SIZE`) {
-				vn.value = String(raw_type_size(type, structs, enums));
+				vn.value = String(raw_type_size(type, structs, tables));
 				vn.type = new Type("int", true);
 				return;
 			}
@@ -54737,7 +55091,7 @@ function substitute_raw_in_node(node, substitution, structs, deref_params = /* @
 			else if (struct_node) c_type_name = `struct ${type}`;
 			else c_type_name = raw_c_type_name(type);
 			value = value.replace(new RegExp(`\\b${param}\\b`, "g"), c_type_name);
-			const size = raw_type_size(type, structs, enums);
+			const size = raw_type_size(type, structs, tables);
 			const size_expr = raw_block_is_pure_asm(value) ? String(size) : `sizeof(${c_type_name})`;
 			value = value.replace(new RegExp(`\\b${param}_SIZE\\b`, "g"), size_expr);
 			value = value.replace(new RegExp(`\\b${param}_destroy\\b`, "g"), `${type}_destroy`);
@@ -54773,22 +55127,22 @@ function substitute_raw_in_node(node, substitution, structs, deref_params = /* @
 		if (any_node.func_return_type?.name) any_node.func_return_type = substitute_type(any_node.func_return_type, substitution);
 	}
 	if (any_node.allocations && Array.isArray(any_node.allocations)) {
-		for (const child of any_node.allocations) if (child && typeof child === "object" && "node_type" in child) substitute_raw_in_node(child, substitution, structs, deref_params, traits, enums);
+		for (const child of any_node.allocations) if (child && typeof child === "object" && "node_type" in child) substitute_raw_in_node(child, substitution, structs, deref_params, traits, tables);
 	}
 	if (any_node.statements && Array.isArray(any_node.statements)) {
-		for (const child of any_node.statements) if (child && typeof child === "object" && "node_type" in child) substitute_raw_in_node(child, substitution, structs, deref_params, traits, enums);
+		for (const child of any_node.statements) if (child && typeof child === "object" && "node_type" in child) substitute_raw_in_node(child, substitution, structs, deref_params, traits, tables);
 	}
 	if (any_node.params && Array.isArray(any_node.params)) {
-		for (const child of any_node.params) if (child && typeof child === "object" && "node_type" in child) substitute_raw_in_node(child, substitution, structs, deref_params, traits, enums);
+		for (const child of any_node.params) if (child && typeof child === "object" && "node_type" in child) substitute_raw_in_node(child, substitution, structs, deref_params, traits, tables);
 	}
-	if (any_node.value && any_node.value.node_type) substitute_raw_in_node(any_node.value, substitution, structs, deref_params, traits, enums);
-	if (any_node.left_value?.node_type) substitute_raw_in_node(any_node.left_value, substitution, structs, deref_params, traits, enums);
-	if (any_node.right_value?.node_type) substitute_raw_in_node(any_node.right_value, substitution, structs, deref_params, traits, enums);
-	if (any_node.target?.node_type) substitute_raw_in_node(any_node.target, substitution, structs, deref_params, traits, enums);
-	if (any_node.access?.node_type) substitute_raw_in_node(any_node.access, substitution, structs, deref_params, traits, enums);
-	if (any_node.swap?.node_type) substitute_raw_in_node(any_node.swap, substitution, structs, deref_params, traits, enums);
-	if (any_node.condition?.node_type) substitute_raw_in_node(any_node.condition, substitution, structs, deref_params, traits, enums);
-	if (any_node.index?.node_type) substitute_raw_in_node(any_node.index, substitution, structs, deref_params, traits, enums);
+	if (any_node.value && any_node.value.node_type) substitute_raw_in_node(any_node.value, substitution, structs, deref_params, traits, tables);
+	if (any_node.left_value?.node_type) substitute_raw_in_node(any_node.left_value, substitution, structs, deref_params, traits, tables);
+	if (any_node.right_value?.node_type) substitute_raw_in_node(any_node.right_value, substitution, structs, deref_params, traits, tables);
+	if (any_node.target?.node_type) substitute_raw_in_node(any_node.target, substitution, structs, deref_params, traits, tables);
+	if (any_node.access?.node_type) substitute_raw_in_node(any_node.access, substitution, structs, deref_params, traits, tables);
+	if (any_node.swap?.node_type) substitute_raw_in_node(any_node.swap, substitution, structs, deref_params, traits, tables);
+	if (any_node.condition?.node_type) substitute_raw_in_node(any_node.condition, substitution, structs, deref_params, traits, tables);
+	if (any_node.index?.node_type) substitute_raw_in_node(any_node.index, substitution, structs, deref_params, traits, tables);
 }
 function specialize_function(generic_func, call_node, status) {
 	const substitution = /* @__PURE__ */ new Map();
@@ -55807,7 +56161,7 @@ function check_function_call(node, status, func, target_type, self_value, self_p
 	for (let [i, param] of node.params.entries()) {
 		const func_param = func.params[i + self_offset];
 		if (func_param && func_param.type.is_nullable && !func_param.is_self_param && !func_param.type.is_ref && !func_param.type.is_array) {
-			if (status.structs.find((st) => st.name === func_param.type.name && !st.is_class && !st.is_simple_type) || is_nullable_scalar_type(func_param.type)) {
+			if (status.structs.find((st) => st.name === func_param.type.name && !st.is_class && !st.is_simple_type) || is_nullable_scalar_type(func_param.type, status)) {
 				if (!node.nullable_param_indices) node.nullable_param_indices = [];
 				if (!node.nullable_param_indices.includes(i)) node.nullable_param_indices.push(i);
 			}