nomen-lang 0.7.1 → 0.8.0

package/dist/index.mjs

@@ -2367,11 +2367,7 @@ function parse_operand(tok) {
 	if (/^[A-Za-z_.$][\w.$]*@[A-Za-z0-9_]+$/.test(trimmed)) return "labelish";
 	return null;
 }
-/**
-* Validate emitted assembly. Returns every problem found (empty array when
-* clean). Never throws — malformed input IS the input here.
-*/
-function validate_asm(code) {
+function validate_asm(code, options = {}) {
 	const errors = [];
 	const lines = code.split("\n");
 	const labels = /* @__PURE__ */ new Set();
@@ -2457,7 +2453,7 @@ function validate_asm(code) {
 		if ((op === "b" || op.startsWith("b.") || op === "cbz" || op === "cbnz") && labelish_count > 0) {
 			const target = operands.find((o) => o.kind === "label").name;
 			const num = /^(\d+)([fb])$/.exec(target);
-			if (!(num ? (numeric_labels.get(num[1]) ?? []).some((line) => num[2] === "f" ? line > i : line < i) : labels.has(target))) err(`branch to undefined label '${target}'`);
+			if (!(num ? (numeric_labels.get(num[1]) ?? []).some((line) => num[2] === "f" ? line > i : line < i) : labels.has(target)) && !options.allow_external_branch_targets) err(`branch to undefined label '${target}'`);
 		}
 	}
 	return errors;
@@ -2795,8 +2791,8 @@ function describe$1(operands) {
 * function entry (bl-target / globl / boundary-heuristic labels). Validation
 * errors are returned alongside — callers should check them first.
 */
-function lift_functions(code) {
-	const errors = validate_asm(code);
+function lift_functions(code, options = {}) {
+	const errors = validate_asm(code, options);
 	const lines = [];
 	const functions = [];
 	const lines_split = code.split("\n");
@@ -4318,20 +4314,42 @@ function convert_loop_invariant_branches(code) {
 *   ldp/stp pairs) → the x17 scratch: `mov x17, #big` (+ `add x17, x29, x17`
 *   for the pair forms, which have no register-offset encoding).
 *
+* The same limits bite RECEIVER-relative field accesses: `[xN, #big]` where
+* xN holds a struct pointer (x19 in methods), and `add xD, xN, #big` for the
+* address-of form. A struct past ~4-7 KB of fields crosses the encodings the
+* moment any field sits far enough into the body (scaled x-loads reach 32760,
+* but sub-word scaled forms and `add` top out at 4095, ldur/stur at 255, and
+* ldp/stp at 504). These rewrite exactly like the frame forms, except the
+* base register is a live receiver that must survive:
+*
+* - `add xD, xN, #big` with xD != xN → the destination stages its own
+*   address (`mov xD, #big; add xD, xN, xD`); with xD == xN the offset goes
+*   through x17 (staging into the destination would destroy the base).
+* - loads whose destination is an x-register distinct from the base stage
+*   their own address; everything else goes through x17, including pair
+*   forms (`mov x17, #big; add x17, xN, x17; ldp a, b, [x17]`).
+* - Scaled accesses rewrite only past their TRUE encodable range, so in-range
+*   code (e.g. `str x3, [x19, #4104]`) stays single-instruction.
+*
 * x17 is safe as the universal scratch here because this pass runs BEFORE the
 * optimization pipeline: the passes that claim x16/x17 (loop promotion,
 * select registers, pointer walks) validate their claim against the function
 * text and refuse when x17 already appears — losing an optimization on
 * large-frame functions, which is the correct trade. Raw `#arch: aarch64`
 * bodies in the core library never hold a live value in x17 across an
-* out-of-range `[x29, #imm]` access (the corpus has none: such accesses did
-* not assemble before this pass existed). x17 is never live across a `bl`
-* by the backend's own convention, and the shims contain no calls.
+* out-of-range access (the corpus has none: such accesses did not assemble
+* before this pass existed). x17 is never live across a `bl` by the backend's
+* own convention, and the shims contain no calls. The receiver register is
+* never x17 (emitters keep receivers in x0–x16/x19–x28), so staging into x17
+* cannot clobber the base; a base-x17 line is left untouched rather than
+* mis-staged.
 */
 /** First scratch that no emitter or raw body relies on across statements. */
 const SCRATCH = "x17";
-/** The imm12 ceiling shared by `add imm` and the scaled load/store forms. */
+/** The imm12 ceiling shared by `add imm` and the byte-scaled load/store. */
 const IMM12_MAX = 4095;
+/** simm9 ceiling (non-negative side) for the unscaled ldur/stur family. */
+const SIMM9_MAX = 255;
 /** mov (movz/movk expanded) that materializes any non-negative constant. */
 function emit_mov_imm(reg, imm) {
 	if (imm <= 65535) return [`mov ${reg}, #${imm}`];
@@ -4366,6 +4384,44 @@ const SP_ADJ_RE = /^(sub|add) sp, sp, #(\d+)$/;
 /** True for full 64-bit integer registers usable as their own address scratch
 *  (xzr excluded: `ldr xzr` still performs the load, and xzr can't stage). */
 const IS_X_REG = /^x([0-9]|[12][0-9]|3[01])$/;
+const X_BASE = "(x(?:[0-9]|[12][0-9]|3[01]))";
+const MEM_RECV_RE = new RegExp(`^(ldr|ldrb|ldrh|ldrsb|ldrsh|ldrsw|ldur|ldurb|ldurh|ldursb|ldursh|ldursw|str|strb|strh|stur|sturb|sturh) ([a-z][a-z0-9]*), \\[${X_BASE}, #(\\d+)\\](\\s*\\/\\/.*)?$`);
+const PAIR_RECV_RE = new RegExp(`^(ldp|stp) ([^,]+), ([^,]+), \\[${X_BASE}, #(\\d+)\\](\\s*\\/\\/.*)?$`);
+const ADD_RECV_RE = new RegExp(`^add ${X_BASE}, ${X_BASE}, #(\\d+)(\\s*\\/\\/.*)?$`);
+/** Register-offset spelling of the unscaled ldur/stur family: the unscaled
+*  encodings have no register-offset form, so an out-of-range unscaled access
+*  rewrites to its scaled mnemonic (identical semantics — the immediate is
+*  non-negative, so the missing sign-extension reach is unused). */
+const SCALED_OF = {
+	ldur: "ldr",
+	stur: "str",
+	ldurb: "ldrb",
+	sturb: "strb",
+	ldurh: "ldrh",
+	sturh: "strh",
+	ldursb: "ldrsb",
+	ldursh: "ldrsh",
+	ldursw: "ldrsw"
+};
+/** Largest non-negative immediate a SCALED load/store encodes: imm12 scaled
+*  by the access width (byte 4095 … quad 65520). The width comes from the
+*  mnemonic's suffix where present, else the destination register's class.
+*/
+function scaled_imm_max(op, reg) {
+	if (op.endsWith("b")) return IMM12_MAX;
+	if (op.endsWith("h")) return IMM12_MAX * 2;
+	if (op === "ldrsw") return IMM12_MAX * 4;
+	if (reg.startsWith("q")) return IMM12_MAX * 16;
+	if (reg.startsWith("x") || reg.startsWith("d")) return IMM12_MAX * 8;
+	if (reg.startsWith("w") || reg.startsWith("s")) return IMM12_MAX * 4;
+	if (reg.startsWith("h")) return IMM12_MAX * 2;
+	return IMM12_MAX;
+}
+/** Largest non-negative immediate a pair form encodes: simm7 scaled by the
+*  element size (8-byte pairs 504, 16-byte pairs 1008). */
+function pair_imm_max(reg) {
+	return 63 * (reg.startsWith("q") ? 16 : reg.startsWith("w") || reg.startsWith("s") ? 4 : 8);
+}
 function rewrite_large_frame_offsets(asm) {
 	const lines = asm.split("\n");
 	const out = [];
@@ -4403,6 +4459,42 @@ function rewrite_large_frame_offsets(asm) {
 			out.push(`${op} ${a}, ${b}, [${SCRATCH}]${comment ?? ""}`);
 			continue;
 		}
+		const add_recv = ADD_RECV_RE.exec(line.trim());
+		if (add_recv && Number(add_recv[3]) > IMM12_MAX) {
+			const [, dest, base, imm_s, comment] = add_recv;
+			const imm = Number(imm_s);
+			if (base !== SCRATCH) {
+				const stage = dest !== base ? dest : SCRATCH;
+				for (const l of emit_mov_imm(stage, imm)) out.push(l);
+				out.push(`add ${dest}, ${base}, ${stage}${comment ?? ""}`);
+				continue;
+			}
+		}
+		const mem_recv = MEM_RECV_RE.exec(line.trim());
+		if (mem_recv) {
+			const [, op, reg, base, imm_s, comment] = mem_recv;
+			const imm = Number(imm_s);
+			if (imm > (op.startsWith("ldur") || op.startsWith("stur") ? SIMM9_MAX : scaled_imm_max(op, reg)) && base !== SCRATCH) {
+				const is_load = op.startsWith("ldr");
+				const emit_op = SCALED_OF[op] ?? op;
+				if (is_load && IS_X_REG.test(reg) && reg !== base) {
+					for (const l of emit_mov_imm(reg, imm)) out.push(l);
+					out.push(`${emit_op} ${reg}, [${base}, ${reg}]${comment ?? ""}`);
+				} else {
+					for (const l of emit_mov_imm(SCRATCH, imm)) out.push(l);
+					out.push(`${emit_op} ${reg}, [${base}, ${SCRATCH}]${comment ?? ""}`);
+				}
+				continue;
+			}
+		}
+		const pair_recv = PAIR_RECV_RE.exec(line.trim());
+		if (pair_recv && Number(pair_recv[5]) > pair_imm_max(pair_recv[2]) && pair_recv[4] !== SCRATCH) {
+			const [, op, a, b, base, imm_s, comment] = pair_recv;
+			for (const l of emit_mov_imm(SCRATCH, Number(imm_s))) out.push(l);
+			out.push(`add ${SCRATCH}, ${base}, ${SCRATCH}`);
+			out.push(`${op} ${a}, ${b}, [${SCRATCH}]${comment ?? ""}`);
+			continue;
+		}
 		out.push(line);
 	}
 	return out.join("\n");
@@ -6526,6 +6618,31 @@ var AccessFunctionCallNode = class extends BaseNode {
 	*/
 	is_nursery_spawn;
 	/**
+	* Set during checking when this `.on_<event>(closure)` call was
+	* checker-interpreted as a handler registration (docs/HANDLERS.md): the
+	* closure body was hoisted into a hidden method on the enclosing struct
+	* and the site checked into a dispatch arm on the host's synthesized
+	* `handle_clicks`. The registration itself emits NO code — both backends
+	* return as soon as they see the stamp.
+	*/
+	is_handler_registration;
+	/**
+	* Set during checking when this `.on_<event>(closure)` call was
+	* checker-interpreted as a COMPOSITE EVENT registration (docs/HANDLERS.md
+	* Stage 3): the closure was hoisted into a hidden method on the app and
+	* the params were REWRITTEN to the enrollment call — `receiver.on_<event>(id)`
+	* — which resolves as the composite's own declared event API. The stamp
+	* makes the re-entered ordinary resolution skip the desugar hook.
+	*/
+	is_handler_enrollment;
+	/**
+	* Set during checking when a `ref T x = container.at(i)` binding was
+	* rewritten to the element-borrow primitive (`slot_ptr` — docs/HANDLERS.md
+	* Stage 4): the call RETURNS the slot pointer, so the ref-binding build
+	* emits it bare (no `&`).
+	*/
+	is_element_slot_load;
+	/**
 	* RETIRED with the pre-migration launch dispatch: `.start()`/`.detach()`
 	* are ordinary methods on the library `Thread` class now (docs/ASYNC.md).
 	* The flags remain only because monomorphized clones can carry them from
@@ -6949,23 +7066,19 @@ function find_enum(name, status) {
 /**
 * Whether `name` is a monomorphized mv-container struct whose
 * `<Mono>_copy` is safe to call from the mv-`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.
+* specialization — `List_<T>` / `Buffer_<T>` / `Map_<K,V>` / `Set_<T>`
+* (and their bare generics). These own heap slabs 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 mv struct or
-* the Map/Set itself works on both backends.
+* `Map`/`Set` compose their `copy` from member `Buffer.copy` calls (and a
+* zero-pair `Map()`/`Set()` ctor); the aarch64 deferred-ctor marshalling
+* that crashed that composition is fixed (see build_constructor_params),
+* so they ride the same deep copy.
 */
 function is_load_deep_copy_container(name) {
-	return name === "List" || name === "Buffer" || name.startsWith("List_") || name.startsWith("Buffer_");
+	return name === "List" || name === "Buffer" || name === "Map" || name === "Set" || name.startsWith("List_") || name.startsWith("Buffer_") || name.startsWith("Map_") || name.startsWith("Set_");
 }
 function mono_type_name(type_or_name, type_args) {
 	const name = typeof type_or_name === "string" ? type_or_name : type_or_name.name;
@@ -8779,6 +8892,89 @@ function check_raw_arch_coverage(func, arch, platform) {
 		has_other_arch
 	};
 }
+function find_use_c_mixed_body(func) {
+	let has_use_c = false;
+	const drops = [];
+	for (const stmt of func.statements) {
+		if (stmt.node_type !== "raw") {
+			drops.push({
+				dropped: "statement",
+				start: stmt.start
+			});
+			continue;
+		}
+		let arches = null;
+		for (const line of stmt.value.split("\n")) {
+			const trimmed = line.trim();
+			if (trimmed.startsWith("#arch:")) arches = trimmed.substring(6).split(",").map((a) => a.trim()).filter((a) => a.length > 0);
+			else if (trimmed.length > 0) break;
+		}
+		if (!arches) {
+			drops.push({
+				dropped: "raw asm",
+				start: stmt.start
+			});
+			continue;
+		}
+		if (arches.includes("aarch64")) {
+			drops.push({
+				dropped: "raw asm",
+				start: stmt.start
+			});
+			continue;
+		}
+		if (arches.includes("aarch64_use_c")) {
+			has_use_c = true;
+			continue;
+		}
+	}
+	if (!has_use_c) return find_nested_use_c_block(func.statements);
+	return drops[0] ?? null;
+}
+/**
+* Descend into nested control-flow statements and report the first
+* block-scope `aarch64_use_c` raw block. Nested functions are boundaries —
+* their bodies get their own check pass (their own find_use_c_mixed_body
+* run). `#scope: file` blocks are exempt: file-scope C hoists to the
+* companion's file scope and emits wherever the carrier function sits (the
+* blessed pattern for delegate IMPs and registries).
+*/
+function find_nested_use_c_block(statements) {
+	let found = null;
+	const visit = (value) => {
+		if (found || !value || typeof value !== "object") return;
+		if (Array.isArray(value)) {
+			for (const item of value) visit(item);
+			return;
+		}
+		const n = value;
+		if (typeof n.node_type !== "string") return;
+		if (n.node_type === "func" || n.node_type === "struct" || n.node_type === "trait") return;
+		if (n.node_type === "raw") {
+			const raw = n;
+			let arches = null;
+			let scope_file = false;
+			for (const line of raw.value.split("\n")) {
+				const trimmed = line.trim();
+				if (trimmed.startsWith("#scope:")) scope_file = trimmed.substring(7).trim() === "file";
+				else if (trimmed.startsWith("#arch:")) arches = trimmed.substring(6).split(",").map((a) => a.trim()).filter((a) => a.length > 0);
+				else if (trimmed.length > 0) break;
+			}
+			if (arches?.includes("aarch64_use_c") && !scope_file) found = {
+				dropped: "nested block",
+				start: n.start
+			};
+			return;
+		}
+		const record = value;
+		for (const key of Object.keys(record)) {
+			if (key === "parent" || key === "scope" || key === "node_type") continue;
+			visit(record[key]);
+		}
+	};
+	for (const stmt of statements) visit(stmt);
+	return found;
+}
 //#endregion
 //#region ../src/nodes/AssignmentNode.ts
 var AssignmentNode = class extends BaseNode {
@@ -9317,6 +9513,24 @@ function struct_needs_destroy(struct, table) {
 	return has_destroy(struct) || has_struct_fields_with_destroy(struct, table) || struct_has_owning_enum_field(struct, table) || struct_has_owned_func_field(struct) || owns_strings_via_destroy(struct) && struct_has_direct_string_fields(struct) || struct_has_trait_declared_destroy_fields(struct, table);
 }
 /**
+* Whether a container-element load may replace this field's shallow bytes
+* with `<Mono>_copy(&field)` (the deep-copy half of mv load_T): any
+* monomorphized, non-class struct that owns resources (needs destroy at
+* scope exit) AND has a `copy` method. The containers (`List`/`Buffer`/
+* `Map`/`Set`) always qualify (their library `copy` yields an independent
+* slab), and nested mv user structs qualify once every field passed the
+* auto-derive copy gate (their synthesized `copy` deep-copies member
+* containers/strings). A flat value struct byte-copies soundly
+* (needs_destroy false) and stays untouched; an owning struct WITHOUT a
+* copy (Box/class/nullable/func fields) stays shallow — the recorded gap
+* in FOLLOWUP.md. The borrow-carrier reclaim walkers use the SAME
+* predicate to free exactly the deep-copied fields — keep all call sites
+* on this one definition.
+*/
+function field_load_deep_copy(struct, table) {
+	return !struct.is_class && !struct.is_generic && struct_needs_destroy(struct, table) && struct.functions.some((f) => f.name === "copy");
+}
+/**
 * Whether a class or OWNING struct has a `func`-typed field. Such a field may
 * hold a capturing-closure descriptor (`owned = 1`, a heap env + descriptor),
 * which the scope-exit / generated destroy must reclaim. A non-mv value
@@ -9328,6 +9542,81 @@ function struct_has_owned_func_field(struct) {
 	return struct.fields.some((f) => !f.type.is_ref && f.type.name === "func" && !f.type.is_array);
 }
 /**
+* Whether a container-element bitwise load (`.at(i)` / `.first()` / `load_T`
+* — the borrow accessor family) aliases destroy-worthy state that neither
+* the mv `load_T` deep-copy nor the binding's string strdup repair
+* privatizes. Such a binding must be classified as a PURE BORROW — no
+* scope-exit destroy and no strdup repair: the slot keeps sole ownership of
+* everything the load aliased (the recorded `List<Own>.at()`
+* double-release: a `#destroy` over a non-string field — an AppKit handle —
+* ran on the borrowed copy AND on the slot, and a nested `#destroy` struct
+* without a copy method did the same one level down).
+*
+* Privatized by the load + binding repair, and therefore fine to keep
+* destroy-tracked: direct `string` fields (strdup'd at the binding),
+* non-nullable `Box<T>` fields (cloned by load_T), nested structs whose
+* `copy` deep-copies (field_load_deep_copy), and enum fields whose payloads
+* are all deep-copyable (strdup'd in place). NOT privatizable, and
+* therefore aliasing: a user `#destroy` body (release semantics — a bitwise
+* copy cannot clone the resource), a nested destroy-worthy struct without a
+* copy method, a nullable Box/class field (the load's clone arm skips
+* nullable fields), an enum field whose payloads reference classes/traits,
+* an owned func field (the shared closure descriptor), and trait-declared
+* destroy fields (outside the strdup repair's field walk).
+*
+* The accessor-name set is kept in sync with
+* `is_container_borrow_accessor_name` (string_return_analysis.ts), which
+* cannot be imported here (it pulls the build_c utils graph into a module
+* the backends' gather passes import directly).
+*/
+function element_load_aliases_destroy_state(struct, table) {
+	if (has_destroy(struct)) return true;
+	if (struct_has_owned_func_field(struct)) return true;
+	if (struct_has_trait_declared_destroy_fields(struct, table)) return true;
+	for (const field of struct.fields) {
+		if (field.type.is_ref || field.type.is_view || field.type.is_array) continue;
+		const field_enum = table.enums?.find((e) => e.name === field.type.name && e.has_associated_data);
+		if (field_enum) {
+			for (const c of field_enum.cases) for (const p of c.params) {
+				if (table.traits?.some((t) => t.name === p.type.name)) return true;
+				if (table.structs.find((s) => s.name === p.type.name)?.is_class) return true;
+			}
+			continue;
+		}
+		const field_struct = resolve_struct_type(field.type, table);
+		if (!field_struct) continue;
+		if (field_struct.is_class) {
+			if (is_box_type(field_struct.name, table.structs) && !field.type.is_nullable) continue;
+			return true;
+		}
+		if (struct_needs_destroy(field_struct, table) && !field_load_deep_copy(field_struct, table)) return true;
+	}
+	return false;
+}
+/**
+* Whether a DECLARATION is the `List<Own>.at()` pure borrow: bound (non-`mv`,
+* non-`ref`) to a container borrow accessor call (`at`/`at_or_panic`/`first`/
+* `slice`/`get_or`/`get_or_panic`/`load`, without `owned_return`) whose
+* value-struct element aliases destroy-worthy state. Both backends gate the
+* binding's scope-exit destroy and the string strdup repair on this — see
+* element_load_aliases_destroy_state.
+*/
+function is_pure_borrow_element_load(decl, table) {
+	const value = decl.value;
+	if (!value || value.node_type !== "access") return false;
+	const access = value.access;
+	if (!access || access.node_type !== "access_func") return false;
+	const func = access;
+	if (func.owned_return) return false;
+	const name = func.name ?? "";
+	if (!(name === "at" || name === "at_or_panic" || name === "first" || name === "slice" || name === "get_or" || name === "get_or_panic" || name === "load")) return false;
+	const decl_type = decl.type;
+	if (!decl_type) return false;
+	const struct_type = resolve_struct_type(decl_type, table);
+	if (!struct_type || struct_type.is_class || struct_type.is_generic) return false;
+	return element_load_aliases_destroy_state(struct_type, table);
+}
+/**
 * Whether a struct needs an auto-generated `<Struct>_destroy` function.
 * Broader than `struct_needs_destroy`: also returns true for structs with
 * `string` fields, because a Buffer<T> for such a struct deep-copies the
@@ -14054,6 +14343,7 @@ function visit$1(node, result, structs) {
 			if (a.left_value.node_type === "value") {
 				if (is_fresh_heap_string(a.right_value)) result.add(a.left_value.value);
 				else if (!a.operator && is_owned_string_var_rhs(a.right_value)) result.add(a.left_value.value);
+				else if (!a.operator && is_moved_string_var_rhs(a.right_value)) result.add(a.left_value.value);
 			}
 			visit$1(a.right_value, result, structs);
 			break;
@@ -14110,6 +14400,13 @@ function is_fresh_heap_string(node) {
 	}
 	return false;
 }
+function is_moved_string_var_rhs(node) {
+	if (!node || node.node_type !== "value") return false;
+	const vn = node;
+	if (!vn.is_moved) return false;
+	const type = vn.type;
+	return !!type && type.name === "string" && !type.is_view && !type.is_array;
+}
 function is_owned_string_var_rhs(node) {
 	if (!node || node.node_type !== "value") return false;
 	const vn = node;
@@ -14393,49 +14690,6 @@ function build_foreign$1(node, status, struct_node) {
 	emit_asm(status, `\n`);
 }
 //#endregion
-//#region ../src/build_aarch64/utils/raw_reload.ts
-/** Width-aware slot reload — mirrors the prologue's store width so the
-*  register holds exactly the value a body read of the slot would produce
-*  (sub-word stores truncate; a same-width load zero-extends like the
-*  emitters' own slot reads). */
-function raw_slot_reload_line(reg, offset, size) {
-	const wreg = reg.replace("x", "w");
-	if (size === 1) return `ldrb ${wreg}, [x29, #${offset}]`;
-	if (size === 2) return `ldrh ${wreg}, [x29, #${offset}]`;
-	if (size === 4) return `ldr ${wreg}, [x29, #${offset}]`;
-	return `ldr ${reg}, [x29, #${offset}]`;
-}
-/** Capture status.code.length as the entry point and install the plan. */
-function install_raw_reload_plan(status, lines) {
-	const plan = {
-		entry_marker: asm_code_len(status),
-		lines
-	};
-	status.raw_param_reloads = plan;
-	return plan;
-}
-/**
-* The reload lines a raw block needs: none at the function's entry point
-* (the registers still hold the entry values), otherwise the lines for the
-* ABI registers the block's text references. Registers are matched against
-* comment-stripped instruction text only — a mention in a `//` comment, a
-* label, or a data directive doesn't force a reload (same discipline as
-* build_inline_method's count_x19_reads).
-*/
-function raw_reload_lines_for(code, plan, current_length) {
-	if (!plan || plan.lines.length === 0 || current_length === plan.entry_marker) return [];
-	const referenced = /* @__PURE__ */ new Set();
-	for (const raw_line of code.split("\n")) {
-		const comment = raw_line.indexOf("//");
-		const line = (comment === -1 ? raw_line : raw_line.slice(0, comment)).trim();
-		if (!line || line.endsWith(":") || line.startsWith(".")) continue;
-		for (const match of line.matchAll(/\b[wx][0-9]\b/g)) referenced.add(match[0]);
-	}
-	const out = [];
-	for (const entry of plan.lines) if (referenced.has(entry.reg) || referenced.has(entry.reg.replace("x", "w"))) out.push(entry.asm);
-	return out;
-}
-//#endregion
 //#region ../src/build_aarch64/utils/aarch64_size.ts
 /**
 * Storage width of a value of `type` in bytes, derived from the
@@ -14792,6 +15046,382 @@ function emit_enum_payload_binding_load(status, base_reg, payload_off, slot, typ
 	}
 }
 //#endregion
+//#region ../src/build_aarch64/utils/c_companion.ts
+/**
+* The label a `aarch64_use_c` function's C body is emitted under — the same
+* shape the aarch64 side derives for thunks and call sites.
+*/
+function companion_function_label(func, struct_name, status) {
+	if (struct_name) {
+		const struct = status.structs.find((s) => s.name === struct_name);
+		if (struct && is_overloaded(struct, func.name)) return mangled_label(func, struct_name);
+		return `${struct_name}_${func.name.replace(/#/g, "")}`;
+	}
+	return func.name === "main" ? "_nomen_main" : func.name;
+}
+/**
+* Mach-O reserves leading-`L` symbols for assembler-local labels: clang's
+* assembler refuses `bl L…` to an undefined symbol (local labels can't be
+* external), and clang's compiler drops L-prefixed `__asm__` bindings from
+* the object symbol table entirely. A struct named `LevelIndicator` (or any
+* L-leading function) with `aarch64_use_c` methods therefore binds its
+* companion symbols under a `_`-prefixed alias — and build.ts rewrites the
+* asm-side references to match.
+*/
+function sanitize_companion_label(label) {
+	return label.startsWith("L") ? `_${label}` : label;
+}
+/**
+* Generate the complete C companion file: includes, struct typedefs, and
+* function definitions for every collected `aarch64_use_c` function.
+*/
+function generate_companion(functions, status) {
+	let out = "";
+	if (functions.length > 0 && (status.platform === "macos" || status.platform === "ios")) {
+		out += `#import <Foundation/Foundation.h>\n`;
+		out += `#include <objc/runtime.h>\n`;
+		out += `#include <objc/message.h>\n`;
+		if (status.platform === "macos") out += `#import <Cocoa/Cocoa.h>\n`;
+		else out += `#import <UIKit/UIKit.h>\n`;
+	}
+	out += `#include <stdint.h>\n`;
+	out += `#include <stdlib.h>\n`;
+	out += `typedef struct { void* ptr; long len; } nomen_view;\n`;
+	out += `typedef struct { char* ptr; long len; } nomen_string;\n`;
+	out += `#include <stdio.h>\n`;
+	out += `#include <string.h>\n`;
+	out += `#include <regex.h>\n`;
+	if (status.file_scope_c?.includes("pthread") || status.emit_mode === "system") out += `#include <pthread.h>\n`;
+	out += "\n";
+	if (status.audit) {
+		out += `void *nomen_malloc_wrap(unsigned long);\n`;
+		out += `void *nomen_calloc_wrap(unsigned long, unsigned long);\n`;
+		out += `void *nomen_realloc_wrap(void *, unsigned long);\n`;
+		out += `void nomen_free_wrap(void *);\n`;
+		out += `void *nomen_strdup_wrap(const char *);\n`;
+		out += `void nomen_audit_check(void);\n`;
+		out += "\n";
+	}
+	if (status.emit_mode === "system") {
+		out += runtime_declarations(POOL_HEADER_C + FIBER_HEADER_C);
+		out += "\n";
+	} else {
+		if (!status.pool_runtime_emitted) {
+			out += POOL_HEADER_C;
+			status.pool_runtime_emitted = true;
+		}
+		if (!status.fiber_runtime_emitted) {
+			out += FIBER_HEADER_C;
+			status.fiber_runtime_emitted = true;
+		}
+	}
+	const enum_nodes = status.enums.filter((e) => !e.is_generic);
+	const struct_nodes = status.structs.filter((s) => !s.is_simple_type && !s.is_generic);
+	const node_kind = /* @__PURE__ */ new Map();
+	for (const e of enum_nodes) node_kind.set(e.name, "enum");
+	for (const st of struct_nodes) node_kind.set(st.name, "struct");
+	for (const b of status.bitsets) node_kind.set(b.name, "bitset");
+	const deps = /* @__PURE__ */ new Map();
+	for (const e of enum_nodes) {
+		const d = /* @__PURE__ */ new Set();
+		for (const c of e.cases) for (const p of c.params) if (node_kind.has(p.type.name) && p.type.name !== e.name) d.add(p.type.name);
+		deps.set(e.name, d);
+	}
+	for (const st of struct_nodes) {
+		const d = /* @__PURE__ */ new Set();
+		for (const f of st.fields) {
+			if (f.type.is_view) continue;
+			const field_type = mono_struct_name(f.type, status);
+			if (status.structs.find((s) => s.name === field_type && !s.is_simple_type)?.is_class) continue;
+			if (node_kind.has(field_type) && field_type !== st.name) d.add(field_type);
+		}
+		deps.set(st.name, d);
+	}
+	const emitted = /* @__PURE__ */ new Set();
+	const visiting = /* @__PURE__ */ new Set();
+	const node_list = [
+		...enum_nodes,
+		...struct_nodes,
+		...status.bitsets
+	];
+	const by_name = new Map(node_list.map((n) => [n.name, n]));
+	const visit = (name) => {
+		if (emitted.has(name) || visiting.has(name)) return;
+		visiting.add(name);
+		for (const dep of deps.get(name) ?? []) visit(dep);
+		visiting.delete(name);
+		emitted.add(name);
+		const node = by_name.get(name);
+		if (!node) return;
+		if (node_kind.get(name) === "enum") out += generate_enum_definition(node, status);
+		else if (node_kind.get(name) === "bitset") out += `typedef unsigned long ${nm(name)};\n`;
+		else out += generate_struct_definition(node, status);
+	};
+	for (const n of node_list) visit(n.name);
+	out += "\n";
+	if (status.file_scope_c) {
+		out += status.file_scope_c;
+		out += "\n";
+	}
+	for (const entry of functions) out += generate_c_function(entry.func, entry.struct_name, entry.raw_code, status, entry.bridge_c_abi);
+	return out;
+}
+/**
+* Prefix a Nomen type's C TYPEDEF name with `nm_`. The companion file `#import`s
+* the platform frameworks (Foundation/Cocoa/UIKit), which drag in a large set of
+* system typedefs (e.g. macOS `MacTypes.h` defines `typedef long Size`). If we
+* emitted Nomen's own `typedef struct Size {...} Size;` the typedef name would
+* collide; mangling only the typedef (`typedef struct Size {...} nm_Size;`)
+* sidesteps it while leaving the struct TAG (`Size`) untouched.
+*
+* Keeping the original tag matters: generated C (spawn/trampoline infra in
+* build_spawn_node / build_nursery_spawn) and `#arch: aarch64_use_c` raw bodies
+* reference Nomen types as `struct Foo` (the tag), so an unchanged tag means
+* none of that code needs to know about mangling. Codegen-generated references
+* here (fields, params, returns) use the mangled typedef instead.
+*
+* `nm_` (no leading underscore: the C standard reserves `_`+lowercase
+* identifiers at file scope). This is purely cosmetic — the aarch64 assembly
+* never references type names (only function labels, bridged via `__asm__`).
+*/
+function nm(name) {
+	return "nm_" + name;
+}
+/**
+* The C type for a field/param/return of the given Nomen type, applying `nm_`
+* to user-defined struct/enum types and falling back to `c_type` for primitives.
+* Generic structs lower to opaque 8-byte pointers (their element type lives in
+* the Nomen `Type`, not in the C layout).
+*/
+/**
+* The C type for a value stored BY VALUE in an enum payload: classes and
+* traits are heap/shared references (pointers, and never have a companion
+* typedef), everything else follows `companion_type`.
+*/
+function payload_type(typeName, status) {
+	if (status.structs.find((s) => s.name === typeName)?.is_class) return `struct ${typeName} *`;
+	if (status.traits.find((t) => t.name === typeName)) return `struct ${typeName} *`;
+	return companion_type(typeName, status);
+}
+function companion_type(typeName, status) {
+	const struct = status.structs.find((s) => s.name === typeName);
+	if (struct?.is_generic) return "void *";
+	if (struct && !struct.is_simple_type) return nm(typeName);
+	if (!struct && status.enums.find((e) => e.name === typeName)) return nm(typeName);
+	if (status.bitsets.find((b) => b.name === typeName)) return nm(typeName);
+	return c_type(typeName);
+}
+/**
+* Emit an enum's C type definition. Mirrors the C backend's `build_enum_node`
+* (typedef for simple enums; tag + tagged-union struct for enums with associated
+* data) but with `nm_`-prefixed TYPEDEF names and no constructor functions (those
+* are emitted as assembly in the aarch64 path; the companion only needs types so
+* struct fields / function signatures can reference them). The struct tag keeps
+* the original Nomen name (see `nm`).
+*/
+function generate_enum_definition(node, status) {
+	let out = "";
+	if (node.has_associated_data) {
+		out += `typedef enum { ${node.cases.map((c) => `${node.name}_${c.name}`).join(", ")} } ${nm(node.name)}_tag;\n`;
+		out += `struct ${node.name};\n`;
+		out += `typedef struct ${node.name}\n{\n`;
+		out += `${nm(node.name)}_tag tag;\n`;
+		out += `union {\n`;
+		for (const c of node.cases) out += `struct { ${c.params.map((p) => `${payload_type(p.type.name, status)} ${p.name}`).join("; ")}${c.params.length ? ";" : ""} } _${c.name};\n`;
+		out += `} _data;\n`;
+		out += `} ${nm(node.name)};\n`;
+	} else out += `typedef enum { ${node.cases.map((c) => `${node.name}_${c.name}`).join(", ")} } ${nm(node.name)};\n`;
+	return out;
+}
+function generate_struct_definition(struct, status) {
+	let out = `typedef struct ${struct.name}\n{\n`;
+	out += `void *_vt;\n`;
+	for (const field of struct.fields) {
+		const member_type = field.type.is_view ? "nomen_view" : payload_type(mono_struct_name(field.type, status), status);
+		out += `${member_type} ${field.name};\n`;
+	}
+	for (const traitName of struct.traits) {
+		const trait = status.traits.find((t) => t.name === traitName);
+		if (!trait) continue;
+		for (const field of trait.fields.filter((f) => !struct.fields.find((nf) => nf.name === f.name))) {
+			const member_type = field.type.is_view ? "nomen_view" : payload_type(mono_struct_name(field.type, status), status);
+			out += `${member_type} ${field.name};\n`;
+		}
+	}
+	out += `} ${nm(struct.name)};\n`;
+	return out;
+}
+function generate_c_function(func, struct_name, raw_code, status, bridge_c_abi = false) {
+	const func_label = companion_function_label(func, struct_name, status);
+	const is_class_init = func.name === "#init" && !!(struct_name && status.structs.find((s) => s.name === struct_name));
+	const return_type = is_class_init ? "void" : func.return_type?.name || "void";
+	const return_struct = is_class_init ? void 0 : status.structs.find((s) => s.name === return_type && !s.is_simple_type);
+	let return_prefix = return_struct ? nm(return_type) : companion_type(return_type, status);
+	return_prefix += ` `;
+	const return_enum_size = return_struct ? void 0 : get_enum_sret_size(return_type, status);
+	const return_struct_size = return_struct ? get_struct_size(return_type, status) : 0;
+	const symbol_label = sanitize_companion_label(return_struct && return_struct_size <= 16 || return_enum_size !== void 0 && return_enum_size <= 16 || bridge_c_abi ? `${func_label}_c` : func_label);
+	const params = func.params;
+	let param_list = "";
+	for (let i = 0; i < params.length; i++) {
+		if (i > 0) param_list += ", ";
+		param_list += generate_c_param(params[i], status);
+	}
+	if (params.length === 0) param_list += `void`;
+	let out = `// ${func_label}\n`;
+	out += `${return_prefix}${symbol_label}(${param_list}) __asm__("${symbol_label}");\n`;
+	out += `${return_prefix}${symbol_label}(${param_list})\n{\n`;
+	if (func.name === "#init" && struct_name) {
+		const ctor_struct = status.structs.find((s) => s.name === struct_name);
+		if (ctor_struct && !ctor_struct.is_simple_type) {
+			if (ctor_struct.traits.length > 0) {
+				out += `extern void *${struct_name}_traits;\n`;
+				out += `self->_vt = (void *)&${struct_name}_traits;\n`;
+			} else if (!ctor_struct.is_class) out += `self->_vt = (void *)1;\n`;
+			for (const field of ctor_struct.fields) {
+				if (!field.value) continue;
+				let seeded;
+				if (field.value.node_type === "func_call" && field.value.params?.length === 0) seeded = emit_zero_ctor_field_default(field.type.name, field.type.type_args, `self->${field.name}`, status, /* @__PURE__ */ new Set());
+				if (!seeded) seeded = emit_ctor_field_default(ctor_struct, field);
+				if (!seeded) {
+					if (!status.build_errors) status.build_errors = [];
+					status.build_errors.push({
+						message: `mv struct '${struct_name}' has a use_c constructor and field '${field.name}' has a non-literal default — assign it in the #init body`,
+						start: func.start
+					});
+					continue;
+				}
+				out += seeded;
+			}
+		}
+	}
+	const self_param = params[0];
+	if (struct_name && self_param?.is_self_param && !self_param?.is_ref && func.name !== "#destroy" && func.name !== "#init") {
+		const struct = status.structs.find((s) => s.name === struct_name);
+		if (struct && !struct.is_simple_type) out += `${nm(struct_name)} _self = *self;\n`;
+	}
+	out += raw_code;
+	out += `\n}\n\n`;
+	return out;
+}
+/**
+* The C statement seeding a defaulted field in a companion constructor, or
+* `undefined` when the default is not a literal shape. Mirrors the ASM-side
+* ctor's default seeding for the shapes a `use_c` constructor can express:
+* string literals borrow static storage (a function-static C literal — never
+* strdup'd, matching the ASM literal-pair store), scalar/bool literals store
+* directly. Nullable and computed defaults are rejected — the caller turns
+* that into a build error naming the field.
+*/
+function emit_ctor_field_default(struct_node, field) {
+	const value = field.value?.node_type === "value" ? field.value.value : void 0;
+	if (value === void 0 || typeof value !== "string") return void 0;
+	if (field.type.is_nullable) return void 0;
+	if (field.type.name === "string" && !field.type.is_view) {
+		const length = string_literal_length(value);
+		const label = `_${struct_node.name}_${field.name}_default`;
+		return `static const char ${label}[] = ${escape_asciz(value)};\nself->${field.name} = (nomen_string){ (char *)${label}, ${length} };\n`;
+	}
+	if (value === "true" || value === "false") return `self->${field.name} = ${value === "true" ? 1 : 0};\n`;
+	if (/^-?\d+$/.test(value)) return `self->${field.name} = ${value};\n`;
+}
+/**
+* The zero-arg CONSTRUCTOR-call field default (`var List<ClickBinding>
+* clicks = List<ClickBinding>()`) in a use_c ctor's companion prologue:
+* the System containers' zero-arg init is exactly stamp/traits + zeroed
+* fields (every container field default is a literal zero or a nested
+* container ctor call), so seed that shape DIRECTLY. A companion→asm call
+* (`List_T_init(&self->f)`) is not available here — method labels are
+* file-local outside system builds, so the companion object could not link
+* the reference. Returns undefined for anything unsupported (a custom
+* zero-arg init could have side effects; the caller's build error names
+* the field). `seen` guards the container nesting (List → Buffer).
+*/
+function emit_zero_ctor_field_default(type_name, type_args, target, status, seen) {
+	const resolved = type_args?.length && status.structs.some((s) => s.name === mono_type_name(type_name, type_args)) ? mono_type_name(type_name, type_args) : type_name;
+	if (!is_load_deep_copy_container(resolved)) return void 0;
+	const struct = status.structs.find((s) => s.name === resolved);
+	if (!struct || struct.is_generic || struct.is_simple_type || struct.is_class) return void 0;
+	if (struct.functions.some((f) => f.name === "#init" && f.has_body)) return void 0;
+	if (seen.has(resolved)) return "";
+	seen.add(resolved);
+	let out = "";
+	if (struct.traits.length > 0) {
+		out += `extern void *${resolved}_traits;\n`;
+		out += `${target}._vt = (void *)&${resolved}_traits;\n`;
+	} else out += `${target}._vt = (void *)1;\n`;
+	for (const f of struct.fields) {
+		if (f.type.is_nullable) return void 0;
+		const fv = f.value?.node_type === "value" ? f.value.value : void 0;
+		if (f.value?.node_type === "func_call") {
+			const nested = emit_zero_ctor_field_default(f.type.name, f.type.type_args, `${target}.${f.name}`, status, seen);
+			if (nested === void 0) return void 0;
+			out += nested;
+			continue;
+		}
+		if (typeof fv !== "string") return void 0;
+		if (f.type.name === "string" && !f.type.is_view && fv.startsWith("\"")) return;
+		if (fv !== "0") return void 0;
+		out += `${target}.${f.name} = 0;\n`;
+	}
+	return out;
+}
+function generate_c_param(param, status) {
+	const struct_type = status.structs.find((s) => s.name === param.type.name);
+	const trait_type = status.traits.find((t) => t.name === param.type.name);
+	const is_struct = (param.is_self_param || struct_type || trait_type) && !struct_type?.is_simple_type;
+	let out = "";
+	if (param.is_variadic) out += `long _${param.name}_len, `;
+	out += companion_type(param.type.name, status);
+	if (is_struct || param.declaration === "var" || param.type.is_ref || param.type.is_array) out += ` *`;
+	else out += ` `;
+	out += param.name;
+	return out;
+}
+//#endregion
+//#region ../src/build_aarch64/utils/raw_reload.ts
+/** Width-aware slot reload — mirrors the prologue's store width so the
+*  register holds exactly the value a body read of the slot would produce
+*  (sub-word stores truncate; a same-width load zero-extends like the
+*  emitters' own slot reads). */
+function raw_slot_reload_line(reg, offset, size) {
+	const wreg = reg.replace("x", "w");
+	if (size === 1) return `ldrb ${wreg}, [x29, #${offset}]`;
+	if (size === 2) return `ldrh ${wreg}, [x29, #${offset}]`;
+	if (size === 4) return `ldr ${wreg}, [x29, #${offset}]`;
+	return `ldr ${reg}, [x29, #${offset}]`;
+}
+/** Capture status.code.length as the entry point and install the plan. */
+function install_raw_reload_plan(status, lines) {
+	const plan = {
+		entry_marker: asm_code_len(status),
+		lines
+	};
+	status.raw_param_reloads = plan;
+	return plan;
+}
+/**
+* The reload lines a raw block needs: none at the function's entry point
+* (the registers still hold the entry values), otherwise the lines for the
+* ABI registers the block's text references. Registers are matched against
+* comment-stripped instruction text only — a mention in a `//` comment, a
+* label, or a data directive doesn't force a reload (same discipline as
+* build_inline_method's count_x19_reads).
+*/
+function raw_reload_lines_for(code, plan, current_length) {
+	if (!plan || plan.lines.length === 0 || current_length === plan.entry_marker) return [];
+	const referenced = /* @__PURE__ */ new Set();
+	for (const raw_line of code.split("\n")) {
+		const comment = raw_line.indexOf("//");
+		const line = (comment === -1 ? raw_line : raw_line.slice(0, comment)).trim();
+		if (!line || line.endsWith(":") || line.startsWith(".")) continue;
+		for (const match of line.matchAll(/\b[wx][0-9]\b/g)) referenced.add(match[0]);
+	}
+	const out = [];
+	for (const entry of plan.lines) if (referenced.has(entry.reg) || referenced.has(entry.reg.replace("x", "w"))) out.push(entry.asm);
+	return out;
+}
+//#endregion
 //#region ../src/build_aarch64/build_raw_node.ts
 function build_raw_node$1(node, status) {
 	const { should_emit, code, is_c, scope } = parse_raw_directives(node.value, "aarch64", status.platform);
@@ -14801,8 +15431,11 @@ function build_raw_node$1(node, status) {
 			if (!status.file_scope_c) status.file_scope_c = "";
 			status.file_scope_c += `${code}\n`;
 		} else {
-			if (!status.c_companion) status.c_companion = "";
-			status.c_companion += `${code}\n`;
+			if (!status.build_errors) status.build_errors = [];
+			status.build_errors.push({
+				message: `aarch64 cannot splice an inline C raw block into a Nomen body — a C raw block is emitted only as a function's whole body; move this block into its own aarch64_use_c function and pass values as parameters`,
+				start: node.start
+			});
 		}
 	} else {
 		for (const line of raw_reload_lines_for(code, status.raw_param_reloads, asm_code_len(status))) emit_asm(status, `${line}\n`);
@@ -14853,6 +15486,16 @@ function check_c_fallback(func, struct_name, status) {
 			else raw_code += parsed.code + "\n";
 		}
 	}
+	let float_bridge = has_float_abi_divergence(func);
+	if (float_bridge && func.params.some((p) => p.is_variadic)) {
+		if (!status.build_errors) status.build_errors = [];
+		const label = struct_name ? `${struct_name}.${func.name.replace(/#/g, "")}` : func.name;
+		status.build_errors.push({
+			message: `Function ${label} mixes variadic params with floats — no aarch64_use_c ABI thunk for that shape`,
+			start: func.start
+		});
+		float_bridge = false;
+	}
 	if (is_c_fallback) {
 		if (file_scope_code) {
 			if (!status.file_scope_c) status.file_scope_c = "";
@@ -14862,38 +15505,84 @@ function check_c_fallback(func, struct_name, status) {
 		status.c_companion_functions.push({
 			func,
 			struct_name,
-			raw_code
+			raw_code,
+			bridge_c_abi: float_bridge
 		});
-		const return_type = func.name === "#init" && !!struct_name ? "" : func.return_type?.name || "";
+		const is_ctor = func.name === "#init" && !!struct_name;
+		const return_type = is_ctor ? "" : func.return_type?.name || "";
 		const return_struct = status.structs.find((s) => s.name === return_type && !s.is_simple_type && !s.is_class);
 		const enum_sret_size = get_enum_sret_size(return_type, status);
+		let sret_size;
 		if (return_struct) {
 			const struct_size = get_struct_size(return_type, status);
-			if (struct_size <= 16) emit_struct_return_thunk(func, struct_name, status, struct_size);
+			if (struct_size <= 16) sret_size = struct_size;
 		} else if (enum_sret_size !== void 0) {
-			if (enum_sret_size <= 16) emit_struct_return_thunk(func, struct_name, status, enum_sret_size);
+			if (enum_sret_size <= 16) sret_size = enum_sret_size;
 		}
+		if (float_bridge) emit_c_abi_thunk(func, struct_name, status, is_ctor ? void 0 : sret_size);
+		else if (!is_ctor && sret_size !== void 0) emit_c_abi_thunk(func, struct_name, status, sret_size);
 		return true;
 	}
 	return false;
 }
-function emit_struct_return_thunk(func, struct_name, status, struct_size) {
+/**
+* Does this parameter type ride the C ABI's d-register file? Nomen `float*`
+* types are 64-bit doubles (`c_type: "double"`).
+*/
+function is_float_type_name(name) {
+	return name.startsWith("float") || name.startsWith("ufloat");
+}
+/** Any float param, or a float return? (see emit_c_abi_thunk case 2) */
+function has_float_abi_divergence(func) {
+	if (is_float_type_name(func.return_type?.name || "")) return true;
+	return func.params.some((p) => !p.is_variadic && is_float_type_name(p.type.name));
+}
+function emit_c_abi_thunk(func, struct_name, status, struct_size) {
 	const func_label = get_func_label(func, struct_name, status);
-	const c_label = `${func_label}_c`;
-	const words = Math.ceil(struct_size / 8);
+	const c_label = sanitize_companion_label(`${func_label}_c`);
+	const words = struct_size !== void 0 ? Math.ceil(struct_size / 8) : 0;
+	const return_is_float = is_float_type_name(func.return_type?.name || "");
 	emit_asm(status, `.p2align 2\n`);
 	emit_asm(status, `${func_label}:\n`);
 	emit_asm(status, `stp x29, x30, [sp, #-16]!\n`);
-	emit_asm(status, `sub sp, sp, #16\n`);
-	emit_asm(status, `str x8, [sp, #0]\n`);
-	emit_asm(status, `bl ${c_label}\n`);
-	emit_asm(status, `ldr x8, [sp, #0]\n`);
-	for (let i = 0; i < words; i++) {
-		const reg = i === 0 ? "x0" : i === 1 ? "x1" : `x${i}`;
-		if (i === 0) emit_asm(status, `str ${reg}, [x8]\n`);
-		else emit_asm(status, `str ${reg}, [x8, #${i * 8}]\n`);
+	emit_asm(status, `mov x29, sp\n`);
+	if (struct_size !== void 0) {
+		emit_asm(status, `sub sp, sp, #16\n`);
+		emit_asm(status, `str x8, [sp, #0]\n`);
+	}
+	let in_slot = 0;
+	let out_x = 0;
+	let out_d = 0;
+	const x_moves = [];
+	const d_moves = [];
+	for (const param of func.params) {
+		if (is_float_type_name(param.type.name)) {
+			d_moves.push({
+				out: out_d++,
+				in: in_slot
+			});
+			in_slot += 1;
+			continue;
+		}
+		const slots = param.type.name === "string" || param.type.is_view ? 2 : 1;
+		x_moves.push({
+			out: out_x,
+			in: in_slot
+		});
+		out_x += slots;
+		in_slot += slots;
 	}
-	emit_asm(status, `add sp, sp, #16\n`);
+	for (const m of d_moves) emit_asm(status, `fmov d${m.out}, x${m.in}\n`);
+	for (let i = x_moves.length - 1; i >= 0; i--) {
+		const { out, in: inc } = x_moves[i];
+		if (out !== inc) emit_asm(status, `mov x${out}, x${inc}\n`);
+	}
+	emit_asm(status, `bl ${c_label}\n`);
+	if (struct_size !== void 0) {
+		emit_asm(status, `ldr x8, [sp, #0]\n`);
+		for (let i = 0; i < words; i++) emit_asm(status, `str ${i === 0 ? "x0" : i === 1 ? "x1" : `x${i}`}, [x8, #${i * 8}]\n`);
+		emit_asm(status, `add sp, sp, #16\n`);
+	} else if (return_is_float) emit_asm(status, `fmov x0, d0\n`);
 	emit_asm(status, `ldp x29, x30, [sp], #16\n`);
 	emit_asm(status, `ret\n`);
 }
@@ -16875,9 +17564,11 @@ function is_borrow_accessor_carrier_stamp(decl) {
 * them; the `_recv_N` carrier skips its destroy entirely (it must not free the
 * ALIASED string fields), so each expression use leaked the copied containers.
 * Free exactly the fields the load deep-copied — the same predicate — and only
-* those: plain strings, nested structs and enum fields stay aliased/untouched
-* (they were not deep-copied, so freeing them would be an invalid free).
-* Mirrors the C backend's `emit_load_owned_copies_destroy`.
+* those: plain strings and nested structs stay aliased/untouched (they were
+* not deep-copied, so freeing them would be an invalid free). Enum-with-data
+* fields ride the same gate the load's strdup arm used (enum_copy_is_deep) —
+* their copied payloads are freed here. Mirrors the C backend's
+* `emit_load_owned_copies_destroy`.
 */
 function emit_borrow_carrier_owned_free(status, elem, decl_name) {
 	let offset = 8;
@@ -16899,10 +17590,18 @@ function emit_borrow_carrier_owned_free(status, elem, decl_name) {
 				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")) {
+			if (field_struct && field_load_deep_copy(field_struct, status)) {
 				emit_var_address(status, "x0", decl_name);
 				emit_asm(status, `add x0, x0, #${offset}\n`);
 				emit_asm(status, `bl ${field_struct.name}_destroy\n`);
+				offset += size;
+				continue;
+			}
+			const field_enum = status.enums.find((e) => e.name === field.type.name && e.has_associated_data);
+			if (field_enum && enum_copy_is_deep$1(field_enum, status)) {
+				emit_var_address(status, "x0", decl_name);
+				emit_asm(status, `add x0, x0, #${offset}\n`);
+				emit_enum_payload_frees_at(status, field_enum.name, "x0");
 			}
 		}
 		offset += size;
@@ -17214,6 +17913,12 @@ function emit_field_destroys_at(status, struct_type, root_slot, acc, root_is_cla
 		const offset = get_field_offset_of_fields(fields, field.name, status);
 		const field_struct = is_struct_type$4(resolve_struct_name(field.type.name, field.type.type_args, status), status) || is_struct_type$4(field.type.name, status);
 		const field_acc = acc + offset;
+		if (field.type.is_array && field_struct && !field_struct.is_class) {
+			const elem_size = get_struct_size(field_struct.name, status);
+			const arr_len = field.type.length ? parseInt(field.type.length.value || "0") : 0;
+			for (let i = 0; i < arr_len; i++) emit_destroy_for_array_elem(status, field_struct, () => emit_slot_base(status, root_slot, root_is_class, field_acc), i * elem_size);
+			continue;
+		}
 		if (field_struct) {
 			if (field_struct.is_class && !field.type.is_ref) {
 				emit_slot_base(status, root_slot, root_is_class, field_acc);
@@ -17398,6 +18103,10 @@ function release_records_for_scope_exit(status, decl, moved) {
 * before.
 */
 function emit_moved_local_cleanup(status, decl) {
+	if (decl.type.is_array && decl.type.length) {
+		emit_fixed_array_local_destroys(status, decl);
+		return;
+	}
 	const owns_flag = status.mv_owns_flag?.get(decl.name);
 	if (owns_flag !== void 0 && decl.type.name === "string" && !decl.type.is_array && status.heap_strings?.has(decl.name)) {
 		const skip = `.Lskip_mvowns_${status.label_counter = (status.label_counter ?? 0) + 1}`;
@@ -17515,6 +18224,31 @@ function emit_heap_array_decl_destroy(status, decl_name) {
 	}
 	return false;
 }
+/**
+* A fixed-size array LOCAL of value-struct elements: destroy each element in
+* place (elem_size stride from the var's frame slot). `resolve_decl_struct`
+* resolves the ELEMENT struct by name — array-ness is a Type flag — so the
+* single-struct walk would reclaim element 0's fields only and leak the rest
+* (one label per extra element on a conformer row). Returns true when the
+* declaration was an array (handled or nothing to do); the caller `continue`s
+* so the single-struct path never mistreats the row.
+*/
+function emit_fixed_array_local_destroys(status, decl) {
+	if (!decl.type.is_array || !decl.type.length) return false;
+	const arr_len = parseInt(decl.type.length.value || "0");
+	const elem_struct = is_struct_type$4(decl.type.name, status);
+	if (arr_len > 0 && elem_struct && !elem_struct.is_class && (has_destroy(elem_struct) || struct_needs_destroy(elem_struct, status))) {
+		const elem_size = get_struct_size(elem_struct.name, status);
+		const was_moved = status.moved?.has(decl.name) ?? false;
+		status.moved?.delete(decl.name);
+		for (let i = 0; i < arr_len; i++) {
+			emit_var_address(status, "x0", decl.name);
+			emit_destroy_for_decl(status, decl.name, elem_struct.name, i * elem_size, decl.type.type_args, false);
+		}
+		if (was_moved) status.moved?.add(decl.name);
+	}
+	return true;
+}
 function emit_destroy_for_decl(status, decl_name, decl_type_name, addr_offset, type_args, is_nullable) {
 	const moved = status.moved ?? /* @__PURE__ */ new Set();
 	release_records_for_scope_exit(status, {
@@ -17654,6 +18388,13 @@ function emit_field_destroys(status, struct_type, decl_name, base_offset, is_cla
 			continue;
 		}
 		const field_struct = is_struct_type$4(resolve_struct_name(field.type.name, field.type.type_args, status), status) || is_struct_type$4(field.type.name, status);
+		if (field.type.is_array && field_struct && !field_struct.is_class) {
+			const elem_size = get_struct_size(field_struct.name, status);
+			const arr_len = field.type.length ? parseInt(field.type.length.value || "0") : 0;
+			const actual_base = base_offset !== void 0 ? base_offset + offset : offset;
+			for (let i = 0; i < arr_len; i++) emit_destroy_for_array_elem(status, field_struct, () => emit_base_ptr(status, decl_name, is_class_parent), actual_base + i * elem_size);
+			continue;
+		}
 		if (field_struct) {
 			if (field_struct.is_class && !field.type.is_ref) {
 				if (decl_name) emit_base_ptr(status, decl_name, is_class_parent);
@@ -17688,7 +18429,7 @@ function emit_field_destroys(status, struct_type, decl_name, base_offset, is_cla
 						emit_asm(status, `bl ${resolve_struct_name(field_struct.name, field.type.type_args, status)}_destroy\n`);
 					}
 				}
-				if (field_has_explicit_destroy) emit_nested_field_destroys(status, field_struct, decl_name, base_offset !== void 0 ? base_offset + offset : offset, is_class_parent);
+				if (field_has_explicit_destroy) emit_nested_field_destroys(status, field_struct, () => emit_base_ptr(status, decl_name, is_class_parent), base_offset !== void 0 ? base_offset + offset : offset);
 			}
 		} else if (free_strings && field.type.name === "string" && !field.type.is_array && !field.type.is_ref && !field.type.is_view) {
 			const actual_offset = base_offset !== void 0 ? base_offset + offset : offset;
@@ -17697,6 +18438,9 @@ function emit_field_destroys(status, struct_type, decl_name, base_offset, is_cla
 			emit_free(status);
 		} else if (field.type.name === "func" && !field.type.is_array && (struct_type.is_class || struct_type.is_owning === true)) {
 			const actual_offset = base_offset !== void 0 ? base_offset + offset : offset;
+			const func_field_borrow = !!decl_name && !!status.func_field_borrow_decls?.has(decl_name);
+			if (func_field_borrow) status.func_field_borrow_decls?.delete(decl_name);
+			if (func_field_borrow) continue;
 			if (decl_name) emit_base_ptr(status, decl_name, is_class_parent);
 			const id = status.label_counter = (status.label_counter ?? 0) + 1;
 			const skip = `.Lfield_closure_done_${id}`;
@@ -17723,37 +18467,38 @@ function emit_field_destroys(status, struct_type, decl_name, base_offset, is_cla
 				const elem_size = get_struct_size(field.type.name, status);
 				const arr_len = field.type.length ? parseInt(field.type.length.value || "0") : 0;
 				const actual_base = base_offset !== void 0 ? base_offset + offset : offset;
-				for (let i = 0; i < arr_len; i++) emit_destroy_for_array_elem(status, elem_struct, decl_name, actual_base + i * elem_size, is_class_parent);
+				for (let i = 0; i < arr_len; i++) emit_destroy_for_array_elem(status, elem_struct, () => emit_base_ptr(status, decl_name, is_class_parent), actual_base + i * elem_size);
 			}
 		}
 	}
 }
-function emit_nested_field_destroys(status, struct_type, decl_name, base_offset, is_class_parent) {
+function emit_nested_field_destroys(status, struct_type, emit_base, base_offset) {
 	for (const field of struct_type.fields) {
 		const offset = get_field_offset_of_fields(struct_type.fields, field.name, status);
 		const field_struct = is_struct_type$4(resolve_struct_name(field.type.name, field.type.type_args, status), status) || is_struct_type$4(field.type.name, status);
 		if (field_struct) {
 			if (has_destroy(field_struct)) {
-				emit_base_ptr(status, decl_name, is_class_parent);
+				emit_base();
 				emit_asm(status, `add x0, x0, #${base_offset + offset}\n`);
 				emit_asm(status, `bl ${resolve_struct_name(field_struct.name, field.type.type_args, status)}_destroy\n`);
 			}
-			emit_nested_field_destroys(status, field_struct, decl_name, base_offset + offset, is_class_parent);
+			emit_nested_field_destroys(status, field_struct, emit_base, base_offset + offset);
 		}
 	}
 }
-function emit_destroy_for_array_elem(status, struct_type, decl_name, elem_offset, is_class_parent) {
-	if (has_destroy(struct_type)) {
-		emit_base_ptr(status, decl_name, is_class_parent);
+function emit_destroy_for_array_elem(status, struct_type, emit_base, elem_offset) {
+	if (has_destroy(struct_type) || struct_type.is_class || struct_needs_auto_destroy(struct_type, status)) {
+		emit_base();
 		emit_asm(status, `add x0, x0, #${elem_offset}\n`);
 		emit_asm(status, `bl ${struct_type.name}_destroy\n`);
+		if (struct_type.is_class || struct_type.is_owning === true) return;
 	}
 	let offset = 8;
 	for (const field of struct_type.fields) {
 		const field_struct = is_struct_type$4(resolve_struct_name(field.type.name, field.type.type_args, status), status) || is_struct_type$4(field.type.name, status);
 		if (field_struct) {
 			const field_size = get_type_size(field.type, status);
-			emit_nested_field_destroys(status, field_struct, decl_name, elem_offset + offset, is_class_parent);
+			emit_nested_field_destroys(status, field_struct, emit_base, elem_offset + offset);
 			offset += field_size;
 		} else offset += get_type_size(field.type, status);
 	}
@@ -17924,6 +18669,8 @@ function emit_destroy_for_scope(status, declarations_before) {
 				continue;
 			}
 			if (is_field_struct_borrow(decl)) continue;
+			if (is_pure_borrow_element_load(decl, status)) continue;
+			if (emit_fixed_array_local_destroys(status, decl)) continue;
 			const resolved_decl = resolve_decl_struct(decl, status);
 			if (!resolved_decl) continue;
 			const struct_type = resolved_decl.struct_type;
@@ -18048,6 +18795,8 @@ function emit_destroy_for_scope(status, declarations_before) {
 			continue;
 		}
 		if (is_field_struct_borrow(decl)) continue;
+		if (is_pure_borrow_element_load(decl, status)) continue;
+		if (emit_fixed_array_local_destroys(status, decl)) continue;
 		const resolved_decl = resolve_decl_struct(decl, status);
 		if (!resolved_decl) continue;
 		const struct_type = resolved_decl.struct_type;
@@ -18188,6 +18937,7 @@ function emit_owning_field_strdups_at(status, struct_name, base_reg, base_offset
 		if (field.type.is_ref || field.type.is_view || field.type.is_array) continue;
 		const field_struct = status.structs.find((s) => s.name === field.type.name && !s.is_simple_type && !s.is_class);
 		if (!field_struct) continue;
+		if (field_load_deep_copy(field_struct, status)) continue;
 		if (!(has_destroy(field_struct) ? owns_strings_uniformly(field_struct) : struct_needs_auto_destroy(field_struct, status))) continue;
 		const nested_off = base_offset + get_field_offset(struct_name, field.name, status);
 		if (is_nullable_struct_type(field.type, status)) {
@@ -21107,10 +21857,14 @@ function emit_transfer_owning_fields$1(status, src, fields) {
 }
 /**
 * Emit the deep-copy half of mv 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
+* each field that `field_load_deep_copy` accepts (the containers, and
+* nested mv user structs whose auto-derived `copy` is deep), replace the
+* shallow-copied field with `<Mono>_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`.
+* final result write); a `Box<T>` field is cloned, and an enum-with-data
+* field whose payloads are all deep-copyable gets its string payloads
+* strdup'd in place (the enum_copy_is_deep gate). 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).
 */
@@ -21134,11 +21888,15 @@ function emit_load_deep_copy_fields$1(elem, status, sret, slot) {
 				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")) {
+			if (field_struct && field_load_deep_copy(field_struct, status)) {
 				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;
+				continue;
 			}
+			const field_enum = status.enums.find((e) => e.name === field.type.name && e.has_associated_data);
+			if (field_enum && enum_copy_is_deep$1(field_enum, status)) emit_enum_payload_strdups_at(status, field_enum.name, sret, offset);
 		}
 		offset += size;
 	}
@@ -21246,12 +22004,20 @@ 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" && func_name !== "load") return false;
+		if (func_name !== "store" && func_name !== "replace" && func_name !== "shift" && func_name !== "modify" && func_name !== "load" && func_name !== "alloc") return false;
+		if (func_name === "alloc") {
+			emit_owning_alloc_T(elem, status);
+			return true;
+		}
 		emit_owning_standalone_struct(elem, func_name, status);
 		return true;
 	}
 	const enum_elem = owning_buffer_enum_element_aarch64(node, status);
 	if (enum_elem) {
+		if (func_name === "alloc") {
+			emit_enum_alloc_T(enum_elem, status);
+			return true;
+		}
 		if (func_name === "store") {
 			emit_enum_store_T(enum_elem, status, "x19");
 			return true;
@@ -21271,6 +22037,10 @@ function emit_owning_buffer_standalone_aarch64(node, func_name, status) {
 		return false;
 	}
 	if (owning_buffer_is_string_elem_aarch64(node)) {
+		if (func_name === "alloc") {
+			emit_string_alloc_T(status);
+			return true;
+		}
 		if (func_name === "store") {
 			emit_string_store_T(status, "x19");
 			return true;
@@ -21338,6 +22108,7 @@ function emit_owning_standalone_struct(elem, func_name, status) {
 	emit_asm(status, `madd x4, x1, x22, xzr\n`);
 	emit_asm(status, `add x20, x20, x4\n`);
 	emit_asm(status, `mov x21, x2\n`);
+	if (func_name === "store") emit_displaced_owned_reclaim_a64(status, elem, "x20", "x21");
 	if (func_name === "replace") emit_guarded_slot_destroy(status, elem, "x20");
 	if (func_name === "store" && string_fields.length) {
 		emit_asm(status, `sub sp, sp, #${Math.ceil(string_fields.length * 8 / 16) * 16}\n`);
@@ -21621,6 +22392,7 @@ function emit_owning_store_T(elem, status) {
 	emit_asm(status, `madd x4, x1, x22, xzr\n`);
 	emit_asm(status, `add x20, x20, x4\n`);
 	emit_asm(status, `mov x21, x2\n`);
+	emit_displaced_owned_reclaim_a64(status, elem, "x20", "x21");
 	if (string_fields.length) {
 		emit_asm(status, `sub sp, sp, #${Math.ceil(string_fields.length * 8 / 16) * 16}\n`);
 		string_fields.forEach((f, i) => {
@@ -21692,6 +22464,86 @@ function emit_owning_replace_T(elem, status) {
 * `#destroy` body would fire on empty cap slots. `slot_reg` must hold the
 * slot ADDRESS and is clobbered only by the destroy call itself.
 */
+/**
+* Specialized `alloc` for `Buffer<string>`: free each old slot's ptr half
+* (zeroed slots free NULL — a no-op), free the slab, calloc the exact fresh
+* slab. x19 = self, x1 = size; returns cap.
+*/
+function emit_string_alloc_T(status) {
+	const lbl = (s) => `.Lsalloc_${s}_${status.label_counter = (status.label_counter ?? 0) + 1}`;
+	const fresh = lbl("fresh");
+	const drop = lbl("drop");
+	const loop = lbl("loop");
+	const skip = lbl("skip");
+	emit_asm(status, `stp x20, x21, [sp, #-16]!\n`);
+	emit_asm(status, `str x22, [sp, #-16]!\n`);
+	emit_asm(status, `mov x22, x1\n`);
+	emit_asm(status, `ldr x20, [x19, #8]\n`);
+	emit_asm(status, `cbz x20, ${fresh}\n`);
+	emit_asm(status, `ldr x21, [x19, #16]\n`);
+	emit_asm(status, `cbz x21, ${drop}\n`);
+	emit_asm(status, `${loop}:\n`);
+	emit_asm(status, `sub x21, x21, #1\n`);
+	emit_asm(status, `lsl x9, x21, #4\n`);
+	emit_asm(status, `add x9, x20, x9\n`);
+	emit_asm(status, `ldr x0, [x9]\n`);
+	emit_asm(status, `cbz x0, ${skip}\n`);
+	emit_free(status);
+	emit_asm(status, `${skip}:\n`);
+	emit_asm(status, `cbnz x21, ${loop}\n`);
+	emit_asm(status, `${drop}:\n`);
+	emit_asm(status, `mov x0, x20\n`);
+	emit_free(status);
+	emit_asm(status, `${fresh}:\n`);
+	emit_asm(status, `mov x0, x22\n`);
+	emit_asm(status, `mov x1, #16\n`);
+	emit_asm(status, status.audit ? `bl _nomen_calloc_wrap\n` : `bl _calloc\n`);
+	emit_asm(status, `str x0, [x19, #8]\n`);
+	emit_asm(status, `str x22, [x19, #16]\n`);
+	emit_asm(status, `ldr x0, [x19, #16]\n`);
+	emit_asm(status, `ldr x22, [sp], #16\n`);
+	emit_asm(status, `ldp x20, x21, [sp], #16\n`);
+}
+/**
+* Specialized `alloc` for a Buffer whose element is an enum-with-data: free
+* each old slot's payloads in place, free the slab, calloc the exact fresh
+* slab. x19 = self, x1 = size; returns cap.
+*/
+function emit_enum_alloc_T(en, status) {
+	const E_SIZE = get_enum_size(en.name, status);
+	const lbl = (s) => `.Lealloc_${s}_${status.label_counter = (status.label_counter ?? 0) + 1}`;
+	const fresh = lbl("fresh");
+	const drop = lbl("drop");
+	const loop = lbl("loop");
+	emit_asm(status, `stp x20, x21, [sp, #-16]!\n`);
+	emit_asm(status, `str x22, [sp, #-16]!\n`);
+	emit_asm(status, `str x23, [sp, #-16]!\n`);
+	emit_asm(status, `mov x22, x1\n`);
+	emit_asm(status, `ldr x20, [x19, #8]\n`);
+	emit_asm(status, `cbz x20, ${fresh}\n`);
+	emit_asm(status, `ldr x21, [x19, #16]\n`);
+	emit_asm(status, `cbz x21, ${drop}\n`);
+	emit_asm(status, `mov x23, x21\n`);
+	emit_asm(status, `${loop}:\n`);
+	emit_asm(status, `sub x23, x23, #1\n`);
+	emit_asm(status, `mov x9, #${E_SIZE}\n`);
+	emit_asm(status, `madd x10, x23, x9, x20\n`);
+	emit_enum_payload_frees_at(status, en.name, "x10", 0);
+	emit_asm(status, `cbnz x23, ${loop}\n`);
+	emit_asm(status, `${drop}:\n`);
+	emit_asm(status, `mov x0, x20\n`);
+	emit_free(status);
+	emit_asm(status, `${fresh}:\n`);
+	emit_asm(status, `mov x0, x22\n`);
+	emit_asm(status, `mov x1, #${E_SIZE}\n`);
+	emit_asm(status, status.audit ? `bl _nomen_calloc_wrap\n` : `bl _calloc\n`);
+	emit_asm(status, `str x0, [x19, #8]\n`);
+	emit_asm(status, `str x22, [x19, #16]\n`);
+	emit_asm(status, `ldr x0, [x19, #16]\n`);
+	emit_asm(status, `ldr x23, [sp], #16\n`);
+	emit_asm(status, `ldr x22, [sp], #16\n`);
+	emit_asm(status, `ldp x20, x21, [sp], #16\n`);
+}
 function emit_guarded_slot_destroy(status, elem, slot_reg) {
 	const skip = `.Lown_slot_skip_${status.label_counter = (status.label_counter ?? 0) + 1}`;
 	emit_asm(status, `ldr x9, [${slot_reg}]\n`);
@@ -21701,6 +22553,279 @@ function emit_guarded_slot_destroy(status, elem, slot_reg) {
 	emit_asm(status, `${skip}:\n`);
 }
 /**
+* The container monos whose `<T>_destroy` reclaims the whole container
+* (slab + per-element owned state): the core value-slot containers. A user
+* mv struct must NOT take this path (its destroy would free its string
+* fields too — the string machinery owns those) — such fields recurse.
+*/
+const CONTAINER_MONO_PREFIXES_A64 = [
+	"Buffer_",
+	"List_",
+	"Map_",
+	"Set_",
+	"Array_"
+];
+function is_container_mono_name_a64(name) {
+	return CONTAINER_MONO_PREFIXES_A64.some((p) => name.startsWith(p));
+}
+/** Offsets (relative to the container struct start) of every owned slab
+*  pointer inside a container mono: the `data` words of the Buffer-shaped
+*  structs reachable through nested struct fields. The displaced-reclaim
+*  guard compares ALL of them — a byte-copy round-trip aliases every slab
+*  pointer; any differing pointer means the displaced container's slabs are
+*  exclusively owned. */
+function container_data_offsets_a64(fs, status, base = 0) {
+	const out = [];
+	let offset = 8;
+	for (const field of fs.fields) {
+		const size = get_type_size(field.type, status);
+		if (field.name === "data") {
+			out.push(base + offset);
+			offset += size;
+			continue;
+		}
+		if (!field.type.is_ref && !field.type.is_view && !field.type.is_array) {
+			if (field.type.name === "string" && !field.type.is_array) {
+				offset += aarch64_size("string");
+				continue;
+			}
+			const sub = resolve_struct_type(field.type, status);
+			if (sub && !sub.is_class && is_container_mono_name_a64(sub.name)) {
+				out.push(...container_data_offsets_a64(sub, status, base + offset));
+				offset += size;
+				continue;
+			}
+		}
+		offset += size;
+	}
+	return out;
+}
+/**
+* Collect the owned POINTER leaves of an element struct whose displaced
+* copies a store onto an occupied slot must reclaim: containers, Box/class
+* fields, func descriptors, enum-with-data payloads. Plain string fields are
+* EXCLUDED (store_T's string machinery owns their displaced-old reclaim, and
+* a whole-struct destroy here would double-free them); plain nested mv
+* structs recurse so their pointer leaves are reached.
+*/
+function collect_displaced_leaves_a64(elem, status, base = 0) {
+	const leaves = [];
+	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) {
+			if (field.type.name === "string" && !field.type.is_array) {
+				offset += aarch64_size("string");
+				continue;
+			}
+			const box_mono = box_field_mono(field.type, status);
+			if (box_mono) {
+				leaves.push({
+					offset: base + offset,
+					kind: "box",
+					destroy: box_mono.name,
+					identities: [0]
+				});
+				offset += size;
+				continue;
+			}
+			const fs = resolve_struct_type(field.type, status);
+			if (fs?.is_class) {
+				leaves.push({
+					offset: base + offset,
+					kind: "class",
+					destroy: fs.name,
+					identities: [0]
+				});
+				offset += size;
+				continue;
+			}
+			if (field.type.name === "func") {
+				leaves.push({
+					offset: base + offset,
+					kind: "func",
+					identities: [0]
+				});
+				offset += size;
+				continue;
+			}
+			const field_enum = status.enums.find((e) => e.name === field.type.name && e.has_associated_data);
+			if (field_enum) {
+				leaves.push({
+					offset: base + offset,
+					kind: "enum",
+					enum_node: field_enum,
+					identities: []
+				});
+				offset += size;
+				continue;
+			}
+			if (fs && !fs.is_class) {
+				if (is_container_mono_name_a64(fs.name)) {
+					leaves.push({
+						offset: base + offset,
+						kind: "container",
+						destroy: fs.name,
+						identities: container_data_offsets_a64(fs, status)
+					});
+					offset += size;
+					continue;
+				}
+				if (struct_needs_destroy(fs, status) || has_string_fields(fs, status)) {
+					leaves.push(...collect_displaced_leaves_a64(fs, status, base + offset));
+					offset += size;
+					continue;
+				}
+			}
+		}
+		offset += size;
+	}
+	return leaves;
+}
+/**
+* Emit the DISPLACED-OWNED reclaim for a store onto an occupied slot (the
+* residual Buffer hole in FOLLOWUP.md — store's fresh-slot contract leaked
+* every owned pointer field of the previous occupant except strings, which
+* the B1 displaced-old free already handles). Runs BEFORE the slot memcpy
+* (both identity sides are live): per leaf, the slot's field is destroyed IN
+* PLACE only when the incoming value does not alias it — the load→modify→store
+* round-trip (a byte-copied alias) keeps the slot's own state, which the
+* subsequent memcpy then replaces wholesale.
+*
+* `slot_reg` holds &slot[i]; `val_reg` holds the incoming value's address.
+* Both must be callee-saved (the destroys call).
+*/
+function emit_displaced_owned_reclaim_a64(status, elem, slot_reg, val_reg) {
+	const leaves = collect_displaced_leaves_a64(elem, status);
+	for (const leaf of leaves) {
+		const next = `.Ldisp_done_${status.label_counter = (status.label_counter ?? 0) + 1}`;
+		if (leaf.kind === "container") {
+			if (leaf.identities.length) {
+				emit_asm(status, `ldr x9, [${slot_reg}, #${leaf.offset + leaf.identities[0]}]\n`);
+				emit_asm(status, `cbz x9, ${next}\n`);
+			}
+			for (const id of leaf.identities) {
+				emit_asm(status, `ldr x9, [${slot_reg}, #${leaf.offset + id}]\n`);
+				emit_asm(status, `ldr x10, [${val_reg}, #${leaf.offset + id}]\n`);
+				emit_asm(status, `cmp x9, x10\n`);
+				emit_asm(status, `b.eq ${next}\n`);
+			}
+			if (slot_reg === "x0") {
+				if (leaf.offset !== 0) emit_asm(status, `add x0, x0, #${leaf.offset}\n`);
+			} else emit_asm(status, `add x0, ${slot_reg}, #${leaf.offset}\n`);
+			emit_asm(status, `bl ${leaf.destroy}_destroy\n`);
+		} else if (leaf.kind === "box" || leaf.kind === "class") {
+			emit_asm(status, `ldr x9, [${slot_reg}, #${leaf.offset}]\n`);
+			emit_asm(status, `cbz x9, ${next}\n`);
+			emit_asm(status, `ldr x10, [${val_reg}, #${leaf.offset}]\n`);
+			emit_asm(status, `cmp x9, x10\n`);
+			emit_asm(status, `b.eq ${next}\n`);
+			emit_asm(status, `mov x0, x9\n`);
+			emit_asm(status, `bl ${leaf.destroy}_destroy\n`);
+			emit_asm(status, `ldr x0, [${slot_reg}, #${leaf.offset}]\n`);
+			emit_free(status);
+		} else if (leaf.kind === "func") {
+			const no_destroy = `.Ldisp_noown_${status.label_counter = (status.label_counter ?? 0) + 1}`;
+			emit_asm(status, `ldr x9, [${slot_reg}, #${leaf.offset}]\n`);
+			emit_asm(status, `cbz x9, ${next}\n`);
+			emit_asm(status, `ldr x10, [${val_reg}, #${leaf.offset}]\n`);
+			emit_asm(status, `cmp x9, x10\n`);
+			emit_asm(status, `b.eq ${next}\n`);
+			emit_asm(status, `ldr w11, [x9, #16]\n`);
+			emit_asm(status, `cbz w11, ${next}\n`);
+			emit_asm(status, `str x9, [sp, #-16]!\n`);
+			emit_asm(status, `ldr x10, [x9, #24]\n`);
+			emit_asm(status, `cbz x10, ${no_destroy}\n`);
+			emit_asm(status, `ldr x0, [x9, #8]\n`);
+			emit_asm(status, `blr x10\n`);
+			emit_asm(status, `${no_destroy}:\n`);
+			emit_asm(status, `ldr x0, [sp]\n`);
+			emit_asm(status, `ldr x0, [x0, #8]\n`);
+			emit_free(status);
+			emit_asm(status, `ldr x0, [sp], #16\n`);
+			emit_free(status);
+		} else if (leaf.kind === "enum" && leaf.enum_node) {
+			const en = leaf.enum_node;
+			const owning_cases = en.cases.filter((c) => c.params.some((p) => p.type.name === "string" || enum_payload_is_reference_a64(p, status)));
+			if (!owning_cases.length) continue;
+			emit_asm(status, `ldr w9, [${slot_reg}, #${leaf.offset}]\n`);
+			for (const c of owning_cases) {
+				const idx = get_enum_case_index(en.name, c.name, status);
+				const case_next = `.Ldisp_case_${status.label_counter = (status.label_counter ?? 0) + 1}`;
+				emit_asm(status, `cmp w9, #${idx}\n`);
+				emit_asm(status, `b.ne ${case_next}\n`);
+				emit_asm(status, `ldr w10, [${val_reg}, #${leaf.offset}]\n`);
+				emit_asm(status, `cmp w10, #${idx}\n`);
+				emit_asm(status, `b.ne ${next}_reclaim\n`);
+				for (const p of c.params) {
+					if (p.type.name !== "string" && !enum_payload_is_reference_a64(p, status)) continue;
+					const poff = get_enum_payload_offset(en.name, c.name, p.name, status);
+					emit_asm(status, `ldr x9, [${slot_reg}, #${leaf.offset + poff}]\n`);
+					emit_asm(status, `ldr x10, [${val_reg}, #${leaf.offset + poff}]\n`);
+					emit_asm(status, `cmp x9, x10\n`);
+					emit_asm(status, `b.eq ${next}\n`);
+				}
+				emit_asm(status, `${case_next}:\n`);
+			}
+			emit_asm(status, `b ${next}_reclaim\n`);
+			emit_asm(status, `${next}_reclaim:\n`);
+			emit_enum_payload_frees_at(status, en.name, slot_reg, leaf.offset);
+		}
+		emit_asm(status, `${next}:\n`);
+	}
+}
+/** The aarch64-side payload reference check (mirrors the C reclaim's). */
+function enum_payload_is_reference_a64(p, status) {
+	return status.structs.some((s) => s.name === p.type.name && s.is_class) || status.traits.some((t) => t.name === p.type.name);
+}
+/**
+* Specialized `alloc` for a Buffer whose element type owns heap data:
+* per-element destroy of the OLD slab (guarded on the constructed stamp —
+* grown-but-unwritten and moved-out slots are zeroed), free the slab, then
+* calloc the exact fresh one. The raw body dropped the old pointer — the
+* second Buffer hole in FOLLOWUP.md. x19 = self, x1 = size; returns cap.
+*/
+function emit_owning_alloc_T(elem, status) {
+	const T_SIZE = get_struct_size(elem.name, status);
+	const lbl = (s) => `.Lalloc_${s}_${status.label_counter = (status.label_counter ?? 0) + 1}`;
+	const fresh = lbl("fresh");
+	const drop = lbl("drop");
+	const loop = lbl("loop");
+	const skip = lbl("skip");
+	const done = lbl("done");
+	emit_asm(status, `stp x20, x21, [sp, #-16]!\n`);
+	emit_asm(status, `str x22, [sp, #-16]!\n`);
+	emit_asm(status, `mov x22, x1\n`);
+	emit_asm(status, `ldr x20, [x19, #8]\n`);
+	emit_asm(status, `cbz x20, ${fresh}\n`);
+	emit_asm(status, `ldr x21, [x19, #16]\n`);
+	emit_asm(status, `cbz x21, ${drop}\n`);
+	emit_asm(status, `${loop}:\n`);
+	emit_asm(status, `mov x9, #${T_SIZE}\n`);
+	emit_asm(status, `madd x10, x21, x9, x20\n`);
+	emit_asm(status, `sub x10, x10, x9\n`);
+	emit_asm(status, `ldr x9, [x10]\n`);
+	emit_asm(status, `cbz x9, ${skip}\n`);
+	emit_asm(status, `mov x0, x10\n`);
+	emit_asm(status, `bl ${elem.name}_destroy\n`);
+	emit_asm(status, `${skip}:\n`);
+	emit_asm(status, `sub x21, x21, #1\n`);
+	emit_asm(status, `cbnz x21, ${loop}\n`);
+	emit_asm(status, `${drop}:\n`);
+	emit_asm(status, `mov x0, x20\n`);
+	emit_free(status);
+	emit_asm(status, `${fresh}:\n`);
+	emit_asm(status, `mov x0, x22\n`);
+	emit_asm(status, `mov x1, #${T_SIZE}\n`);
+	emit_asm(status, status.audit ? `bl _nomen_calloc_wrap\n` : `bl _calloc\n`);
+	emit_asm(status, `str x0, [x19, #8]\n`);
+	emit_asm(status, `str x22, [x19, #16]\n`);
+	emit_asm(status, `ldr x0, [x19, #16]\n`);
+	emit_asm(status, `${done}:\n`);
+	emit_asm(status, `ldr x22, [sp], #16\n`);
+	emit_asm(status, `ldp x20, x21, [sp], #16\n`);
+}
+/**
 * Emit a specialized #destroy for a Buffer whose element type is a mv
 * value struct. Per-element T_destroy, then free the slab. Called from
 * build_struct_node instead of build_destroy_function when the element owns.
@@ -23362,7 +24487,7 @@ function build_function_node$1(node, status) {
 	const old_code = status.code;
 	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 return_struct = !node.return_type.is_view && !node.return_type.is_array && !node.return_type.is_pointer && (!!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, status) && !node.return_type.is_ref;
 	const uses_sret = return_struct || nullable_scalar_ret;
 	const old_struct_return_buffer = status.struct_return_buffer;
@@ -24514,18 +25639,40 @@ function build_init_function(node, status) {
 		}
 		if (field.type.is_array && field.type.length && (field.type.length.start ?? -1) >= 0) {
 			const elem_is_fat_string = field.type.name === "string";
-			const element_size = elem_is_fat_string ? 16 : aarch64_size(field.type.name);
+			const elem_struct = elem_is_fat_string ? void 0 : status.structs.find((s) => s.name === field.type.name && !s.is_simple_type && !s.is_class && !s.is_generic);
+			const element_size = elem_is_fat_string ? 16 : elem_struct ? get_struct_size(field.type.name, status) : aarch64_size(field.type.name);
 			const length = parseInt(field.type.length.value || "0");
-			for (let e = 0; e < length; e++) {
-				const byte_offset = e * element_size;
-				if (elem_is_fat_string) {
-					emit_asm(status, `ldp x9, x10, [${src_reg}, #${byte_offset}]\n`);
-					emit_asm(status, `stp x9, x10, [x19, #${offset + byte_offset}]\n`);
-				} else {
-					emit_asm(status, load_element(src_reg, byte_offset, element_size));
-					emit_asm(status, store_element("x19", offset + byte_offset, element_size));
+			const detach_fields = elem_struct && owns_strings_uniformly(elem_struct) ? layout_fields(elem_struct, status).filter((f) => !f.type.is_ref && !f.type.is_view && !f.type.is_array && f.type.name === "string") : [];
+			const elem_field_offsets = detach_fields.map((f) => get_field_offset_of_fields(layout_fields(elem_struct, status), f.name, status));
+			const copy_elements = () => {
+				for (let e = 0; e < length; e++) {
+					const byte_offset = e * element_size;
+					if (elem_is_fat_string) {
+						emit_asm(status, `ldp x9, x10, [${src_reg}, #${byte_offset}]\n`);
+						emit_asm(status, `stp x9, x10, [x19, #${offset + byte_offset}]\n`);
+					} else if (elem_struct) {
+						const words = Math.ceil(element_size / 8);
+						for (let w = 0; w < words; w++) {
+							emit_asm(status, `ldr x9, [${src_reg}, #${byte_offset + w * 8}]\n`);
+							emit_asm(status, `str x9, [x19, #${offset + byte_offset + w * 8}]\n`);
+						}
+						for (const sfo of elem_field_offsets) {
+							const slot_off = offset + byte_offset + sfo;
+							emit_asm(status, `ldr x0, [x19, #${slot_off}]\n`);
+							const skip = `.arr_elem_strdup_skip_${status.label_counter = (status.label_counter ?? 0) + 1}`;
+							emit_asm(status, `cbz x0, ${skip}\n`);
+							emit_strdup(status);
+							emit_asm(status, `str x0, [x19, #${slot_off}]\n`);
+							emit_asm(status, `${skip}:\n`);
+						}
+					} else {
+						emit_asm(status, load_element(src_reg, byte_offset, element_size));
+						emit_asm(status, store_element("x19", offset + byte_offset, element_size));
+					}
 				}
-			}
+			};
+			if (detach_fields.length > 0) with_live_arg_regs_spilled(status, param_regs.slice(slot - 1), copy_elements);
+			else copy_elements();
 		} else if (!field.type.is_ref && status.enums.find((e) => e.name === field.type.name && e.has_associated_data)) {
 			const enum_name = field.type.name;
 			const enum_size = get_enum_size(enum_name, status);
@@ -24580,7 +25727,13 @@ function build_init_function(node, status) {
 				}
 				emit_asm(status, `mov x1, #0\n`);
 			} else if (/^(\+|-)*\d+$/.test(val)) emit_asm(status, `ldr x1, =${val}\n`);
-			else if (val.startsWith("\"")) {
+			else if (/^(\+|-)*\d+\.\d+$/.test(val)) {
+				const label = `_fdefault_${func_name}_${field.name}`;
+				const data = `${label}: .double ${val}\n.p2align 3\n`;
+				status.function_data = (status.function_data ?? "") + data;
+				emit_asm(status, `adr x1, ${label}\n`);
+				emit_asm(status, `ldr x1, [x1]\n`);
+			} else if (val.startsWith("\"")) {
 				const label = `_str_${func_name}_${field.name}`;
 				status.strings.set(label, val);
 				emit_asm(status, `adr x1, ${label}\n`);
@@ -24678,6 +25831,10 @@ function build_init_function(node, status) {
 	emit_asm(status, `ldr x19, [sp], #16\n`);
 	emit_asm(status, `ldp x29, x30, [sp], #16\n`);
 	emit_asm(status, `ret\n`);
+	if (status.function_data) {
+		emit_asm(status, status.function_data);
+		status.function_data = void 0;
+	}
 	status.stack_size = old_stack_size;
 	status.stack_offsets = old_stack_offsets;
 }
@@ -24708,6 +25865,8 @@ function build_custom_init_function(node, func, status) {
 	status.register_allocations = void 0;
 	status.nir_site_allocs = void 0;
 	status.callee_saved_regs_used = void 0;
+	const old_struct_param_slots = status.function_struct_param_slots;
+	status.function_struct_param_slots = /* @__PURE__ */ new Set();
 	status.scoped_declarations = [];
 	status.heap_strings = /* @__PURE__ */ new Set();
 	status.stack_size = 0;
@@ -24826,6 +25985,9 @@ function build_custom_init_function(node, func, status) {
 		const size = aarch64_size(param.type.name);
 		const offset = allocate_stack_space(status, size, size);
 		status.stack_offsets.set(param.name, offset);
+		if (!param.type.is_ref && !param.type.is_array && !param.is_variadic) {
+			if (!!status.structs.find((s) => s.name === param.type.name && !s.is_simple_type) || !!status.traits.find((t) => t.name === param.type.name) || !!status.enums.find((e) => e.name === param.type.name && e.has_associated_data)) status.function_struct_param_slots.add(param.name);
+		}
 		if (param_idx < 8) {
 			const reg = param_regs[param_idx];
 			if (size === 1) emit_asm(status, `strb ${reg.replace("x", "w")}, [x29, #${offset}]\n`);
@@ -24886,7 +26048,13 @@ function build_custom_init_function(node, func, status) {
 				}
 				emit_asm(status, `mov x1, #0\n`);
 			} else if (/^(\+|-)*\d+$/.test(val)) emit_asm(status, `ldr x1, =${val}\n`);
-			else if (val.startsWith("\"")) {
+			else if (/^(\+|-)*\d+\.\d+$/.test(val)) {
+				const label = `_fdefault_${func_name}_${field.name}`;
+				const data = `${label}: .double ${val}\n.p2align 3\n`;
+				status.function_data = (status.function_data ?? "") + data;
+				emit_asm(status, `adr x1, ${label}\n`);
+				emit_asm(status, `ldr x1, [x1]\n`);
+			} else if (val.startsWith("\"")) {
 				const label = `_str_${func_name}_${field.name}`;
 				status.strings.set(label, val);
 				emit_asm(status, `adr x1, ${label}\n`);
@@ -24979,6 +26147,7 @@ function build_custom_init_function(node, func, status) {
 		status.init_assigned_fields = old_init_assigned_fields;
 		status.init_default_reclaimed_fields = old_init_default_reclaimed;
 		status.heap_string_fields = old_init_heap_string_fields;
+		status.function_struct_param_slots = old_struct_param_slots;
 	}
 	const init_claims = status.callee_saved_regs_used;
 	const init_loop_regs = init_claims ? [...init_claims].sort() : [];
@@ -25004,6 +26173,10 @@ function build_custom_init_function(node, func, status) {
 	emit_asm(status, `ldr x19, [sp], #16\n`);
 	emit_asm(status, `ldp x29, x30, [sp], #16\n`);
 	emit_asm(status, `ret\n`);
+	if (status.function_data) {
+		emit_asm(status, status.function_data);
+		status.function_data = void 0;
+	}
 	status.scoped_declarations = old_scoped_declarations;
 	status.heap_strings = old_heap_strings;
 	status.trait_class_frames = old_trait_class_frames;
@@ -25036,6 +26209,8 @@ function build_struct_functions$1(node, status) {
 		}
 		const old_scoped_declarations = status.scoped_declarations;
 		const old_heap_strings = status.heap_strings;
+		const old_variable_types = status.variable_types;
+		status.variable_types = /* @__PURE__ */ new Map();
 		const old_trait_class_frames = status.trait_class_frames;
 		status.trait_class_frames = void 0;
 		const old_moved = status.moved;
@@ -25122,7 +26297,7 @@ function build_struct_functions$1(node, status) {
 		status.function_view_params = /* @__PURE__ */ new Set();
 		status.function_param_types = /* @__PURE__ */ new Map();
 		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 return_struct = !func.return_type?.is_array && !func.return_type?.is_pointer && (!!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, status) && !func.return_type.is_ref;
 		const uses_sret = return_struct || nullable_scalar_ret;
 		let return_buffer_stack_offset;
@@ -25454,6 +26629,7 @@ function build_struct_functions$1(node, status) {
 		emit_asm(status, `ret\n`);
 		status.scoped_declarations = old_scoped_declarations;
 		status.heap_strings = old_heap_strings;
+		status.variable_types = old_variable_types;
 		status.trait_class_frames = old_trait_class_frames;
 		status.moved = old_moved;
 		status.mv_owns_flag = old_mv_owns_flag;
@@ -25505,6 +26681,8 @@ function build_trait_functions(node, status) {
 			status.emitted_trait_funcs.add(trait_func_label);
 			const old_scoped_declarations = status.scoped_declarations;
 			const old_heap_strings = status.heap_strings;
+			const old_variable_types = status.variable_types;
+			status.variable_types = /* @__PURE__ */ new Map();
 			const old_heap_string_arrays = status.heap_string_arrays;
 			status.heap_string_arrays = void 0;
 			const old_heap_class_arrays = status.heap_class_arrays;
@@ -25694,6 +26872,7 @@ function build_trait_functions(node, status) {
 			emit_asm(status, `ret\n`);
 			status.scoped_declarations = old_scoped_declarations;
 			status.heap_strings = old_heap_strings;
+			status.variable_types = old_variable_types;
 			status.heap_string_arrays = old_heap_string_arrays;
 			status.heap_class_arrays = old_heap_class_arrays;
 			status.heap_array_vars = old_heap_array_vars;
@@ -27616,6 +28795,23 @@ function scaled_load_instr(name, size) {
 }
 //#endregion
 //#region ../src/build_aarch64/naked_inline.ts
+/**
+* Storage width of a built-in scalar type name: 1/2/4 for the sub-word ints,
+* bool, and char; 8 for everything else (words, floats-as-bits, references).
+* `null` for anything that is not a built-in scalar (structs, enums, strings,
+* views) — callers keep their existing behavior for those.
+*/
+function scalar_byte_width(type_name) {
+	const info = get_built_in_type(type_name);
+	if (!info || info.bytes === void 0) return 8;
+	if (info.bytes === 1 || info.bytes === 2 || info.bytes === 4) return info.bytes;
+	return 8;
+}
+/** The W-register alias of an X register ("x19" → "w19") — sub-word loads
+*  zero-extend into the full register, so the caller sees a clean scalar. */
+function w_alias(reg) {
+	return reg.startsWith("x") ? `w${reg.slice(1)}` : reg;
+}
 const NAKED_MAX_STATEMENTS = 4;
 const NAKED_SCRATCH = ["x9", "x10"];
 /** Byte size of a pointer element — must be a power of two ≤ 8 to be naked. */
@@ -27759,7 +28955,11 @@ function emit_naked_expr(node, dst, ctx) {
 			if (next === null) return false;
 			struct_name = next;
 		}
-		ctx.push(`ldr ${dst}, [x19, #${offset}]`);
+		const width = scalar_byte_width(struct_name);
+		if (width === 1) ctx.push(`ldrb ${w_alias(dst)}, [x19, #${offset}]`);
+		else if (width === 2) ctx.push(`ldrh ${w_alias(dst)}, [x19, #${offset}]`);
+		else if (width === 4) ctx.push(`ldr ${w_alias(dst)}, [x19, #${offset}]`);
+		else ctx.push(`ldr ${dst}, [x19, #${offset}]`);
 		return true;
 	}
 	if (nt === "index") {
@@ -29256,10 +30456,10 @@ function find_var_size$2(name, status) {
 */
 function current_return_is_string(status) {
 	const rt = status.function_return_type;
-	if (rt) return rt.name === "string" && !rt.is_view;
+	if (rt) return rt.name === "string" && !rt.is_view && !rt.is_pointer;
 	if (status.current_struct && status.current_function_name) {
 		const frt = status.current_struct.functions.find((f) => f.name === status.current_function_name)?.return_type;
-		return !!frt && frt.name === "string" && !frt.is_view;
+		return !!frt && frt.name === "string" && !frt.is_view && !frt.is_pointer;
 	}
 	return false;
 }
@@ -29329,6 +30529,7 @@ function build_return_node$1(node, status, nir_value) {
 				continue;
 			}
 			if (is_field_struct_borrow(decl)) continue;
+			if (is_pure_borrow_element_load(decl, status)) continue;
 			emit_destroy_for_decl(status, decl.name, decl.type.name, void 0, decl.type.type_args, decl.type.is_nullable);
 		}
 		emit_heap_slots_cleanup_for_return(status);
@@ -29349,6 +30550,7 @@ function build_return_node$1(node, status, nir_value) {
 					continue;
 				}
 				if (is_field_struct_borrow(decl)) continue;
+				if (is_pure_borrow_element_load(decl, status)) continue;
 				emit_destroy_for_decl(status, decl.name, decl.type.name, void 0, decl.type.type_args, decl.type.is_nullable);
 			}
 			emit_heap_slots_cleanup_for_return(status);
@@ -29456,6 +30658,7 @@ function build_return_node$1(node, status, nir_value) {
 					continue;
 				}
 				if (is_field_struct_borrow(decl)) continue;
+				if (is_pure_borrow_element_load(decl, status)) continue;
 				emit_destroy_for_decl(status, decl.name, decl.type.name, void 0, decl.type.type_args, decl.type.is_nullable);
 			}
 			emit_heap_slots_cleanup_for_return(status);
@@ -32290,6 +33493,7 @@ function build_cast_node$1(node, status) {
 	const is_from_float = is_float_type$1(from);
 	const is_to_float = is_float_type$1(to);
 	if (is_from_float && !is_to_float) {
+		emit_asm(status, `fmov d0, x0\n`);
 		emit_asm(status, `fcvtzs x0, d0\n`);
 		emit_asm(status, `fmov d0, x0\n`);
 		return;
@@ -32800,7 +34004,8 @@ const OWNING_BUFFER_METHODS = /* @__PURE__ */ new Set([
 	"modify",
 	"shift",
 	"destroy",
-	"#destroy"
+	"#destroy",
+	"alloc"
 ]);
 /**
 * Emit the transfer half of mv store_T/replace_T: the slot bytes were
@@ -32829,18 +34034,16 @@ function emit_transfer_owning_fields(elem, src, status, prefix = "") {
 	}
 }
 /**
-* Emit the deep-copy half of mv 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. B1
-* cutover: an OWNING struct's plain string fields are freed unconditionally
-* too (the same unconditional teardown), so they are strdup'd here as well —
-* the loaded copy owns independent bytes and the slot keeps its own. Fields
-* without a copyable shape (class fields, nested mv user structs without
-* a synthesized copy) stay shallow — recorded in FOLLOWUP.md.
+* Emit the deep-copy half of mv load_T: for each field that
+* `field_load_deep_copy` accepts (a `List<T>`/`Buffer<T>`/`Map`/`Set` field
+* whose `<Mono>_copy` deep-copies the slots or member buffers, a nested mv
+* user struct whose auto-derived `copy` is deep, or a `Box<T>` wrapper that
+* is cloned), overwrite the shallow-copied bytes with an owned copy; enum-
+* with-data fields whose payloads are all deep-copyable ride `<E>_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 mv structs that need
+* destroy but have no `copy`) stay shallow — recorded in FOLLOWUP.md.
 */
 function emit_load_deep_copy_fields(elem, dst, status) {
 	for (const field of elem.fields) {
@@ -32854,7 +34057,7 @@ function emit_load_deep_copy_fields(elem, dst, status) {
 			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")) {
+		if (field_struct && field_load_deep_copy(field_struct, status)) {
 			status.code += `${dst}.${field.name} = ${field_struct.name}_copy(&${dst}.${field.name});\n`;
 			continue;
 		}
@@ -32884,7 +34087,7 @@ function emit_load_owned_copies_destroy(status, elem, var_expr) {
 			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")) {
+		if (field_struct && field_load_deep_copy(field_struct, status)) {
 			status.code += `${field_struct.name}_destroy(&${var_expr}.${field.name});\n`;
 			continue;
 		}
@@ -32982,6 +34185,17 @@ function emit_owning_buffer_enum_body(func_name, elem, status) {
 		}
 		return true;
 	}
+	if (func_name === "alloc") {
+		status.code += `if (self->data) {\n`;
+		status.code += `${E}* _old_slots = ${slots};\n`;
+		status.code += `for (int _i = 0; _i < self->cap; _i++) { ${E}_free_payloads(&_old_slots[_i]); }\n`;
+		status.code += `free(_old_slots);\n`;
+		status.code += `}\n`;
+		status.code += `self->cap = size;\n`;
+		status.code += `self->data = (unsigned long long)calloc(size, sizeof(${E}));\n`;
+		status.code += `return self->cap;\n`;
+		return true;
+	}
 	if (func_name === "destroy") {
 		status.code += `if (self->data) {\n`;
 		status.code += `${E}* _slots = ${slots};\n`;
@@ -33032,6 +34246,17 @@ function emit_owning_buffer_string_body(func_name, status) {
 		status.code += `}\n`;
 		return true;
 	}
+	if (func_name === "alloc") {
+		status.code += `if (self->data) {\n`;
+		status.code += `nomen_string* _old_slots = (nomen_string*)self->data;\n`;
+		status.code += `for (int _i = 0; _i < self->cap; _i++) { free(_old_slots[_i].ptr); }\n`;
+		status.code += `free(_old_slots);\n`;
+		status.code += `}\n`;
+		status.code += `self->cap = size;\n`;
+		status.code += `self->data = (unsigned long long)calloc(size, sizeof(nomen_string));\n`;
+		status.code += `return self->cap;\n`;
+		return true;
+	}
 	if (func_name === "destroy") {
 		status.code += `if (self->data) {\n`;
 		status.code += `nomen_string* _slots = (nomen_string*)self->data;\n`;
@@ -33060,6 +34285,7 @@ function emit_owning_buffer_body(func_name, elem, status) {
 	if (func_name === "store") {
 		status.code += `${Tptr}_slots = ${Tcast}(unsigned long long)self->data;\n`;
 		status.code += `struct ${elem.name} _old = _slots[i];\n`;
+		emit_reclaim_displaced_owned(elem, "_slots[i]", "val", status);
 		status.code += `_slots[i] = (*val);\n`;
 		emit_deep_copy_fields(elem, "_slots[i]", "val", status, "_old");
 		emit_transfer_owning_fields(elem, "val", status);
@@ -33072,6 +34298,17 @@ function emit_owning_buffer_body(func_name, elem, status) {
 		status.code += `return _loaded;\n`;
 		return true;
 	}
+	if (func_name === "alloc") {
+		status.code += `if (self->data) {\n`;
+		status.code += `${Tptr}_old_slots = ${Tcast}(unsigned long long)self->data;\n`;
+		status.code += `for (int _i = 0; _i < self->cap; _i++) { if (_old_slots[_i]._vt) { ${elem.name}_destroy(&_old_slots[_i]); } }\n`;
+		status.code += `free(_old_slots);\n`;
+		status.code += `}\n`;
+		status.code += `self->cap = size;\n`;
+		status.code += `self->data = (unsigned long long)calloc(size, sizeof(struct ${elem.name}));\n`;
+		status.code += `return self->cap;\n`;
+		return true;
+	}
 	if (func_name === "modify") {
 		status.code += `${Tptr}_slots = ${Tcast}(unsigned long long)self->data;\n`;
 		status.code += `struct ${elem.name} _old = _slots[i];\n`;
@@ -33114,6 +34351,130 @@ function emit_owning_buffer_body(func_name, elem, status) {
 	return false;
 }
 /**
+* The container monos whose `<T>_destroy` reclaims the whole container
+* (slab + per-element owned state): the core value-slot containers. A user
+* mv struct must NOT take this path (its destroy would free its string
+* fields too — the string machinery owns those) — such fields recurse.
+*/
+const CONTAINER_MONO_PREFIXES = [
+	"Buffer_",
+	"List_",
+	"Map_",
+	"Set_",
+	"Array_"
+];
+let c_disp_closure_counter = 0;
+function is_container_mono_name(name) {
+	return CONTAINER_MONO_PREFIXES.some((p) => name.startsWith(p));
+}
+/**
+* Member paths (relative to the container struct start) of every owned slab
+* pointer inside a container mono: the `data` words of the Buffer-shaped
+* structs reachable through nested struct fields (`Buffer` → `.data`,
+* `List` → `.items.data`, `Map` → `.keys.data` / `.values.data` / …). The
+* store_T displaced-reclaim guard compares ALL of them: the incoming value
+* aliases the displaced container only when every slab pointer is shared
+* (a byte-copy round-trip); any differing pointer means the displaced
+* container's slabs are exclusively owned and can be reclaimed.
+*/
+function container_data_paths(struct, status, prefix = "") {
+	const paths = [];
+	for (const field of struct.fields) {
+		if (field.type.is_ref || field.type.is_view || field.type.is_array) continue;
+		if (field.type.name === "string" && !field.type.is_array) continue;
+		if (field.name === "data") {
+			paths.push(`${prefix}.${field.name}`);
+			continue;
+		}
+		const fs = resolve_struct_type(field.type, status);
+		if (fs && !fs.is_class && is_container_mono_name(fs.name)) paths.push(...container_data_paths(fs, status, `${prefix}.${field.name}`));
+	}
+	return paths;
+}
+/**
+* Reclaim the DISPLACED slot value's owned pointer state on a store onto an
+* occupied slot — the residual Buffer hole (FOLLOWUP.md): store_T's
+* fresh-slot contract leaked every owned field of the previous occupant
+* except the plain string fields the B1 displaced-old reclaim already
+* handles. Runs BEFORE the slot overwrite (the guard reads both the slot's
+* and the incoming value's identity pointers live), per owned leaf:
+*
+*  - container fields: `<T>_destroy` in place when NO slab pointer aliases
+*    the incoming value's (a byte-copy round-trip keeps the slot's own);
+*  - Box / class fields: destroy + free the displaced wrapper when the
+*    incoming pointer differs;
+*  - func fields: the free-if-owned arm when the descriptor differs;
+*  - enum-with-data fields: `<E>_free_payloads` when the tag differs, or
+*    the same case's payload pointers all differ;
+*  - nested mv struct fields: recurse (their strings stay out — the string
+*    machinery owns them).
+*/
+function emit_reclaim_displaced_owned(elem, slot_path, val_path, status) {
+	for (const field of elem.fields) {
+		if (field.type.is_ref || field.type.is_view || field.type.is_array) continue;
+		if (field.type.name === "string" && !field.type.is_array) continue;
+		const slot_f = `${slot_path}.${field.name}`;
+		const val_f = `${val_path}${arrow(val_path)}${field.name}`;
+		const box_mono = box_field_mono(field.type, status);
+		if (box_mono) {
+			status.code += `if (${slot_f} && ${slot_f} != ${val_f}) { ${box_mono.name}_destroy(${slot_f}); free(${slot_f}); }\n`;
+			continue;
+		}
+		const fs = resolve_struct_type(field.type, status);
+		if (fs?.is_class) {
+			status.code += `if (${slot_f} && ${slot_f} != ${val_f}) { ${fs.name}_destroy(${slot_f}); free(${slot_f}); }\n`;
+			continue;
+		}
+		if (field.type.name === "func") {
+			const c = `_disp_closure_${c_disp_closure_counter++}`;
+			status.code += `if (${slot_f} && ${slot_f} != ${val_f}) {\n`;
+			status.code += `struct nomen_closure *${c} = (struct nomen_closure *)${slot_f};\n`;
+			status.code += `if (${c}->owned) { if (${c}->destroy_env) ${c}->destroy_env(${c}->env); free(${c}->env); free(${c}); }\n`;
+			status.code += `}\n`;
+			continue;
+		}
+		const field_enum = status.enums.find((e) => e.name === field.type.name && e.has_associated_data);
+		if (field_enum) {
+			emit_displaced_enum_reclaim(field_enum, slot_f, val_f, status);
+			continue;
+		}
+		if (fs && !fs.is_class) {
+			if (is_container_mono_name(fs.name)) {
+				const data_paths = container_data_paths(fs, status);
+				if (!data_paths.length) continue;
+				const guard = [`${slot_f}${data_paths[0]}`, ...data_paths.map((p) => `${slot_f}${p} != ${val_f}${p}`)].join(" && ");
+				status.code += `if (${guard}) { ${fs.name}_destroy(&${slot_f}); }\n`;
+			} else if (struct_needs_destroy(fs, status) || has_string_fields(fs, status)) emit_reclaim_displaced_owned(fs, slot_f, val_f, status);
+		}
+	}
+}
+/**
+* The enum-with-data arm of the displaced reclaim: the payload compare must
+* be tag-scoped (payloads of different cases never alias — distinct
+* allocations), so per owning case: a differing tag reclaims outright; the
+* same tag reclaims only when every payload pointer differs (the round-trip
+* identity keeps the slot's payloads).
+*/
+function emit_displaced_enum_reclaim(elem, slot_f, val_f, status) {
+	const owning_cases = elem.cases.filter((c) => c.params.some((p) => p.type.name === "string" || payload_is_reference$3(p.type, status)));
+	if (!owning_cases.length) return;
+	const reclaim = `${elem.name}_free_payloads(&${slot_f});`;
+	const guards = owning_cases.map((c) => {
+		const compares = c.params.filter((p) => p.type.name === "string" || payload_is_reference$3(p.type, status)).map((p) => {
+			const slot_p = `${slot_f}._data._${c.name}.${p.name}`;
+			const val_p = `${val_f}._data._${c.name}.${p.name}`;
+			return p.type.name === "string" ? `${slot_p}.ptr != ${val_p}.ptr` : `${slot_p} != ${val_p}`;
+		});
+		return `else if (${slot_f}.tag == ${elem.name}_${c.name}) { if (${compares.join(" && ")}) { ${reclaim} } }`;
+	});
+	status.code += `if (${slot_f}.tag != ${val_f}.tag) { ${reclaim} }\n`;
+	status.code += `${guards.join(" ")}\n`;
+}
+/** The C-side payload reference check (mirrors the enum reclaim's shape). */
+function payload_is_reference$3(type, status) {
+	return status.structs.some((s) => s.name === type.name && s.is_class) || status.traits.some((t) => t.name === type.name);
+}
+/**
 * 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
@@ -33434,7 +34795,7 @@ function free_scoped_declarations(status, decls, persist_string_field_records =
 				status.code += `(${cast}_get_trait_func((void *)&${cname}, ${traitIndex}, ${funcIndex}))(&${cname});\n`;
 			}
 		}
-		const is_destructured_field_access = dec.value?.node_type === "access" && dec.value.access.node_type === "access_field" && !dec.value.is_moved && dec.force_owned_string !== true || is_borrow_accessor_carrier(dec);
+		const is_destructured_field_access = dec.value?.node_type === "access" && dec.value.access.node_type === "access_field" && !dec.value.is_moved && dec.force_owned_string !== true || is_borrow_accessor_carrier(dec) || is_pure_borrow_element_load(dec, status);
 		const is_borrowed_string = is_string_borrow(dec.value) && !status.c_owned_borrow_inits?.has(dec) || !!status.string_borrow_vars?.has(dec.name);
 		const value_is_heap_string = dec.type.name === "string" && (dec.value?.node_type === "access" && dec.value.access.node_type === "access_func" || dec.value?.node_type === "func_call" || !!dec.value && !dec.type.is_view && is_view_value(dec.value, status));
 		const dec_value = dec.value;
@@ -33604,6 +34965,7 @@ function emit_struct_destroys(status, struct, var_expr) {
 			continue;
 		}
 		if ((struct.is_class === true || struct.is_owning === true) && field.type.name === "func" && !field.type.is_array) {
+			if (status.func_field_borrow_decls?.delete(var_expr)) continue;
 			const f = `((struct nomen_closure *)${var_expr}.${field.name})`;
 			status.code += `if (${f} && ${f}->owned) { if (${f}->destroy_env) ${f}->destroy_env(${f}->env); free(${f}->env); free(${f}); }\n`;
 			continue;
@@ -33611,6 +34973,15 @@ function emit_struct_destroys(status, struct, var_expr) {
 		const field_struct = resolve_struct_type(field.type, status);
 		if (!field_struct) continue;
 		const field_expr = `${var_expr}.${field.name}`;
+		if (field.type.is_array && !field_struct.is_class) {
+			const arr_len = field.type.length ? parseInt(field.type.length.value || "0") : 0;
+			if (arr_len > 0 && (has_destroy(field_struct) || struct_needs_destroy(field_struct, status) || struct_needs_auto_destroy(field_struct, status))) {
+				status.code += `for (long _i = 0; _i < ${arr_len}; _i++) {\n`;
+				emit_struct_destroys(status, field_struct, `${field_expr}[_i]`);
+				status.code += `}\n`;
+			}
+			continue;
+		}
 		if (field_struct.is_class) status.code += `if (${field_expr}) { ${field_struct.name}_destroy(${field_expr}); free(${field_expr}); }\n`;
 		else if (is_nullable_struct_type(field.type, status)) {
 			if (struct_needs_destroy(field_struct, status)) {
@@ -33658,6 +35029,15 @@ function capture_destroys(status, struct, var_expr, accessor) {
 		const field_struct = resolve_struct_type(field.type, status);
 		if (!field_struct) continue;
 		const field_expr = `${var_expr}${accessor}${field.name}`;
+		if (field.type.is_array && !field_struct.is_class) {
+			const arr_len = field.type.length ? parseInt(field.type.length.value || "0") : 0;
+			if (arr_len > 0 && (has_destroy(field_struct) || struct_needs_destroy(field_struct, status) || struct_needs_auto_destroy(field_struct, status))) {
+				status.code += `for (long _i = 0; _i < ${arr_len}; _i++) { `;
+				emit_struct_destroys(status, field_struct, `${field_expr}[_i]`);
+				status.code += `} `;
+			}
+			continue;
+		}
 		if (field_struct.is_class) status.code += `if (${field_expr}) { ${field_struct.name}_destroy(${field_expr}); free(${field_expr}); } `;
 		else if (is_nullable_struct_type(field.type, status)) {
 			if (struct_needs_destroy(field_struct, status)) {
@@ -35027,7 +36407,11 @@ function build_assignment_node$1(node, status, nir_rhs, nir_swap) {
 				} else if (!node.swap && rhs.is_moved) {
 					const src_name = rhs.value;
 					if (string_var_owns_heap(status, src_name)) {
-						splice_decl_from_c_scopes(status, src_name);
+						const src_flag = status.c_mv_owns_flags?.get(src_name);
+						if (src_flag !== void 0) {
+							if (!status.pending_mv_owns_sets) status.pending_mv_owns_sets = [];
+							status.pending_mv_owns_sets.push(`${src_flag} = 1;`);
+						} else splice_decl_from_c_scopes(status, src_name);
 						if (!status.heap_strings) status.heap_strings = /* @__PURE__ */ new Set();
 						status.heap_strings.add(lhs_name);
 					} else {
@@ -35893,11 +37277,13 @@ function build_declaration_node$1(node, status, nir_init, nir_swap) {
 			status.code += `;\n`;
 			return;
 		}
-		if (node.type.is_ref && !node.type.is_array) {
+		const value_struct_ref_alias = node.is_ref_binding === true && !node.type.is_ref && !!status.structs.find((s) => s.name === (mono_name ?? node.type.name) && !s.is_class && !s.is_simple_type && !s.is_generic);
+		if ((node.type.is_ref || value_struct_ref_alias) && !node.type.is_array) {
 			if (mono_struct) status.code += `struct ${mono_name} *${safe_name}`;
 			else status.code += `${c_type(node.type.name)} *${safe_name}`;
 			if (node.value) {
-				status.code += ` = &`;
+				if (!(node.value.node_type === "access" && node.value.access.is_element_slot_load === true)) status.code += ` = &`;
+				else status.code += ` = `;
 				build_node$1(node.value, status);
 			}
 			status.code += `;\n`;
@@ -36215,7 +37601,7 @@ function build_declaration_node$1(node, status, nir_init, nir_swap) {
 				const binding_struct = status.structs.find((s) => s.name === node.type?.name && !s.is_simple_type && !s.is_class);
 				const init_access = node.value?.node_type === "access" ? node.value.access : void 0;
 				const is_borrow_accessor_init = init_access?.node_type === "access_func" && is_container_borrow_accessor_name(init_access.name ?? "");
-				if (binding_struct && owns_strings_uniformly(binding_struct) && is_borrow_accessor_init && !is_borrow_accessor_carrier(node)) {
+				if (binding_struct && owns_strings_uniformly(binding_struct) && is_borrow_accessor_init && !is_borrow_accessor_carrier(node) && !is_pure_borrow_element_load(node, status)) {
 					if (!status.code.endsWith(";\n")) status.code += `;\n`;
 					const emit_strdups = (s, prefix, guard) => {
 						const lines = [];
@@ -36229,6 +37615,7 @@ function build_declaration_node$1(node, status, nir_init, nir_swap) {
 							}
 							const field_struct = resolve_struct_type(field.type, status);
 							if (!field_struct || field_struct.is_class) continue;
+							if (field_load_deep_copy(field_struct, status)) continue;
 							if (!owns_strings_uniformly(field_struct)) continue;
 							const nested_guard = is_nullable_struct_type(field.type, status) ? `${lhs}_has` : void 0;
 							lines.push(...emit_strdups(field_struct, path, nested_guard));
@@ -36242,6 +37629,10 @@ function build_declaration_node$1(node, status, nir_init, nir_swap) {
 					};
 					for (const line of emit_strdups(binding_struct, "")) status.code += line;
 				}
+				if (binding_struct && is_borrow_accessor_init && !is_borrow_accessor_carrier(node)) {
+					if (!status.func_field_borrow_decls) status.func_field_borrow_decls = /* @__PURE__ */ new Set();
+					status.func_field_borrow_decls.add(safe_name);
+				}
 			}
 			const override_ctor_call = node.value?.node_type === "func_call" && node.value.field_overrides?.length && node.type?.name && node.value.name === node.type.name ? node.value : void 0;
 			if (override_ctor_call) {
@@ -36896,10 +38287,10 @@ function build_return_node(node, status, nir_value) {
 		const ret_type = status.function_return_type || node.type;
 		const mono_ret_name = mono_type_name(ret_type);
 		const return_struct = status.structs.find((s) => s.name === mono_ret_name && !s.is_simple_type);
-		const is_struct = !!return_struct;
+		const is_struct = !!return_struct && !ret_type.is_pointer;
 		const return_is_class = !!return_struct?.is_class;
 		const return_trait = status.traits.find((t) => t.name === ret_type.name);
-		const type_prefix = ret_type.is_array ? `struct Array_${ret_type.name}* ` : ret_type.is_view ? "nomen_view " : is_struct ? return_is_class ? `struct ${mono_ret_name}* ` : `struct ${mono_ret_name} ` : return_trait ? `struct ${ret_type.name}* ` : c_type(ret_type.name || "int");
+		const type_prefix = ret_type.is_array ? `struct Array_${ret_type.name}* ` : ret_type.is_pointer ? `${status.traits.find((t) => t.name === ret_type.name) ? `struct ${ret_type.name}` : pointer_element_c_type(ret_type, status)}* ` : ret_type.is_view ? "nomen_view " : is_struct ? return_is_class ? `struct ${mono_ret_name}* ` : `struct ${mono_ret_name} ` : return_trait ? `struct ${ret_type.name}* ` : c_type(ret_type.name || "int");
 		if (node.value.node_type === "match" || node.value.node_type === "switch" || node.value.node_type === "if") {
 			const join_branch_values = collect_expression_branch_values(node.value);
 			const first_branch_type = join_branch_values.length ? type_from_value_node$1(join_branch_values[0])?.name : void 0;
@@ -36937,10 +38328,10 @@ function build_return_node(node, status, nir_value) {
 		}
 		status.code += `${type_prefix} _return_val = `;
 		if (return_trait && !ret_type.is_view) status.code += `(struct ${ret_type.name} *)`;
-		let returns_borrowed_string = ret_type.name === "string" && !ret_type.is_view && node.value.node_type === "access";
-		const returns_string_literal = ret_type.name === "string" && !ret_type.is_view && node.value.node_type === "value" && node.value.value.length >= 2 && node.value.value.startsWith("\"") && node.value.value.endsWith("\"");
+		let returns_borrowed_string = ret_type.name === "string" && !ret_type.is_view && !ret_type.is_pointer && node.value.node_type === "access";
+		const returns_string_literal = ret_type.name === "string" && !ret_type.is_view && !ret_type.is_pointer && node.value.node_type === "value" && node.value.value.length >= 2 && node.value.value.startsWith("\"") && node.value.value.endsWith("\"");
 		let returns_borrow_var = false;
-		if (ret_type.name === "string" && !ret_type.is_view && node.value.node_type === "value" && !returns_string_literal) {
+		if (ret_type.name === "string" && !ret_type.is_view && !ret_type.is_pointer && node.value.node_type === "value" && !returns_string_literal) {
 			const var_name = node.value.value;
 			if (!returned_value_decl) returns_borrow_var = true;
 			else if (is_string_borrow(returned_value_decl.value) || !!status.string_borrow_vars?.has(var_name)) returns_borrow_var = true;
@@ -37618,6 +39009,8 @@ function build_struct_node(node, status) {
 			status.init_default_reclaimed_fields = /* @__PURE__ */ new Set();
 			const old_init_heap_string_fields = status.heap_string_fields;
 			status.heap_string_fields = void 0;
+			const old_init_variable_types = status.variable_types;
+			status.variable_types = /* @__PURE__ */ new Map();
 			for (const field of node.fields) if (field.value) {
 				status.init_assigned_fields?.add(`self.${field.name}`);
 				if (field.type.is_view && !field.type.is_array && !is_nullable_struct_type(field.type, status)) {
@@ -37707,6 +39100,7 @@ function build_struct_node(node, status) {
 			status.init_assigned_fields = old_init_assigned_fields;
 			status.init_default_reclaimed_fields = old_init_default_reclaimed;
 			status.heap_string_fields = old_init_heap_string_fields;
+			status.variable_types = old_init_variable_types;
 			status.function_return_type = old_return_type;
 		}
 		build_struct_functions(node, status, true);
@@ -37724,8 +39118,21 @@ function build_struct_node(node, status) {
 				build_node$1(field.value, 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, status)) && field.value) {
+		} 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`;
+			const elem_struct = status.structs.find((s) => s.name === field.type.name && !s.is_simple_type && !s.is_class && !s.is_generic);
+			if (elem_struct && owns_strings_uniformly(elem_struct)) {
+				const arr_len = parseInt(field.type.length.value || "0");
+				for (const sf of class_destroy_fields(elem_struct, status)) {
+					if (sf.type.is_ref || sf.type.is_view || sf.type.is_array) continue;
+					if (sf.type.name !== "string") continue;
+					for (let e = 0; e < arr_len; e++) {
+						const slot = `${object_name}${accessor}${field.name}[${e}].${sf.name}`;
+						status.code += `${slot}.ptr = ${slot}.ptr ? nomen_str_dup(${slot}).ptr : ${slot}.ptr;\n`;
+					}
+				}
+			}
+		} 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} = `;
@@ -37869,6 +39276,8 @@ function build_struct_functions(node, status, skip_init = false) {
 		const old_ref_class_params = status.ref_class_params;
 		const old_ref_class_param_types = status.ref_class_param_types;
 		const old_scoped_declarations = status.scoped_declarations;
+		const old_variable_types = status.variable_types;
+		status.variable_types = /* @__PURE__ */ new Map();
 		const old_borrow_only = status.c_borrow_only_strings;
 		const old_force_heap = status.force_heap_strings;
 		const old_heap_array_vars = status.heap_array_vars;
@@ -37931,7 +39340,10 @@ function build_struct_functions(node, status, skip_init = false) {
 		const returns_array_data = (func.return_type.type_args?.length ?? 0) > 0 && return_type === "Array";
 		const emit_label = is_overloaded(node, func.name) ? mangled_label(func, node.name) : `${node.name}_${func.name.replace(/#/g, "")}`;
 		if (func.return_type.is_array) status.code += `void* ${emit_label}(`;
-		else if (returns_array_data) {
+		else if (func.return_type.is_pointer) {
+			const elem_c = status.traits.find((t) => t.name === func.return_type.name) ? `struct ${func.return_type.name}` : pointer_element_c_type(func.return_type, status);
+			status.code += `${elem_c}* ${emit_label}(`;
+		} else if (returns_array_data) {
 			const elem_type = c_type(func.return_type.type_args[0].name);
 			status.code += `${elem_type}* ${emit_label}(`;
 		} else if (return_type.startsWith("Array_")) status.code += `void* ${emit_label}(`;
@@ -37996,6 +39408,7 @@ function build_struct_functions(node, status, skip_init = false) {
 		status.current_function_name = old_function_name;
 		status.current_function = old_current_function;
 		status.function_view_params = old_view_params;
+		status.variable_types = old_variable_types;
 	}
 	status.current_struct = old_current_struct;
 	for (let traitName of node.traits) {
@@ -38066,6 +39479,11 @@ function build_auto_destroy(node, status) {
 		const field_struct = status.structs.find((s) => s.name === mono_name && !s.is_simple_type);
 		if (process.env.NOMEN_DEBUG_DESTROY) console.error("AUTODESTROY-LOOKUP:", node.name, field.name, mono_name, "found:", !!field_struct, "nstructs:", status.structs.length);
 		if (!field_struct) continue;
+		if (field.type.is_array && !field_struct.is_class) {
+			const arr_len = field.type.length ? parseInt(field.type.length.value || "0") : 0;
+			if (arr_len > 0 && (field_struct.functions.find((f) => f.name === "#destroy") || struct_needs_auto_destroy(field_struct, status))) status.code += `for (long _i = 0; _i < ${arr_len}; _i++) { ${field_struct.name}_destroy(&self->${field.name}[_i]); }\n`;
+			continue;
+		}
 		if (field_struct.is_class) {
 			const field_has_destroy = !!field_struct.functions.find((f) => f.name === "#destroy");
 			const field_is_owned = field.declaration === "mv" || node.is_owning === true;
@@ -39013,7 +40431,7 @@ function emit_boxed_value_struct_c(status, arg, box_struct) {
 	}
 	const unrecorded = string_fields.filter((f) => !recorded.has(f.name));
 	if (arg.node_type === "func_call" && arg.name === box_struct.name) {
-		status.code += `(void *)({ struct ${box_struct.name} *_box = (struct ${box_struct.name} *)nomen_malloc_wrap(sizeof(struct ${box_struct.name})); *_box = `;
+		status.code += `(void *)({ struct ${box_struct.name} *_box = (struct ${box_struct.name} *)malloc(sizeof(struct ${box_struct.name})); *_box = `;
 		build_node$1(arg, status);
 		status.code += `; `;
 		for (const f of unrecorded) status.code += `_box->${f.name} = nomen_str_dup(_box->${f.name}); `;
@@ -39028,7 +40446,7 @@ function emit_boxed_value_struct_c(status, arg, box_struct) {
 	const addr_text = end_code_scratch(status, saved_arg);
 	status.code += `(void *)({ struct ${box_struct.name} *_src = (struct ${box_struct.name} *)${addr_text}; `;
 	for (const f of unrecorded) status.code += `_src->${f.name} = nomen_str_dup(_src->${f.name}); `;
-	status.code += `struct ${box_struct.name} *_box = (struct ${box_struct.name} *)nomen_malloc_wrap(sizeof(struct ${box_struct.name})); `;
+	status.code += `struct ${box_struct.name} *_box = (struct ${box_struct.name} *)malloc(sizeof(struct ${box_struct.name})); `;
 	status.code += `*_box = *_src; `;
 	status.code += `(void *)_box; })`;
 }
@@ -39837,6 +41255,7 @@ function build_access_node$1(node, status) {
 		}
 		case "access_func": {
 			const access_func = node.access;
+			if (access_func.is_handler_registration) return;
 			if (access_func.is_nursery_spawn) {
 				build_nursery_spawn$1(access_func, nursery_pointer_expr(node.target, status), status);
 				return;
@@ -40599,7 +42018,7 @@ void **_get_trait_func(void **obj, int trait_index, int func_index)
 		let range = Array.from({ length }, (_, i) => i);
 		let declaration = `nomen_string _string_interpolate_${length}(nomen_string pattern, ${range.map((n) => `nomen_string arg${n + 1}`).join(", ")})`;
 		status.headers += `${declaration};\n`;
-		if (status.emit_mode !== "user") status.code += `${declaration}
+		if (status.emit_mode !== "user" || length > 7) status.code += `${declaration}
 {
     int length = snprintf(NULL, 0, pattern.ptr, ${range.map((n) => `arg${n + 1}.ptr`).join(", ")});
     char *str = malloc(length + 1);
@@ -42374,6 +43793,17 @@ function emit_struct_constructor_to_slot(fc, slot_addr, status) {
 function build_constructor_params(fc, param_regs, status) {
 	mark_tuple_literal_move_owners(fc, status, (name) => mark_local_moved_flag(status, name));
 	const variadic_idx = fc.variadic_param_index;
+	if (variadic_idx === void 0 && fc.params.length === 0) {
+		const resolved = fc.resolved_function ?? status.structs.find((s) => s.name === fc.name)?.functions.find((f) => f.name === "#init");
+		const variadic_param = resolved?.params?.find((p) => p.is_variadic);
+		if (resolved && variadic_param && resolved.params.filter((p) => !p.is_self_param && !p.is_variadic).length === 0) {
+			const elem_type_name = variadic_param.type.tuple_types?.length ? variadic_param.type.tuple_types[0].name : variadic_param.type.name || "int";
+			const arr_offset = allocate_stack_space(status, 8 + (status.structs.find((s) => s.name === elem_type_name && !s.is_simple_type) ? get_struct_size(elem_type_name, status) : elem_type_name === "string" ? 16 : 8), 16);
+			emit_asm(status, `str xzr, [x29, #${arr_offset}]\n`);
+			emit_asm(status, `mov x1, #0\n`);
+			emit_asm(status, `add x2, x29, #${arr_offset + 8}\n`);
+		}
+	}
 	if (variadic_idx !== void 0 && fc.params[variadic_idx] && fc.params[variadic_idx].node_type === "array") {
 		const arr = fc.params[variadic_idx];
 		const elem_type_name = arr.type.name || "int";
@@ -42906,6 +44336,26 @@ function build_declaration_node(node, status, nir_init, nir_swap) {
 		}
 		return;
 	}
+	const value_struct_ref_alias = node.is_ref_binding === true && !node.type.is_ref && !!status.structs.find((s) => s.name === node.type.name && !s.is_class && !s.is_simple_type && !s.is_generic);
+	if (node.type.is_ref || value_struct_ref_alias) {
+		const offset = allocate_stack_space(status, 8);
+		status.stack_offsets.set(node.name, offset);
+		if (node.value) {
+			const init_is_slot_load = node.value.node_type === "access" && node.value.access.is_element_slot_load === true;
+			if (node.value.node_type === "value") emit_var_address(status, "x0", node.value.value);
+			else if (init_is_slot_load) {
+				build_node(node.value, status);
+				ensure_newline(status);
+			} else {
+				emit_init_value(node.value, nir_init, status);
+				ensure_newline(status);
+			}
+			emit_var_store(status, "x0", node.name, 8);
+		}
+		if (!status.function_ref_params) status.function_ref_params = /* @__PURE__ */ new Set();
+		status.function_ref_params.add(node.name);
+		return;
+	}
 	if (node.type.is_pointer) {
 		const offset = allocate_stack_space(status, 8);
 		status.stack_offsets.set(node.name, offset);
@@ -43150,7 +44600,8 @@ function build_declaration_node(node, status, nir_init, nir_swap) {
 			status.alias_owns_flag?.set(node.name, flag_offset);
 		}
 	}
-	if (!is_borrowed_class_ref && !is_field_struct_borrow(node) && struct_type && struct_needs_destroy(struct_type, status)) track_struct_decl(status, node.name, node.type.name, node.type.type_args, node.type.is_nullable);
+	const pure_borrow_element_load = !is_borrowed_class_ref && is_pure_borrow_element_load(node, status);
+	if (!is_borrowed_class_ref && !is_field_struct_borrow(node) && !pure_borrow_element_load && struct_type && struct_needs_destroy(struct_type, status)) track_struct_decl(status, node.name, node.type.name, node.type.type_args, node.type.is_nullable);
 	if (status.enums.find((e) => e.name === node.type.name && e.has_associated_data)) {
 		const enum_size = get_enum_size(node.type.name, status);
 		if (status.function_return_label) {
@@ -43602,9 +45053,13 @@ function build_declaration_node(node, status, nir_init, nir_swap) {
 				status.stack_offsets.set(node.name, offset);
 			} else emit_data(status, `${node.name}: .space 8\n`);
 			if (node.value) {
-				if (node.value.node_type === "value") {
+				const init_is_slot_load = node.value.node_type === "access" && node.value.access.is_element_slot_load === true;
+				if (node.value.node_type === "value" && !init_is_slot_load) {
 					const src_name = node.value.value;
 					emit_var_address(status, "x0", src_name);
+				} else if (init_is_slot_load) {
+					build_node(node.value, status);
+					ensure_newline(status);
 				} else {
 					emit_init_value(node.value, nir_init, status);
 					ensure_newline(status);
@@ -43788,13 +45243,18 @@ function build_declaration_node(node, status, nir_init, nir_swap) {
 					const init_access = node.value?.node_type === "access" ? node.value.access : void 0;
 					const is_borrow_accessor_init = init_access?.node_type === "access_func" && is_container_borrow_accessor_name(init_access.name ?? "");
 					const is_compiler_carrier = is_compiler_temp_name$2(node.name);
-					if (binding_struct && owns_strings_uniformly(binding_struct) && is_borrow_accessor_init) {
+					const pure_borrow_init = is_borrow_accessor_init && is_pure_borrow_element_load(node, status);
+					if (binding_struct && owns_strings_uniformly(binding_struct) && is_borrow_accessor_init && !pure_borrow_init) {
 						if (is_compiler_carrier) node.borrow_accessor_carrier = true;
 						else {
 							emit_var_address(status, "x2", node.name);
 							emit_owning_field_strdups_at(status, binding_struct.name, "x2");
 						}
 					}
+					if (binding_struct && is_borrow_accessor_init && !is_compiler_carrier) {
+						if (!status.func_field_borrow_decls) status.func_field_borrow_decls = /* @__PURE__ */ new Set();
+						status.func_field_borrow_decls.add(node.name);
+					}
 				}
 				if (node.value.is_moved) mark_moved_if_struct(node.value, status);
 				else if (node.value.node_type === "anon_struct") {
@@ -45062,9 +46522,9 @@ function build_assignment_node(node, status, nir_rhs, nir_swap) {
 					if (self_param.value !== name) mark_moved_if_struct(self_param, status);
 				}
 			}
-			const lhs_decl = status.scoped_declarations.find((d) => d.name === name);
-			const lhs_type_name = lhs_decl?.type?.name ?? status.variable_types?.get(name)?.name ?? "";
-			if (rhs_is_struct && !rhs_struct && !paramReg && !is_local_ref_var(name, status) && lhs_type_name) emit_destroy_for_decl(status, name, lhs_type_name, void 0, lhs_decl?.type?.type_args, lhs_decl?.type?.is_nullable);
+			const lhs_decl_type = status.scoped_declarations.find((d) => d.name === name)?.type ?? status.variable_types?.get(name);
+			const lhs_type_name = lhs_decl_type?.name ?? "";
+			if (rhs_is_struct && !rhs_struct && !paramReg && !is_local_ref_var(name, status) && lhs_type_name) emit_destroy_for_decl(status, name, lhs_type_name, void 0, lhs_decl_type?.type_args, lhs_decl_type?.is_nullable);
 			get_source_address(node.right_value, status, nir_rhs);
 			ensure_newline(status);
 			if (paramReg && is_mutable_param(name, status)) {
@@ -45378,7 +46838,12 @@ function build_assignment_node(node, status, nir_rhs, nir_swap) {
 			else if (status.last_result_is_heap) {
 				if (!status.heap_strings) status.heap_strings = /* @__PURE__ */ new Set();
 				status.heap_strings.add(name);
-			} else if (explicit_move_source !== void 0 && status.heap_strings?.delete(explicit_move_source)) status.heap_strings.add(name);
+			} else if (explicit_move_source !== void 0 && status.heap_strings?.has(explicit_move_source)) {
+				if (!status.moved) status.moved = /* @__PURE__ */ new Set();
+				status.moved.add(explicit_move_source);
+				mark_local_moved_flag(status, explicit_move_source);
+				status.heap_strings.add(name);
+			}
 			if (lhs_is_heap && size === 16 && !status.heap_strings?.has(name)) {
 				emit_strdup_string(status);
 				if (!status.heap_strings) status.heap_strings = /* @__PURE__ */ new Set();
@@ -48391,6 +49856,7 @@ function build_access_node(node, status) {
 			break;
 		case "access_func": {
 			const access_func = node.access;
+			if (access_func.is_handler_registration) return;
 			if (access_func.is_nursery_spawn) {
 				build_nursery_spawn(node, access_func, status);
 				return;
@@ -49501,7 +50967,7 @@ function build_access_method(node, access_func, status) {
 	const method_ret_type = access_callee_method?.return_type ?? access_func.type;
 	const resolved_ret_type = resolve_mono_type(method_ret_type, status);
 	const ret_type_name = resolved_ret_type.name || access_func.type.name;
-	const return_struct = !access_func.type.is_view && !access_func.type.is_array && !resolved_ret_type.is_view && !resolved_ret_type.is_array && (!!status.structs.find((s) => s.name === ret_type_name && !s.is_simple_type && !s.is_class) || get_enum_sret_size(ret_type_name, status) !== void 0);
+	const return_struct = !access_func.type.is_view && !access_func.type.is_array && !resolved_ret_type.is_view && !resolved_ret_type.is_array && !resolved_ret_type.is_pointer && !access_func.type.is_pointer && (!!status.structs.find((s) => s.name === ret_type_name && !s.is_simple_type && !s.is_class) || get_enum_sret_size(ret_type_name, status) !== void 0);
 	if (process.env.NOMEN_DBG_SRET) __require("node:fs").appendFileSync("/var/folders/j7/hblq8b2n0t5258cz04tslkg80000gp/T/opencode/nom_asm/dbg.log", `access method=${method_name} ret=${access_func.type.name} mono=${mono_struct_name} return_struct=${return_struct}\n`);
 	const nullable_scalar_ret = is_nullable_scalar_type(method_ret_type, status) && !method_ret_type.is_ref;
 	let temp_addr = "";
@@ -49569,7 +51035,7 @@ function build_access_method(node, access_func, status) {
 					emit_asm(status, `ldr x0, [x0]\n`);
 					emit_asm(status, `add x0, x0, #8\n`);
 				} else if (target_type.is_array && (status.function_array_params?.has(name) || status.function_variadic_params?.has(name)) && !is_local_ref_var(name, status)) emit_asm(status, `ldr x0, [x0]\n`);
-				else if (target_is_simple && !target_type.is_array && (target_type.name !== "string" || has_stack_offset) && !is_local_ref_var(name, status) && !method_self_is_ref) {
+				else if (target_is_simple && !target_type.is_array && (target_type.name !== "string" || has_stack_offset) && !method_self_is_ref && (!is_local_ref_var(name, status) || target_type.name !== "string")) {
 					const size = aarch64_size(target_type.name);
 					const signed = is_signed_type(target_type.name);
 					if (size === 1) emit_asm(status, signed ? `ldrsb x0, [x0]\n` : `ldrb w0, [x0]\n`);
@@ -50044,269 +51510,6 @@ function resolve_access_type(node, status) {
 	return struct.fields.find((f) => f.name === field_name)?.type || null;
 }
 //#endregion
-//#region ../src/build_aarch64/utils/c_companion.ts
-/**
-* Generate the complete C companion file: includes, struct typedefs, and
-* function definitions for every collected `aarch64_use_c` function.
-*/
-function generate_companion(functions, status) {
-	let out = "";
-	if (functions.length > 0 && (status.platform === "macos" || status.platform === "ios")) {
-		out += `#import <Foundation/Foundation.h>\n`;
-		out += `#include <objc/runtime.h>\n`;
-		out += `#include <objc/message.h>\n`;
-		if (status.platform === "macos") out += `#import <Cocoa/Cocoa.h>\n`;
-		else out += `#import <UIKit/UIKit.h>\n`;
-	}
-	out += `#include <stdint.h>\n`;
-	out += `#include <stdlib.h>\n`;
-	out += `typedef struct { void* ptr; long len; } nomen_view;\n`;
-	out += `typedef struct { char* ptr; long len; } nomen_string;\n`;
-	out += `#include <stdio.h>\n`;
-	out += `#include <string.h>\n`;
-	out += `#include <regex.h>\n`;
-	if (status.file_scope_c?.includes("pthread") || status.emit_mode === "system") out += `#include <pthread.h>\n`;
-	out += "\n";
-	if (status.audit) {
-		out += `void *nomen_malloc_wrap(unsigned long);\n`;
-		out += `void *nomen_calloc_wrap(unsigned long, unsigned long);\n`;
-		out += `void *nomen_realloc_wrap(void *, unsigned long);\n`;
-		out += `void nomen_free_wrap(void *);\n`;
-		out += `void *nomen_strdup_wrap(const char *);\n`;
-		out += `void nomen_audit_check(void);\n`;
-		out += "\n";
-	}
-	if (status.emit_mode === "system") {
-		out += runtime_declarations(POOL_HEADER_C + FIBER_HEADER_C);
-		out += "\n";
-	} else {
-		if (!status.pool_runtime_emitted) {
-			out += POOL_HEADER_C;
-			status.pool_runtime_emitted = true;
-		}
-		if (!status.fiber_runtime_emitted) {
-			out += FIBER_HEADER_C;
-			status.fiber_runtime_emitted = true;
-		}
-	}
-	const enum_nodes = status.enums.filter((e) => !e.is_generic);
-	const struct_nodes = status.structs.filter((s) => !s.is_simple_type && !s.is_generic);
-	const node_kind = /* @__PURE__ */ new Map();
-	for (const e of enum_nodes) node_kind.set(e.name, "enum");
-	for (const st of struct_nodes) node_kind.set(st.name, "struct");
-	for (const b of status.bitsets) node_kind.set(b.name, "bitset");
-	const deps = /* @__PURE__ */ new Map();
-	for (const e of enum_nodes) {
-		const d = /* @__PURE__ */ new Set();
-		for (const c of e.cases) for (const p of c.params) if (node_kind.has(p.type.name) && p.type.name !== e.name) d.add(p.type.name);
-		deps.set(e.name, d);
-	}
-	for (const st of struct_nodes) {
-		const d = /* @__PURE__ */ new Set();
-		for (const f of st.fields) {
-			if (f.type.is_view) continue;
-			if (node_kind.has(f.type.name) && f.type.name !== st.name) d.add(f.type.name);
-		}
-		deps.set(st.name, d);
-	}
-	const emitted = /* @__PURE__ */ new Set();
-	const visiting = /* @__PURE__ */ new Set();
-	const node_list = [
-		...enum_nodes,
-		...struct_nodes,
-		...status.bitsets
-	];
-	const by_name = new Map(node_list.map((n) => [n.name, n]));
-	const visit = (name) => {
-		if (emitted.has(name) || visiting.has(name)) return;
-		visiting.add(name);
-		for (const dep of deps.get(name) ?? []) visit(dep);
-		visiting.delete(name);
-		emitted.add(name);
-		const node = by_name.get(name);
-		if (!node) return;
-		if (node_kind.get(name) === "enum") out += generate_enum_definition(node, status);
-		else if (node_kind.get(name) === "bitset") out += `typedef unsigned long ${nm(name)};\n`;
-		else out += generate_struct_definition(node, status);
-	};
-	for (const n of node_list) visit(n.name);
-	out += "\n";
-	if (status.file_scope_c) {
-		out += status.file_scope_c;
-		out += "\n";
-	}
-	for (const entry of functions) out += generate_c_function(entry.func, entry.struct_name, entry.raw_code, status);
-	return out;
-}
-/**
-* Prefix a Nomen type's C TYPEDEF name with `nm_`. The companion file `#import`s
-* the platform frameworks (Foundation/Cocoa/UIKit), which drag in a large set of
-* system typedefs (e.g. macOS `MacTypes.h` defines `typedef long Size`). If we
-* emitted Nomen's own `typedef struct Size {...} Size;` the typedef name would
-* collide; mangling only the typedef (`typedef struct Size {...} nm_Size;`)
-* sidesteps it while leaving the struct TAG (`Size`) untouched.
-*
-* Keeping the original tag matters: generated C (spawn/trampoline infra in
-* build_spawn_node / build_nursery_spawn) and `#arch: aarch64_use_c` raw bodies
-* reference Nomen types as `struct Foo` (the tag), so an unchanged tag means
-* none of that code needs to know about mangling. Codegen-generated references
-* here (fields, params, returns) use the mangled typedef instead.
-*
-* `nm_` (no leading underscore: the C standard reserves `_`+lowercase
-* identifiers at file scope). This is purely cosmetic — the aarch64 assembly
-* never references type names (only function labels, bridged via `__asm__`).
-*/
-function nm(name) {
-	return "nm_" + name;
-}
-/**
-* The C type for a field/param/return of the given Nomen type, applying `nm_`
-* to user-defined struct/enum types and falling back to `c_type` for primitives.
-* Generic structs lower to opaque 8-byte pointers (their element type lives in
-* the Nomen `Type`, not in the C layout).
-*/
-/**
-* The C type for a value stored BY VALUE in an enum payload: classes and
-* traits are heap/shared references (pointers, and never have a companion
-* typedef), everything else follows `companion_type`.
-*/
-function payload_type(typeName, status) {
-	if (status.structs.find((s) => s.name === typeName)?.is_class) return `struct ${typeName} *`;
-	if (status.traits.find((t) => t.name === typeName)) return `struct ${typeName} *`;
-	return companion_type(typeName, status);
-}
-function companion_type(typeName, status) {
-	const struct = status.structs.find((s) => s.name === typeName);
-	if (struct?.is_generic) return "void *";
-	if (struct && !struct.is_simple_type) return nm(typeName);
-	if (!struct && status.enums.find((e) => e.name === typeName)) return nm(typeName);
-	if (status.bitsets.find((b) => b.name === typeName)) return nm(typeName);
-	return c_type(typeName);
-}
-/**
-* Emit an enum's C type definition. Mirrors the C backend's `build_enum_node`
-* (typedef for simple enums; tag + tagged-union struct for enums with associated
-* data) but with `nm_`-prefixed TYPEDEF names and no constructor functions (those
-* are emitted as assembly in the aarch64 path; the companion only needs types so
-* struct fields / function signatures can reference them). The struct tag keeps
-* the original Nomen name (see `nm`).
-*/
-function generate_enum_definition(node, status) {
-	let out = "";
-	if (node.has_associated_data) {
-		out += `typedef enum { ${node.cases.map((c) => `${node.name}_${c.name}`).join(", ")} } ${nm(node.name)}_tag;\n`;
-		out += `struct ${node.name};\n`;
-		out += `typedef struct ${node.name}\n{\n`;
-		out += `${nm(node.name)}_tag tag;\n`;
-		out += `union {\n`;
-		for (const c of node.cases) out += `struct { ${c.params.map((p) => `${payload_type(p.type.name, status)} ${p.name}`).join("; ")}${c.params.length ? ";" : ""} } _${c.name};\n`;
-		out += `} _data;\n`;
-		out += `} ${nm(node.name)};\n`;
-	} else out += `typedef enum { ${node.cases.map((c) => `${node.name}_${c.name}`).join(", ")} } ${nm(node.name)};\n`;
-	return out;
-}
-function generate_struct_definition(struct, status) {
-	let out = `typedef struct ${struct.name}\n{\n`;
-	out += `void *_vt;\n`;
-	for (const field of struct.fields) out += `${field.type.is_view ? "nomen_view" : payload_type(field.type.name, status)} ${field.name};\n`;
-	for (const traitName of struct.traits) {
-		const trait = status.traits.find((t) => t.name === traitName);
-		if (!trait) continue;
-		for (const field of trait.fields.filter((f) => !struct.fields.find((nf) => nf.name === f.name))) out += `${field.type.is_view ? "nomen_view" : payload_type(field.type.name, status)} ${field.name};\n`;
-	}
-	out += `} ${nm(struct.name)};\n`;
-	return out;
-}
-function generate_c_function(func, struct_name, raw_code, status) {
-	let func_label;
-	if (struct_name) {
-		const struct = status.structs.find((s) => s.name === struct_name);
-		if (struct && is_overloaded(struct, func.name)) func_label = mangled_label(func, struct_name);
-		else func_label = `${struct_name}_${func.name.replace(/#/g, "")}`;
-	} else func_label = func.name === "main" ? "_nomen_main" : func.name;
-	const is_class_init = func.name === "#init" && !!(struct_name && status.structs.find((s) => s.name === struct_name));
-	const return_type = is_class_init ? "void" : func.return_type?.name || "void";
-	const return_struct = is_class_init ? void 0 : status.structs.find((s) => s.name === return_type && !s.is_simple_type);
-	let return_prefix = return_struct ? nm(return_type) : companion_type(return_type, status);
-	return_prefix += ` `;
-	const return_enum_size = return_struct ? void 0 : get_enum_sret_size(return_type, status);
-	const return_struct_size = return_struct ? get_struct_size(return_type, status) : 0;
-	const symbol_label = return_struct && return_struct_size <= 16 || return_enum_size !== void 0 && return_enum_size <= 16 ? `${func_label}_c` : func_label;
-	const params = func.params;
-	let param_list = "";
-	for (let i = 0; i < params.length; i++) {
-		if (i > 0) param_list += ", ";
-		param_list += generate_c_param(params[i], status);
-	}
-	if (params.length === 0) param_list += `void`;
-	let out = `// ${func_label}\n`;
-	out += `${return_prefix}${symbol_label}(${param_list}) __asm__("${symbol_label}");\n`;
-	out += `${return_prefix}${symbol_label}(${param_list})\n{\n`;
-	if (func.name === "#init" && struct_name) {
-		const ctor_struct = status.structs.find((s) => s.name === struct_name);
-		if (ctor_struct && !ctor_struct.is_simple_type) {
-			if (ctor_struct.traits.length > 0) {
-				out += `extern void *${struct_name}_traits;\n`;
-				out += `self->_vt = (void *)&${struct_name}_traits;\n`;
-			} else if (!ctor_struct.is_class) out += `self->_vt = (void *)1;\n`;
-			for (const field of ctor_struct.fields) {
-				if (!field.value) continue;
-				const seeded = emit_ctor_field_default(ctor_struct, field);
-				if (!seeded) {
-					if (!status.build_errors) status.build_errors = [];
-					status.build_errors.push({
-						message: `mv struct '${struct_name}' has a use_c constructor and field '${field.name}' has a non-literal default — assign it in the #init body`,
-						start: func.start
-					});
-					continue;
-				}
-				out += seeded;
-			}
-		}
-	}
-	const self_param = params[0];
-	if (struct_name && self_param?.is_self_param && !self_param?.is_ref && func.name !== "#destroy" && func.name !== "#init") {
-		const struct = status.structs.find((s) => s.name === struct_name);
-		if (struct && !struct.is_simple_type) out += `${nm(struct_name)} _self = *self;\n`;
-	}
-	out += raw_code;
-	out += `\n}\n\n`;
-	return out;
-}
-/**
-* The C statement seeding a defaulted field in a companion constructor, or
-* `undefined` when the default is not a literal shape. Mirrors the ASM-side
-* ctor's default seeding for the shapes a `use_c` constructor can express:
-* string literals borrow static storage (a function-static C literal — never
-* strdup'd, matching the ASM literal-pair store), scalar/bool literals store
-* directly. Nullable and computed defaults are rejected — the caller turns
-* that into a build error naming the field.
-*/
-function emit_ctor_field_default(struct_node, field) {
-	const value = field.value?.node_type === "value" ? field.value.value : void 0;
-	if (value === void 0 || typeof value !== "string") return void 0;
-	if (field.type.is_nullable) return void 0;
-	if (field.type.name === "string" && !field.type.is_view) {
-		const length = string_literal_length(value);
-		const label = `_${struct_node.name}_${field.name}_default`;
-		return `static const char ${label}[] = ${escape_asciz(value)};\nself->${field.name} = (nomen_string){ (char *)${label}, ${length} };\n`;
-	}
-	if (value === "true" || value === "false") return `self->${field.name} = ${value === "true" ? 1 : 0};\n`;
-	if (/^-?\d+$/.test(value)) return `self->${field.name} = ${value};\n`;
-}
-function generate_c_param(param, status) {
-	const struct_type = status.structs.find((s) => s.name === param.type.name);
-	const trait_type = status.traits.find((t) => t.name === param.type.name);
-	const is_struct = (param.is_self_param || struct_type || trait_type) && !struct_type?.is_simple_type;
-	let out = "";
-	if (param.is_variadic) out += `long _${param.name}_len, `;
-	out += companion_type(param.type.name, status);
-	if (is_struct || param.declaration === "var" || param.type.is_ref || param.type.is_array) out += ` *`;
-	else out += ` `;
-	out += param.name;
-	return out;
-}
-//#endregion
 //#region ../src/build_aarch64/utils/scan_heap_returns.ts
 const KNOWN_HEAP_RETURNING = /* @__PURE__ */ new Set([]);
 function scan_heap_returning_functions(root) {
@@ -50532,7 +51735,7 @@ function fold_asm_constants(asm) {
 			i++;
 			continue;
 		}
-		const m = /^(\w+)\s*(.*)$/.exec(line);
+		const m = /^([A-Za-z.][\w.]*)\s*(.*)$/.exec(line);
 		if (!m) {
 			clear();
 			out.push(raw_line);
@@ -51161,7 +52364,9 @@ function build(root, options = {}) {
 			for (const [label, value] of status.float_literals) status.code += `${label}: .double ${value}\n`;
 		}
 		const emit_mode = status.emit_mode ?? "all";
-		const interpolate_lengths = emit_mode === "user" ? [] : emit_mode === "system" ? Array.from(/* @__PURE__ */ new Set([
+		let interpolate_lengths;
+		if (emit_mode === "user") interpolate_lengths = Array.from(status.interpolate_string_counts).filter((n) => n > 7);
+		else if (emit_mode === "system") interpolate_lengths = Array.from(/* @__PURE__ */ new Set([
 			...status.interpolate_string_counts,
 			1,
 			2,
@@ -51170,15 +52375,21 @@ function build(root, options = {}) {
 			5,
 			6,
 			7
-		])).sort((a, b) => a - b) : Array.from(status.interpolate_string_counts);
+		])).sort((a, b) => a - b);
+		else interpolate_lengths = Array.from(status.interpolate_string_counts);
 		for (const length of interpolate_lengths) {
 			status.code += `\n.p2align 2\n`;
 			if (emit_mode === "system") status.code += `.globl _string_interpolate_${length}\n`;
 			status.code += `_string_interpolate_${length}:\n`;
 			status.code += `stp x29, x30, [sp, #-16]!\n`;
 			status.code += `mov x29, sp\n`;
-			status.code += `sub sp, sp, #80\n`;
-			status.code += `str x0, [sp, #72]\n`;
+			const args_area = length * 8;
+			const len_off = args_area;
+			const buf_off = args_area + 8;
+			const pat_off = args_area + 16;
+			const frame = Math.ceil((args_area + 24) / 16) * 16;
+			status.code += `sub sp, sp, #${frame}\n`;
+			status.code += `str x0, [sp, #${pat_off}]\n`;
 			const pairRegs = [
 				["x2", "x3"],
 				["x4", "x5"],
@@ -51191,7 +52402,7 @@ function build(root, options = {}) {
 			}
 			status.code += `mov x0, xzr\n`;
 			status.code += `mov x1, xzr\n`;
-			status.code += `ldr x2, [sp, #72]\n`;
+			status.code += `ldr x2, [sp, #${pat_off}]\n`;
 			const variadicRegs = [
 				"x3",
 				"x4",
@@ -51202,17 +52413,17 @@ function build(root, options = {}) {
 			for (let i = 0; i < length && i < variadicRegs.length; i++) status.code += `ldr ${variadicRegs[i]}, [sp, #${i * 8}]\n`;
 			status.code += `bl _snprintf\n`;
 			status.code += `add x0, x0, #1\n`;
-			status.code += `str x0, [sp, #56]\n`;
+			status.code += `str x0, [sp, #${len_off}]\n`;
 			emit_malloc(status);
-			status.code += `str x0, [sp, #64]\n`;
-			status.code += `ldr x0, [sp, #64]\n`;
-			status.code += `ldr x1, [sp, #56]\n`;
-			status.code += `ldr x2, [sp, #72]\n`;
+			status.code += `str x0, [sp, #${buf_off}]\n`;
+			status.code += `ldr x0, [sp, #${buf_off}]\n`;
+			status.code += `ldr x1, [sp, #${len_off}]\n`;
+			status.code += `ldr x2, [sp, #${pat_off}]\n`;
 			for (let i = 0; i < length && i < variadicRegs.length; i++) status.code += `ldr ${variadicRegs[i]}, [sp, #${i * 8}]\n`;
 			status.code += `bl _snprintf\n`;
 			status.code += `mov x1, x0\n`;
-			status.code += `ldr x0, [sp, #64]\n`;
-			status.code += `add sp, sp, #80\n`;
+			status.code += `ldr x0, [sp, #${buf_off}]\n`;
+			status.code += `add sp, sp, #${frame}\n`;
 			status.code += `ldp x29, x30, [sp], #16\n`;
 			status.code += `ret\n`;
 		}
@@ -51239,7 +52450,7 @@ function build(root, options = {}) {
 			status.code = status.code.replaceAll("bl _strdup\n", "bl _nomen_strdup_wrap\n");
 			status.code = status.code.replaceAll("bl _free\n", "bl _nomen_free_wrap\n");
 		}
-		const { result: lifted } = lift_functions(status.code);
+		const { result: lifted } = lift_functions(status.code, { allow_external_branch_targets: status.emit_mode === "user" });
 		const lift_errors = lifted.errors;
 		if (lift_errors.length > 0) {
 			if (!status.build_errors) status.build_errors = [];
@@ -51275,6 +52486,10 @@ function build(root, options = {}) {
 	if (options.arch === "aarch64") ensure_weak_runtime_a64(status);
 	let companion;
 	if (status.c_companion_functions && status.c_companion_functions.length > 0 || status.file_scope_c) companion = generate_companion(status.c_companion_functions ?? [], status);
+	if (options.arch === "aarch64" && companion && status.c_companion_functions) for (const entry of status.c_companion_functions) {
+		const label = companion_function_label(entry.func, entry.struct_name, status);
+		if (label.startsWith("L")) status.code = status.code.replace(new RegExp(`\\b${label}`, "g"), `_${label}`);
+	}
 	if (companion && options.audit) companion = wrap_c_allocators(companion);
 	if (status.headers.includes("struct Point") && !status.headers.includes("typedef struct Point") && process.env.NOMEN_DBG) console.error("DBG build.ts: headers has forward Point but no typedef. len=", status.headers.length);
 	return {
@@ -52894,6 +54109,10 @@ function clone_node(node) {
 		case "access_field": {
 			const n = node;
 			const c = new AccessFieldNode(n.start, n.name, n.type ? clone_type$2(n.type) : void 0);
+			c.is_destructure = n.is_destructure;
+			c.destructure_index = n.destructure_index;
+			c.is_destructure_rename = n.is_destructure_rename;
+			c.destructure_move = n.destructure_move;
 			c.allocations = n.allocations?.map(clone_node);
 			return c;
 		}
@@ -52918,6 +54137,8 @@ function clone_node(node) {
 			} : void 0;
 			c.inferred_array_length = n.inferred_array_length;
 			c.is_nursery_spawn = n.is_nursery_spawn;
+			c.is_handler_registration = n.is_handler_registration;
+			c.is_handler_enrollment = n.is_handler_enrollment;
 			c.is_thread_start = n.is_thread_start;
 			c.is_thread_detach = n.is_thread_detach;
 			c.is_fiber_start = n.is_fiber_start;
@@ -53689,7 +54910,9 @@ function type_from_value_node(node, status) {
 				t.is_nullable = true;
 				return t;
 			}
-			return type_from_value(vn.value, status);
+			const t = type_from_value(vn.value, status);
+			if (t.name) return t;
+			return vn.type?.name ? vn.type : t;
 		}
 		case "access": return type_from_value_node(node.access, status);
 		case "array": return node.type;
@@ -53751,8 +54974,7 @@ function borrow_depth_of(node, status) {
 				return Math.max(base?.borrow_depth ?? 0, status.scope_depth);
 			}
 		} else if (access.access.node_type === "access_func") {
-			if (is_borrowed_return(type_from_value_node(access, status), status)) {
-				if (access.access.owned_return) return void 0;
+			if (is_borrowed_return(type_from_value_node(access, status), status) && !access.access.owned_return || is_element_load_pure_borrow(access, status)) {
 				if (access.target.node_type === "value") {
 					const recv = status.values.findLast((v) => v.name === access.target.value);
 					if (recv) return recv.borrow_depth ?? recv.decl_depth ?? status.scope_depth;
@@ -53784,8 +55006,7 @@ function borrow_owner_of(node, status) {
 			if (t?.name && is_owning_ref_type(t.name, status)) return ultimate_owner(access.target, status);
 			if (t?.is_view) return ultimate_owner(access.target, status);
 		} else if (access.access.node_type === "access_func") {
-			if (is_borrowed_return(type_from_value_node(access, status), status)) {
-				if (access.access.owned_return) return void 0;
+			if (is_borrowed_return(type_from_value_node(access, status), status) && !access.access.owned_return || is_element_load_pure_borrow(access, status)) {
 				if (access.target.node_type === "value") {
 					const recv = status.values.findLast((v) => v.name === access.target.value);
 					if (recv) return recv.borrowed_from ?? recv.name;
@@ -53811,6 +55032,26 @@ function is_borrowed_return(t, status) {
 	return !!t.name && is_owning_ref_type(t.name, status);
 }
 /**
+* The `List<Own>.at()` pure borrow (FOLLOWUP.md): a container borrow accessor
+* (`list.at(i)` — the accessor family, non-`mv out`) whose value-struct
+* element aliases destroy-worthy state the load cannot privatize. The result
+* is a borrow of the slot's resources — rooted at the container exactly like
+* a class-typed method return, so a `ref self` call on the container
+* invalidates it, it cannot escape its scope, and it cannot transfer through
+* `mv`. Deliberately name-scoped to the accessor family: any method may
+* return a `#destroy`-bearing struct by value as an OWNED transfer.
+*/
+function is_element_load_pure_borrow(access, status) {
+	const func_access = access.access;
+	if (func_access.owned_return) return false;
+	if (!is_container_borrow_accessor_name(func_access.name ?? "")) return false;
+	const t = type_from_value_node(access, status);
+	if (!t?.name || t.is_view || t.is_array) return false;
+	const elem = status.structs.find((s) => s.name === t.name && !s.is_simple_type && !s.is_generic);
+	if (!elem || elem.is_class) return false;
+	return element_load_aliases_destroy_state(elem, status);
+}
+/**
 * Resolve an access target down to its ultimate mv variable name. Recurses
 * through field paths so `z.animals` → `z` (and `a.b.c` → `a`).
 */
@@ -55770,6 +57011,7 @@ function sanitize_type_name(t) {
 function clone_type$1(t) {
 	const new_t = new Type(t.name, t.is_static, t.is_array, t.length);
 	new_t.is_ref = t.is_ref;
+	new_t.is_view = t.is_view;
 	new_t.is_nullable = t.is_nullable;
 	new_t.is_return_type = t.is_return_type;
 	new_t.type_args = t.type_args?.map(clone_type$1);
@@ -55826,6 +57068,178 @@ function materialize_tuple_type(type, status) {
 	return new_type;
 }
 //#endregion
+//#region ../src/check/utils/view_fields.ts
+/**
+* Whether the named struct (or any value struct embedded in its fields,
+* recursively) declares a `view T` field. A struct with view fields carries
+* non-mv borrows inside its bytes, which drives the borrow rules:
+* copies are sound (a pair copy aliases nothing owned), but escapes
+* (returning, outer-scope assignment) are checked against where those
+* borrows were taken.
+*/
+function struct_has_view_fields(type_name, status) {
+	if (!type_name) return false;
+	const struct = status.structs.find((s) => s.name === type_name && !s.is_simple_type);
+	return !!struct && has_view_fields(struct, status, /* @__PURE__ */ new Set());
+}
+function has_view_fields(struct, status, visited) {
+	if (visited.has(struct.name)) return false;
+	visited.add(struct.name);
+	for (const field of struct.fields) {
+		if (field.type.is_view) return true;
+		if (field.type.is_ref || field.type.is_array) continue;
+		const field_struct = status.structs.find((s) => s.name === field.type.name && !s.is_simple_type && !s.is_class);
+		if (field_struct && has_view_fields(field_struct, status, visited)) return true;
+	}
+	return false;
+}
+/**
+* The root variable an access chain bottoms out at (`line.text` → "line",
+* `a.b.c` → "a", bare `x` → "x"). Returns undefined when the chain does not
+* bottom out in a plain name (e.g. a call receiver).
+*/
+function root_var_of(node) {
+	if (node.node_type === "value") {
+		const name = node.value;
+		return name === "null" ? void 0 : name;
+	}
+	if (node.node_type === "access") return root_var_of(node.target);
+}
+/**
+* Where a view value stored into a field borrows from.
+*
+*  - A `.slice()`-style view expression: borrow_depth/borrow_owner give the
+*    scope depth and owner variable (the slice's receiver).
+*  - A bare variable of owned type (`view string f = doc`): borrowing it is
+*    the identity on fat strings, but it creates a real dependency — record
+*    the source's own declaration depth and name so reassignment of the
+*    source invalidates the field.
+*  - A literal / const: static storage that outlives everything — no borrow.
+*
+* Returns undefined for sources that impose no dependency.
+*/
+function view_source_borrow_info(node, status) {
+	if (node.node_type === "value" && node.value.startsWith("\"")) return void 0;
+	const depth = borrow_depth_of(node, status);
+	const owner = borrow_owner_of(node, status);
+	if (depth !== void 0 || owner !== void 0) return {
+		depth: depth ?? status.scope_depth,
+		owner
+	};
+	if (node.node_type === "value") {
+		const decl = status.values.findLast((v) => v.name === node.value);
+		if (decl && !decl.is_null) return {
+			depth: decl.decl_depth ?? 0,
+			owner: decl.name
+		};
+		const alloc = status.allocations.findLast((d) => d.name === node.value);
+		if (alloc?.value) return view_source_borrow_info(alloc.value, status);
+	}
+}
+/**
+* Borrow info contributed by a constructor call's `view T` arguments (e.g.
+* `Line(doc.slice(0, 5), 0, 5)`): merges every view-typed argument's borrow
+* into one entry per distinct owner (the tightest depth wins). Returns
+* undefined when the call passes no dependent views.
+*/
+function ctor_call_view_borrow(call, status) {
+	const indices = call.view_param_indices ?? [];
+	let merged;
+	for (const i of indices) {
+		let arg = call.params[i];
+		if (!arg) continue;
+		if (arg.node_type === "value") {
+			const name = arg.value;
+			const hoisted = call.allocations?.findLast((d) => d.name === name) ?? status.allocations.findLast((d) => d.name === name);
+			if (hoisted?.value) arg = hoisted.value;
+		}
+		const info = view_source_borrow_info(arg, status);
+		if (!info) continue;
+		if (!merged) merged = /* @__PURE__ */ new Map();
+		merge_borrow_info(merged, info);
+	}
+	return merged;
+}
+/** Fold one borrow into the per-owner map, keeping the tightest depth. */
+function merge_borrow_info(map, info) {
+	const key = info.owner ?? "";
+	const existing = map.get(key);
+	if (!existing) {
+		map.set(key, { ...info });
+		return;
+	}
+	if (info.depth !== void 0 && (existing.depth === void 0 || info.depth < existing.depth)) existing.depth = info.depth;
+}
+/**
+* Record that view values were stored into fields of the struct variable
+* `root`: the instance now carries borrows rooted at each owner with the
+* given scope depths. Depth tracking keeps the tightest (deepest-rooted)
+* borrow so escape checks stay conservative across multiple fields. Also
+* clears any stale invalidation for the root — the fresh store re-points a
+* field (approximation: any view-field store refreshes the whole instance).
+*/
+function merge_view_borrows_into_var(root, infos, status) {
+	if (!root || !infos || infos.size === 0) return;
+	const sv = status.values.findLast((v) => v.name === root);
+	if (!sv) return;
+	sv.has_view_borrows = true;
+	if (!sv.view_field_owners) sv.view_field_owners = /* @__PURE__ */ new Set();
+	for (const [owner, info] of infos) {
+		if (owner) sv.view_field_owners.add(owner);
+		if (info.depth !== void 0) sv.borrow_depth = sv.borrow_depth === void 0 ? info.depth : Math.min(sv.borrow_depth, info.depth);
+	}
+	status.invalidated_view_structs?.delete(root);
+}
+/**
+* Propagate view-field borrow state when a struct value is copied
+* (`b = a`, `var Line b = a`): the copy aliases the same sources, so it
+* depends on exactly the same owners and inherits the tightest depth.
+*/
+function propagate_view_borrows(target, source) {
+	if (!source.has_view_borrows) return;
+	target.has_view_borrows = true;
+	if (source.view_field_owners?.size) {
+		if (!target.view_field_owners) target.view_field_owners = /* @__PURE__ */ new Set();
+		for (const owner of source.view_field_owners) target.view_field_owners.add(owner);
+	}
+	if (source.borrow_depth !== void 0 && (target.borrow_depth === void 0 || source.borrow_depth < target.borrow_depth)) target.borrow_depth = source.borrow_depth;
+}
+/**
+* Whether every recorded view-field borrow of the value roots at `self`
+* (the receiver) — the same re-rooting convention that lets a `slice`
+* method return its view: the caller re-roots the borrow at the call-site
+* receiver.
+*/
+function view_borrows_root_at_self(sv) {
+	const owners = sv.view_field_owners;
+	return !!owners?.size && [...owners].every((o) => o === "self");
+}
+/**
+* Whether a value of this type can carry a non-mv view borrow: the type
+* itself is a `view`, a `ref` (a borrow by definition — keep the existing
+* taint), a struct declaring (transitively) `view T` fields, or a generic
+* instantiation with such an argument. Anything else (primitives, owned
+* strings, containers of owned values) owns its storage outright, so a call
+* producing it does not propagate its view arguments' borrows — tainting it
+* is a false positive (e.g. returning `slice_string(view)` from a function
+* returning owned `string`). Callers pass an unset/unknown type through as
+* carrying, preserving today's behavior where nothing is known.
+*/
+function type_can_carry_view_borrow(type, status) {
+	if (!type || !type.name) return true;
+	if (type.is_view || type.is_ref) return true;
+	if (struct_has_view_fields(type.name, status)) return true;
+	return (type.type_args ?? []).some((t) => type_can_carry_view_borrow(t, status));
+}
+/**
+* Whether reading view fields of `root` is currently rejected because their
+* source was mutated (reassigned / ref-mutated).
+*/
+function view_fields_invalidated(root, status) {
+	if (!root) return false;
+	return !!status.invalidated_view_structs?.has(root);
+}
+//#endregion
 //#region ../src/check/utils/anon_enum.ts
 /**
 * Canonical, order-independent name for an auto-generated anonymous enum
@@ -55863,6 +57277,8 @@ function contains_unresolved_param(t, status) {
 */
 function get_or_create_anon_enum(cases, status) {
 	if (cases.some((c) => c.types.some((t) => contains_unresolved_param(t, status)))) return null;
+	for (const c of cases) for (const t of c.types) if (t.is_view) add_error(status, `enum case payloads cannot be 'view' — materialize the value ('.to_string()') or re-slice from the source on use`, t.start ?? 0);
+	else if (t.name && struct_has_view_fields(t.name, status)) add_error(status, `enum case payloads cannot be '${t.name}' — structs with 'view' fields are scope-local; store the fields (the views) instead`, t.start ?? 0);
 	const sorted = [...cases].sort((a, b) => a.name.localeCompare(b.name));
 	const name = anon_enum_name(sorted);
 	const root = status.stack[0];
@@ -56084,22 +57500,27 @@ function spawn_arg_region_class(arg_type, moved, status) {
 * (`nursery_frozen_roots`): `check_async_block_node` pushes one, block
 * clones SHARE the innermost set (the freeze lasts to the block exit, not
 * to the construction's branch exit), and the set dies with the block's
-* cloned status — the enclosing scope never sees it.
+* cloned status — the enclosing scope never sees it. Each entry records the
+* spawn that lent the root (the task label), so the write gate can name it.
 */
-function freeze_root(root, status) {
+function freeze_root(root, status, task_label) {
 	if (!status.nursery_frozen_roots?.length) return;
-	status.nursery_frozen_roots[status.nursery_frozen_roots.length - 1].add(root);
+	status.nursery_frozen_roots[status.nursery_frozen_roots.length - 1].set(root, task_label);
 }
 /**
-* The R3 write gate: `'m' is borrowed by a task until this 'async' block
-* exits`. Called from every mutation path with the ROOT variable's name.
-* Returns true when the name is frozen (the error has been added).
+* The R3 write gate: `'m' is borrowed by the 'worker' spawn until this
+* 'async' block exits`. Called from every mutation path with the ROOT
+* variable's name. Returns true when the name is frozen (the error has been
+* added). The message names the spawn that lent the root — the disclosure
+* is retroactive (the lend itself rides the unspelled read-only default
+* flavor), so it must at least be precise.
 */
 function enforce_root_not_frozen(name, status, start) {
 	const frames = status.nursery_frozen_roots;
 	if (!frames?.length) return false;
-	if (frames[frames.length - 1].has(name)) {
-		add_error(status, `'${name}' is borrowed by a task until this 'async' block exits — it is read-only here (mv a copy in, or mv it in at the spawn)`, start);
+	const lender = frames[frames.length - 1].get(name);
+	if (lender !== void 0) {
+		add_error(status, `'${name}' is borrowed by ${lender} until this 'async' block exits — it is read-only here (mv a copy in, or mv it in at the spawn)`, start);
 		return true;
 	}
 	return false;
@@ -56109,7 +57530,7 @@ function enforce_root_not_frozen(name, status, start) {
 * (shared class/trait since tranche 1; mv value structs and views since
 * R1). Called from the Sendable validation site.
 */
-function enforce_spawn_arg_region(param, arg_type, status, is_ref_borrow = false) {
+function enforce_spawn_arg_region(param, arg_type, status, is_ref_borrow = false, task_label = "a task") {
 	if ((status.nursery_depth ?? 0) === 0) return;
 	if ((is_ref_borrow ? "borrow" : spawn_arg_region_class(arg_type, false, status)) !== "borrow") return;
 	const join_depth = innermost_nursery_depth(status);
@@ -56127,7 +57548,7 @@ function enforce_spawn_arg_region(param, arg_type, status, is_ref_borrow = false
 		else add_error(status, `this task shares a temporary ${arg_type.name ?? ""} that dies before the 'async' join — bind it to a local in the 'async' block's scope and pass the local`, param.start);
 		return;
 	}
-	if (root !== void 0 && arg_type.name !== "Task") freeze_root(root, status);
+	if (root !== void 0 && arg_type.name !== "Task") freeze_root(root, status, task_label);
 }
 /**
 * N2 / R4 — a detached task owns its captures. Called from the access-func
@@ -56208,178 +57629,6 @@ function boxing_owns_error() {
 	return `boxing owns its instance — mv the value, or copy it ('.copy()')`;
 }
 //#endregion
-//#region ../src/check/utils/view_fields.ts
-/**
-* Whether the named struct (or any value struct embedded in its fields,
-* recursively) declares a `view T` field. A struct with view fields carries
-* non-mv borrows inside its bytes, which drives the borrow rules:
-* copies are sound (a pair copy aliases nothing owned), but escapes
-* (returning, outer-scope assignment) are checked against where those
-* borrows were taken.
-*/
-function struct_has_view_fields(type_name, status) {
-	if (!type_name) return false;
-	const struct = status.structs.find((s) => s.name === type_name && !s.is_simple_type);
-	return !!struct && has_view_fields(struct, status, /* @__PURE__ */ new Set());
-}
-function has_view_fields(struct, status, visited) {
-	if (visited.has(struct.name)) return false;
-	visited.add(struct.name);
-	for (const field of struct.fields) {
-		if (field.type.is_view) return true;
-		if (field.type.is_ref || field.type.is_array) continue;
-		const field_struct = status.structs.find((s) => s.name === field.type.name && !s.is_simple_type && !s.is_class);
-		if (field_struct && has_view_fields(field_struct, status, visited)) return true;
-	}
-	return false;
-}
-/**
-* The root variable an access chain bottoms out at (`line.text` → "line",
-* `a.b.c` → "a", bare `x` → "x"). Returns undefined when the chain does not
-* bottom out in a plain name (e.g. a call receiver).
-*/
-function root_var_of(node) {
-	if (node.node_type === "value") {
-		const name = node.value;
-		return name === "null" ? void 0 : name;
-	}
-	if (node.node_type === "access") return root_var_of(node.target);
-}
-/**
-* Where a view value stored into a field borrows from.
-*
-*  - A `.slice()`-style view expression: borrow_depth/borrow_owner give the
-*    scope depth and owner variable (the slice's receiver).
-*  - A bare variable of owned type (`view string f = doc`): borrowing it is
-*    the identity on fat strings, but it creates a real dependency — record
-*    the source's own declaration depth and name so reassignment of the
-*    source invalidates the field.
-*  - A literal / const: static storage that outlives everything — no borrow.
-*
-* Returns undefined for sources that impose no dependency.
-*/
-function view_source_borrow_info(node, status) {
-	if (node.node_type === "value" && node.value.startsWith("\"")) return void 0;
-	const depth = borrow_depth_of(node, status);
-	const owner = borrow_owner_of(node, status);
-	if (depth !== void 0 || owner !== void 0) return {
-		depth: depth ?? status.scope_depth,
-		owner
-	};
-	if (node.node_type === "value") {
-		const decl = status.values.findLast((v) => v.name === node.value);
-		if (decl && !decl.is_null) return {
-			depth: decl.decl_depth ?? 0,
-			owner: decl.name
-		};
-		const alloc = status.allocations.findLast((d) => d.name === node.value);
-		if (alloc?.value) return view_source_borrow_info(alloc.value, status);
-	}
-}
-/**
-* Borrow info contributed by a constructor call's `view T` arguments (e.g.
-* `Line(doc.slice(0, 5), 0, 5)`): merges every view-typed argument's borrow
-* into one entry per distinct owner (the tightest depth wins). Returns
-* undefined when the call passes no dependent views.
-*/
-function ctor_call_view_borrow(call, status) {
-	const indices = call.view_param_indices ?? [];
-	let merged;
-	for (const i of indices) {
-		let arg = call.params[i];
-		if (!arg) continue;
-		if (arg.node_type === "value") {
-			const name = arg.value;
-			const hoisted = call.allocations?.findLast((d) => d.name === name) ?? status.allocations.findLast((d) => d.name === name);
-			if (hoisted?.value) arg = hoisted.value;
-		}
-		const info = view_source_borrow_info(arg, status);
-		if (!info) continue;
-		if (!merged) merged = /* @__PURE__ */ new Map();
-		merge_borrow_info(merged, info);
-	}
-	return merged;
-}
-/** Fold one borrow into the per-owner map, keeping the tightest depth. */
-function merge_borrow_info(map, info) {
-	const key = info.owner ?? "";
-	const existing = map.get(key);
-	if (!existing) {
-		map.set(key, { ...info });
-		return;
-	}
-	if (info.depth !== void 0 && (existing.depth === void 0 || info.depth < existing.depth)) existing.depth = info.depth;
-}
-/**
-* Record that view values were stored into fields of the struct variable
-* `root`: the instance now carries borrows rooted at each owner with the
-* given scope depths. Depth tracking keeps the tightest (deepest-rooted)
-* borrow so escape checks stay conservative across multiple fields. Also
-* clears any stale invalidation for the root — the fresh store re-points a
-* field (approximation: any view-field store refreshes the whole instance).
-*/
-function merge_view_borrows_into_var(root, infos, status) {
-	if (!root || !infos || infos.size === 0) return;
-	const sv = status.values.findLast((v) => v.name === root);
-	if (!sv) return;
-	sv.has_view_borrows = true;
-	if (!sv.view_field_owners) sv.view_field_owners = /* @__PURE__ */ new Set();
-	for (const [owner, info] of infos) {
-		if (owner) sv.view_field_owners.add(owner);
-		if (info.depth !== void 0) sv.borrow_depth = sv.borrow_depth === void 0 ? info.depth : Math.min(sv.borrow_depth, info.depth);
-	}
-	status.invalidated_view_structs?.delete(root);
-}
-/**
-* Propagate view-field borrow state when a struct value is copied
-* (`b = a`, `var Line b = a`): the copy aliases the same sources, so it
-* depends on exactly the same owners and inherits the tightest depth.
-*/
-function propagate_view_borrows(target, source) {
-	if (!source.has_view_borrows) return;
-	target.has_view_borrows = true;
-	if (source.view_field_owners?.size) {
-		if (!target.view_field_owners) target.view_field_owners = /* @__PURE__ */ new Set();
-		for (const owner of source.view_field_owners) target.view_field_owners.add(owner);
-	}
-	if (source.borrow_depth !== void 0 && (target.borrow_depth === void 0 || source.borrow_depth < target.borrow_depth)) target.borrow_depth = source.borrow_depth;
-}
-/**
-* Whether every recorded view-field borrow of the value roots at `self`
-* (the receiver) — the same re-rooting convention that lets a `slice`
-* method return its view: the caller re-roots the borrow at the call-site
-* receiver.
-*/
-function view_borrows_root_at_self(sv) {
-	const owners = sv.view_field_owners;
-	return !!owners?.size && [...owners].every((o) => o === "self");
-}
-/**
-* Whether a value of this type can carry a non-mv view borrow: the type
-* itself is a `view`, a `ref` (a borrow by definition — keep the existing
-* taint), a struct declaring (transitively) `view T` fields, or a generic
-* instantiation with such an argument. Anything else (primitives, owned
-* strings, containers of owned values) owns its storage outright, so a call
-* producing it does not propagate its view arguments' borrows — tainting it
-* is a false positive (e.g. returning `slice_string(view)` from a function
-* returning owned `string`). Callers pass an unset/unknown type through as
-* carrying, preserving today's behavior where nothing is known.
-*/
-function type_can_carry_view_borrow(type, status) {
-	if (!type || !type.name) return true;
-	if (type.is_view || type.is_ref) return true;
-	if (struct_has_view_fields(type.name, status)) return true;
-	return (type.type_args ?? []).some((t) => type_can_carry_view_borrow(t, status));
-}
-/**
-* Whether reading view fields of `root` is currently rejected because their
-* source was mutated (reassigned / ref-mutated).
-*/
-function view_fields_invalidated(root, status) {
-	if (!root) return false;
-	return !!status.invalidated_view_structs?.has(root);
-}
-//#endregion
 //#region ../src/check/check_declaration_node.ts
 /**
 * Record the may-be-null state of a freshly-declared struct's nullable
@@ -56563,9 +57812,16 @@ function check_declaration_node(decl, status) {
 		if (!is_view_keyword && !declared_type_is_view && decl.type.is_view && decl.value) add_error(status, `binding a view requires the 'view' keyword (e.g. 'view name = ...' or 'var view name = ...')`, decl.value.start);
 		const ref_src = is_ref_keyword ? ref_alias_source_name(decl.value) : void 0;
 		if (is_ref_keyword) {
-			if (decl.type.name && !is_class_type$1(decl.type.name, status)) add_error(status, `'ref' binds an alias to a heap-resident instance (a Box<T>); use 'view' for a slice of '${decl.type.name}'`, decl.start);
-			if (decl.value && !ref_src && decl.value.node_type === "value") add_error(status, `'ref' requires an existing binding to alias, got an owned value`, decl.value.start);
-			if (decl.value && !ref_src && decl.value.node_type !== "value") add_error(status, `'ref' requires an existing binding to alias, got an owned value`, decl.value.start);
+			const slot_load = element_slot_load(decl.value, status);
+			if (slot_load) {
+				slot_load.name = "slot_ptr";
+				slot_load.params = [slot_load.params[0]];
+				slot_load.is_element_slot_load = true;
+			} else {
+				if (decl.type.name && !is_class_type$1(decl.type.name, status)) add_error(status, `'ref' binds an alias to a heap-resident instance (a Box<T>); use 'view' for a slice of '${decl.type.name}'`, decl.start);
+				if (decl.value && !ref_src && decl.value.node_type === "value") add_error(status, `'ref' requires an existing binding to alias, got an owned value`, decl.value.start);
+				if (decl.value && !ref_src && decl.value.node_type !== "value") add_error(status, `'ref' requires an existing binding to alias, got an owned value`, decl.value.start);
+			}
 			if (decl.value && decl.value.is_moved) add_error(status, `'ref' binds an alias — 'mv' cannot transfer through it`, decl.value.start);
 		}
 		if (declaration === "mv" && !decl.swap && decl.value?.node_type === "value" && !decl.value.is_moved) decl.value.is_moved = true;
@@ -56592,7 +57848,10 @@ function check_declaration_node(decl, status) {
 				if (!decl.value.is_moved && !temp_rhs) add_error(status, `cannot copy '${field_type.name}' out of field '${field_name}' by value — it owns heap resources; use 'mv ... swap <replacement>'${field_type.name === "string" ? ", or .copy() for a deep copy" : ""}`, decl.value.start);
 				else if (!decl.swap) {
 					if (!access_field.destructure_move && !temp_rhs) add_error(status, `mv out of a field requires a swap to revalidate it`, decl.value.start);
-					else {
+					else if (temp_rhs && access_field.destructure_move && field_type.name === "string" && !field_type.is_array && !field_type.is_view) {
+						decl.value.is_moved = void 0;
+						access_field.destructure_move = void 0;
+					} else {
 						decl.value.is_moved = true;
 						decl.swap = synthesized_swap_value(field_type, decl.value.start);
 						if (check_node(decl.swap, status)) check_type_and_value_match(field_type, type_from_value_node(decl.swap, status), void 0, status, decl.swap.start, "swap");
@@ -56803,6 +58062,23 @@ function ref_alias_source_name(value) {
 		return value_from_value_node(value) || void 0;
 	}
 }
+/**
+* The ELEMENT BORROW shape (docs/HANDLERS.md Stage 4): a ref-binding
+* initializer that is `container.at(i)` — a container element read whose
+* container exposes the `slot_ptr` primitive (the `List<T>` mono). Returns
+* the inner AccessFunctionCallNode to rewrite, or undefined when the
+* initializer isn't an element load.
+*/
+function element_slot_load(value, status) {
+	if (!value || value.node_type !== "access") return void 0;
+	const access = value;
+	if (access.access.node_type !== "access_func") return void 0;
+	const call = access.access;
+	if (call.name !== "at" || call.params.length !== 1) return void 0;
+	const target_type = type_from_value_node(access.target, status);
+	if (!status.structs.find((s) => s.name === target_type.name || s.name === mono_type_name(target_type))?.functions.some((f) => f.name === "slot_ptr")) return void 0;
+	return call;
+}
 //#endregion
 //#region ../src/check/utils/check_init_fields.ts
 const checked_structs = /* @__PURE__ */ new WeakSet();
@@ -57563,6 +58839,28 @@ function struct_copy_ctor_args(struct) {
 	if (!auto) return null;
 	return auto.params.filter((p) => !p.is_self_param).map((p) => p.name);
 }
+/**
+* The element type args of a mv-container type (`List<T>` / `Buffer<T>` /
+* `Set<T>` / `Map<K,V>`), in either spelling: the generic annotation
+* (`Map<string, int>` — type_args on the type, the shape seen by the derive
+* pre-pass which runs before per-field mono rewriting) or the monomorphized
+* name (`Map_string_int` — the registered mono carries the flattened args).
+* Undefined for non-container types.
+*/
+function container_element_args(type, status) {
+	if (!type.name || type.is_array || type.is_ref || type.is_view || type.is_nullable) return;
+	if (type.type_args?.length) {
+		if ([
+			"List",
+			"Buffer",
+			"Set",
+			"Map"
+		].includes(type.name)) return type.type_args;
+		return;
+	}
+	const mono = status.structs.find((s) => s.name === type.name && !s.is_generic);
+	if (mono && is_load_deep_copy_container(mono.name) && mono.source_type_args?.length) return mono.source_type_args;
+}
 /** 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 mv store contract), or
@@ -57575,6 +58873,8 @@ function field_copyable(type, status, visited) {
 	if (visited?.has(type.name)) return false;
 	if (is_box_type(type.name, status.structs)) return false;
 	if (type.name === "List" && type.type_args?.length === 1) return element_copyable(type.type_args[0], status);
+	const elem_args = container_element_args(type, status);
+	if (elem_args) return elem_args.every((arg) => element_copyable(arg, status));
 	const nested_struct = status.structs.find((s) => s.name === type.name);
 	if (nested_struct) {
 		if (nested_struct.is_simple_type) return true;
@@ -57593,6 +58893,8 @@ 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 elem_args = container_element_args(type, status);
+	if (elem_args) return elem_args.every((arg) => element_copyable(arg, status));
 	const nested = status.structs.find((s) => s.name === type.name);
 	if (nested) {
 		if (nested.is_simple_type) return true;
@@ -57609,6 +58911,8 @@ function element_copyable(type, status) {
 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 elem_args = container_element_args(type, status);
+	if (elem_args) return elem_args.every((arg) => element_copyable(arg, 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);
 }
@@ -58139,7 +59443,7 @@ function check_function_parameter_node(param, status, is_library_scope = false)
 	}
 	if (status.values.some((v) => v.name === param.name && v.declaration !== "const" && !(is_library_scope && v.is_global))) add_error(status, `Parameter already declared: ${param.name}`, param.start);
 	status.values.push({
-		declaration: param.declaration === "var" || is_pass_by_value_owning_struct(param.type, status) ? "var" : param.declaration,
+		declaration: param.declaration === "var" || param.is_variadic || is_pass_by_value_owning_struct(param.type, status) ? "var" : param.declaration,
 		name: param.name,
 		type: param.type,
 		is_set: true,
@@ -58272,6 +59576,8 @@ function check_function_node(func, status) {
 		}
 		if (func.return_type.name && !foreign_supported_type(func.return_type)) add_error(status, `foreign return type '${func.return_type.name}' is unsupported (scalars and string only)`, func.return_type_start ?? func.start);
 	}
+	const mixed_body = find_use_c_mixed_body(func);
+	if (mixed_body) add_error(status, mixed_body.dropped === "statement" ? `Function '${func.name}' mixes '#arch: aarch64_use_c' blocks with Nomen statements — the aarch64 backend replaces the whole body with the raw blocks and would drop the statements` : mixed_body.dropped === "raw asm" ? `Function '${func.name}' mixes '#arch: aarch64_use_c' blocks with inline raw code — the aarch64 backend replaces the whole body with the raw blocks and would drop the assembly` : `Function '${func.name}' has a '#arch: aarch64_use_c' block nested inside control flow — the aarch64 backend emits the body as assembly and silently drops block-scope C; move the block into its own aarch64_use_c function and pass values as parameters`, mixed_body.start);
 	if (is_generic_func(func)) {
 		func.is_generic = true;
 		return;
@@ -58294,6 +59600,10 @@ function check_function_node(func, status) {
 			if (func.return_type.is_pointer && !func.is_library) add_error(function_status, `'ptr' return types are reserved for the System library — raw pointer manipulation is not available to user code`, func.return_type_start ?? func.start);
 		}
 		instantiate_generic_type(func.return_type, function_status);
+		if (func.name !== "#init" && !func.return_type.is_view && !func.return_type.is_ref && struct_has_view_fields(func.return_type.name, function_status)) {
+			add_error(function_status, `cannot return a '${func.return_type.name}' — structs with 'view' fields are scope-local; return the fields (the views) instead`, func.return_type_start ?? func.start);
+			func.view_bundle_return_rejected = true;
+		}
 	}
 	if (func.is_foreign) return;
 	check_block_node(func, function_status);
@@ -58524,6 +59834,8 @@ function synthesize_lambda_name(func, status) {
 */
 function validate_spawn_args_sendable(call, status, reason) {
 	const callee_params = call.resolved_function?.params?.filter((p) => !p.is_self_param);
+	const callee_name = call.resolved_function?.name;
+	const task_label = callee_name ? `the '${callee_name}' spawn` : "a spawn";
 	for (let i = 0; i < call.params.length; i++) {
 		const param = call.params[i];
 		let arg_type = type_from_value_node(param, status);
@@ -58536,7 +59848,7 @@ function validate_spawn_args_sendable(call, status, reason) {
 			if (status.structs.find((st_) => st_.name === arg_type.name && !st_.is_class && !st_.is_simple_type)) {
 				if (!call.region_borrowed_args) call.region_borrowed_args = [];
 				if (!call.region_borrowed_args.includes(i)) call.region_borrowed_args.push(i);
-				enforce_spawn_arg_region(param, arg_type, status, true);
+				enforce_spawn_arg_region(param, arg_type, status, true, task_label);
 				continue;
 			}
 		}
@@ -58550,15 +59862,15 @@ function validate_spawn_args_sendable(call, status, reason) {
 			}
 			if (!call.region_borrowed_args) call.region_borrowed_args = [];
 			if (!call.region_borrowed_args.includes(i)) call.region_borrowed_args.push(i);
-			if (inside_nursery) enforce_spawn_arg_region(param, arg_type, status);
+			if (inside_nursery) enforce_spawn_arg_region(param, arg_type, status, false, task_label);
 			continue;
 		}
 		if (inside_nursery && arg_type.is_view && !arg_type.is_array) {
-			enforce_spawn_arg_region(param, arg_type, status);
+			enforce_spawn_arg_region(param, arg_type, status, false, task_label);
 			continue;
 		}
 		if (is_sendable_type(arg_type.name, status)) {
-			enforce_spawn_arg_region(param, arg_type, status);
+			enforce_spawn_arg_region(param, arg_type, status, false, task_label);
 			continue;
 		}
 		add_error(status, `Spawn argument of type ${arg_type.name || "<unknown>"} is not Sendable${reason ?? " — a shared class/trait reference crossing a task boundary must be marked Sendable; mv it in (a `mv` parameter), share it as a checked region borrow inside an 'async' block, or mediate it through Mutex/Channel/Atomic<T>"}`, param.start);
@@ -58822,14 +60134,21 @@ function monomorphize(generic_struct, type_args, status) {
 	const mono_struct = new StructNode(generic_struct.start, generic_struct.visibility, mono_name, generic_struct.traits, mono_fields, []);
 	mono_struct.source_type_args = flat_args;
 	mono_struct.is_class = generic_struct.is_class;
-	mono_struct.is_owning = generic_struct.is_owning || mono_fields.some((f) => type_owns_heap(f.type, status));
+	const derived_owning = mono_fields.some((f) => type_owns_heap(f.type, status));
+	mono_struct.is_owning = generic_struct.is_owning || derived_owning;
+	if (derived_owning && !generic_struct.is_owning && !generic_struct.is_class) {
+		const param_list = generic_struct.type_params.join(", ");
+		add_error(status, `'${generic_struct.name}<${param_list}>' instantiates to an owning type — a substituted field owns heap memory --> mark the generic \`mv struct ${generic_struct.name}<${param_list}>\``, generic_struct.start);
+	}
 	mono_struct.is_library = generic_struct.is_library;
 	mono_struct.trait_args = (generic_struct.trait_args ?? []).map((args) => args?.map((t) => substitute_type(t, substitution)));
 	status.structs.push(mono_struct);
 	status.types.push(mono_name);
 	const cloned_methods = [];
+	const has_ref_type_arg = (generic_struct.name === "Map" || generic_struct.name === "Set") && flat_args.some((arg) => status.traits.some((tr) => tr.name === arg.name) || status.structs.some((s) => s.name === arg.name && s.is_class));
 	for (const func of generic_struct.functions) {
 		if (func.name === "#init") continue;
+		if (func.name === "copy" && has_ref_type_arg) continue;
 		const cloned = clone_node(func);
 		substitute_raw_types(cloned, substitution, status.structs, status.traits, {
 			enums: status.enums,
@@ -61097,6 +62416,7 @@ function check_function_call(node, status, func, target_type, self_value, self_p
 			if ((func_param.type.name ? status.structs.find((st) => st.name === func_param.type.name && !st.is_class && !st.is_simple_type) : void 0) || func_param.type.name === "string") param.type = func_param.type;
 		}
 		const param_type = type_from_value_node(param, status);
+		if (param_type && !param_type.is_view && !param_type.is_ref && param_type.name && struct_has_view_fields(param_type.name, status)) add_error(status, `cannot pass a '${param_type.name}' as an argument — structs with 'view' fields are scope-local; pass the fields (the views) instead`, param.start);
 		const param_value = value_from_value_node(param);
 		const has_ref_keyword = node.ref_param_indices?.includes(i) ?? false;
 		if (has_ref_keyword && param.node_type === "value") invalidate_token_facts(param.value, status);
@@ -61161,14 +62481,12 @@ function check_function_call(node, status, func, target_type, self_value, self_p
 			} else if (!!func_param && !!status.traits.find((t) => t.name === func_param.type.name) && func_param.is_moved && is_value_struct_conformer(field_type.name, func_param.type.name, status)) add_error(status, `boxing owns its instance — mv the value, or copy it ('.copy()')`, param.start);
 		}
 		if (func_param.is_moved && !has_mov_keyword && !node.swap_params?.has(i) && param_is_owning_struct && param.node_type === "access" && param.access.node_type === "access_field") {
-			const read_root = param.target;
-			const root_name = read_root.node_type === "value" ? read_root.value : void 0;
-			if (!(read_root.node_type === "access" && read_root.access.node_type === "access_func" || !!root_name && (root_name.startsWith("_recv_") || root_name.startsWith("_tuple_dst_")))) {
-				const field_name = param.access.name;
-				add_error(status, `cannot copy field '${field_name}' into parameter '${func_param.name}' by value — it owns heap resources; use 'mv ... swap <replacement>' or .copy()`, param.start);
-			}
+			const field_name = param.access.name;
+			add_error(status, `cannot copy field '${field_name}' into parameter '${func_param.name}' by value — it owns heap resources; use 'mv ... swap <replacement>' or .copy()`, param.start);
 		}
-		if (func_param.is_moved && !node.swap_params?.has(i) && func_param.type.name && is_owning_ref_type(func_param.type.name, status)) {
+		const param_struct = func_param.type.name ? status.structs.find((s) => s.name === func_param.type.name && !s.is_simple_type && !s.is_generic) : void 0;
+		const param_takes_ownership = func_param.type.name && is_owning_ref_type(func_param.type.name, status) || !!param_struct && !param_struct.is_class && param_struct.is_owning === true;
+		if (func_param.is_moved && !node.swap_params?.has(i) && param_takes_ownership) {
 			if (borrow_depth_of(param, status) !== void 0) add_error(status, `Cannot mv a borrowed value into mv parameter '${func_param.name}' — it would create shared ownership (the destination frees the pointer on destroy, leaving the borrow's source dangling). Pass an owned value: a fresh constructor, an owned local, or a 'mv out T' accessor result (e.g. .pop() or items.move_T(i)).`, param.start);
 		}
 		const swap_expr = node.swap_params?.get(i);
@@ -61410,8 +62728,7 @@ function check_function_call(node, status, func, target_type, self_value, self_p
 		if (param.node_type === "access" && maybe_mark_borrow_to_string_arg(param, func_param, func, i, node, status)) continue;
 		const callee_param_is_trait = !!func_param && !!status.traits.find((t) => t.name === func_param.type.name);
 		if (callee_param_is_trait && !func_param.type.is_array && is_value_struct_conformer(param_type.name, func_param.type.name, status)) {
-			if (func_param.type.is_ref) add_error(status, `a 'ref ${func_param.type.name}' parameter cannot take value struct '${param_type.name}' — boxing owns its instance — mv the value, or copy it ('.copy()')`, param.start);
-			else if (func_param.is_moved) {
+			if (func_param.is_moved) {
 				if (!node.move_owned_param_indices) node.move_owned_param_indices = [];
 				if (!node.move_owned_param_indices.includes(i)) node.move_owned_param_indices.push(i);
 			}
@@ -61635,6 +62952,516 @@ function is_library_regex_func(func, status) {
 	return !!regex_struct && regex_struct.functions.includes(func);
 }
 //#endregion
+//#region ../src/check/utils/handlers.ts
+/**
+* Handler registrations: `.on_<event>(closure)` desugars into owner-dispatched
+* methods (docs/HANDLERS.md, Stage 1 — the root desugar).
+*
+* `self.<field>.on_click(func () { ... })` on a control receiver is
+* checker-interpreted (the name-keyed precedent is the Fiber.start_on
+* rewrite): no code executes at the site. The closure body is HOISTED into a
+* hidden method on the enclosing struct — `#on_click_N = (ref self, ref
+* Window win) { body }` — an ordinary method both backends already lower, and
+* the registration checks into a dispatch ARM appended to the host's
+* synthesized `handle_events` method:
+*
+* ```
+* func handle_events = (ref self, ref Window win) {
+* 	nomen_window_clicks_init(self.<field>.handle)
+* 	if self.<field>.take_click() { self.#on_click_N(ref win) }
+* }
+* ```
+*
+* `App` declares a default-empty `handle_events`; `Window.run` calls
+* `app.handle_events(ref win)` before `frame`, so the borrow of `self` is
+* taken by the dispatcher at dispatch time — the closure captures nothing
+* (HANDLERS.md, "The insight"). The arm's handle expression re-evaluates the
+* remembered field path against final fields each frame; nothing is captured,
+* so there is no staleness.
+*
+* Checker rules (one clear error each, HANDLERS.md "Checker rules"):
+*  - the receiver must be a `self`-rooted field path (the arm re-evaluates
+*    it, so a local receiver has nothing to re-evaluate);
+*  - the closure takes no parameters (v1);
+*  - no upvalue captures — the hoisted method has no env;
+*  - host reachability — dispatch reaches hosts through static field paths
+*    from the run root, so the enclosing struct must conform to `App` or be
+*    a (transitive) field of one (library composites are trusted).
+*/
+/** The reserved member-name family on control receivers (HANDLERS.md). */
+const HANDLER_EVENT = /^on_[a-z][a-z0-9_]*$/;
+/** The one pump slot's name on handler hosts. */
+const PUMP_NAME = "handle_events";
+/**
+* Per-check synthesis state, keyed by the host struct (one pump per host).
+* Module-level (not on CheckStatus) because `clone_status` copies a fixed
+* field list — state recorded inside a branch clone (a registration nested
+* in an `if`) must survive the clone's discard. The per-check entry in
+* `pending_pumps` dies with the check that created it: `finalize` deletes by
+* root identity, and an aborted compile (parse errors, no check pass) never
+* creates an entry.
+*/
+const dispatcher_states = /* @__PURE__ */ new WeakMap();
+/** Hosts whose pump awaits its final check, per compile root. */
+const pending_hosts = /* @__PURE__ */ new Map();
+/** Per-app up-call synthesis state (see host_states for why module-level). */
+const run_handler_states = /* @__PURE__ */ new WeakMap();
+/** Apps whose synthesized `run_handler` awaits its check (see pending_hosts). */
+const pending_run_handlers = /* @__PURE__ */ new Map();
+/** Per-app tick-forward state (see host_states for why module-level). */
+const tick_states = /* @__PURE__ */ new WeakMap();
+/** Apps whose pump awaits its synthesized tick forwards (see pending_hosts). */
+const pending_tick_apps = /* @__PURE__ */ new Map();
+/**
+* The `.on_<event>(closure)` hook, called from check_access_function_node
+* BEFORE ordinary method resolution. Returns:
+*  - `undefined` — not a handler registration (name family or receiver does
+*    not match); the call resolves ordinarily;
+*  - `false` — a handler registration that failed a checker rule (an error
+*    has been added);
+*  - `true` — desugared: the site is stamped `is_handler_registration` (the
+*    backends emit nothing for it) and the arm is synthesized.
+*/
+function try_check_handler_registration(target_type, target, node, status) {
+	if (node.is_handler_enrollment) return void 0;
+	if (!HANDLER_EVENT.test(node.name)) return void 0;
+	const receiver = status.structs.find((s) => s.name === target_type.name);
+	if (!receiver) return void 0;
+	const fail = (message) => {
+		add_error(status, message, node.start);
+		return false;
+	};
+	const composite = try_check_composite_event(receiver, target_type, target, node, status, fail);
+	if (composite !== void 0) return composite;
+	return try_check_control_drain(receiver, target_type, target, node, status, fail);
+}
+/**
+* The control-carried event path (docs/HANDLERS.md, "Registered control
+* events"): the event comes from the CONTROL's own source (the click ring,
+* the window's first responder, the control's text), the synthesized arm
+* polls that source's drain primitive, and the hidden method hoists onto
+* the App conformer the way the click desugar does. Config comes from
+* and everything here is event-agnostic.
+*/
+function try_check_control_drain(receiver, target_type, target, node, status, fail) {
+	const drain = `take_${node.name.slice(3)}`;
+	if (!receiver.functions.some((f) => f.name === drain && f.params.length === 1)) return fail(`'${receiver.name}' doesn't emit ${node.name} events (no ${drain} drain)`);
+	if (node.params.length !== 1 || node.params[0].node_type !== "func") return fail(`.${node.name} expects one closure argument — .${node.name}(func () { ... })`);
+	const closure = node.params[0];
+	if (closure.params.length > 0) return fail("handler closures take no parameters — the body sees `self` and the dispatch `win`");
+	const fields = self_rooted_field_path(target);
+	if (!fields) return fail(`.${node.name} needs a self-rooted field receiver — store the control in a field and register from self.<field>.${node.name}(...): the dispatch arm re-evaluates the path, so a local receiver has nothing to re-evaluate`);
+	const host = status.stack.findLast((n) => n.node_type === "func")?.scope;
+	if (!host || host.node_type !== "struct") return fail(`.${node.name} registers a handler on the enclosing struct — it cannot appear outside one`);
+	if (!host.traits.includes("App") && !host.is_library && !reachable_from_an_app(host, status)) return fail(`handlers dispatch from the run root — '${host.name}' is not owned by the app`);
+	let state = dispatcher_states.get(host);
+	if (!state) {
+		if (host.functions.some((f) => f.name === PUMP_NAME)) return fail(`'${host.name}' already declares ${PUMP_NAME} — the .${node.name} desugar synthesizes it (the name is reserved on handler hosts)`);
+		const func = new FunctionNode(node.start, "pub", PUMP_NAME, new Type(""), [ref_self_param(host), win_param()]);
+		host.functions.push(func);
+		state = {
+			func,
+			next_index: /* @__PURE__ */ new Map()
+		};
+		dispatcher_states.set(host, state);
+		const root = status.stack[0];
+		let hosts = pending_hosts.get(root);
+		if (!hosts) {
+			hosts = [];
+			pending_hosts.set(root, hosts);
+		}
+		hosts.push(host);
+	}
+	let index_state = state.next_index.get(node.name);
+	if (index_state === void 0) index_state = 1;
+	else index_state += 1;
+	state.next_index.set(node.name, index_state);
+	const index = index_state;
+	const hidden = `#${node.name}_${index}`;
+	const hoisted = new FunctionNode(closure.start, "private", `#${node.name}_${index}`, new Type(""), [ref_self_param(host), win_param()], closure.statements);
+	host.functions.push(hoisted);
+	hoisted.is_closure = true;
+	check_function_node(hoisted, status);
+	const upvalues = hoisted.captures ?? [];
+	hoisted.is_closure = void 0;
+	hoisted.captures = void 0;
+	if (upvalues.length) return fail("handler closures see `self` and the dispatch `win` — copy what you need into fields");
+	state.func.statements.push(arm_dispatch_statement(host, fields, drain, hidden, node.start));
+	node.is_handler_registration = true;
+	node.type = new Type("");
+	return true;
+}
+/**
+* Composite event registration (docs/HANDLERS.md Stage 3 — id up-calls).
+* `self.<field>.on_<event>(closure)` on a composite host — a struct that
+* DECLARES the event API — enrolls the app handler for the composite's
+* up-call:
+*
+*  - the closure hoists into a hidden method on the app —
+*    `#on_<event>_N = (ref self, ref Window win) { body }`;
+*  - the app's synthesized `run_handler` gains the dispatch arm
+*    `if id == N { self.#on_<event>_N(ref win) }` — the concrete method the
+*    composite's `owner.run_handler(id, ref win)` callback hops into;
+*  - the registration site REWRITES to the enrollment call
+*    `receiver.on_<event>(N)` — the composite's own declared API stores the
+*    id (the one thing tier 2 stores: an int, never a handler);
+*  - the app's dispatch pump gains the per-frame owner forward
+*    `self.<fields>.tick(ref self, ref win)` at finalize — registration is
+*    register-and-forget, the app never writes the forwarding call.
+*
+* The composite opts in by declaration: the event exists when the receiver
+* declares `func on_<event> = (ref self, int id)`. Without it the name
+* resolves ordinarily ("Function not found") — the family is not reserved
+* on composites, only on controls.
+*
+* The closure rules match the click desugar (no parameters, no upvalue
+* captures, self-rooted field receiver), and the enclosing host must be the
+* App conformer — the up-call dispatches through the app's `run_handler`.
+* Returns undefined when this isn't a declared composite event.
+*/
+function try_check_composite_event(receiver, target_type, target, node, status, fail) {
+	if (!receiver.functions.find((f) => f.name === node.name && f.params.length === 2 && f.params[0].is_self_param && !f.params[1].is_self_param && f.params[1].type.name === "int" && !f.params[1].type.is_ref)) return void 0;
+	if (node.params.length !== 1 || node.params[0].node_type !== "func") return fail(`.${node.name} expects one closure argument — .${node.name}(func () { ... })`);
+	const closure = node.params[0];
+	if (closure.params.length > 0) return fail("handler closures take no parameters — the body sees `self` and the dispatch `win`");
+	const fields = self_rooted_field_path(target);
+	if (!fields) return fail(`.${node.name} needs a self-rooted field receiver — store the composite in a field and register from self.<field>.${node.name}(...)`);
+	const host = status.stack.findLast((n) => n.node_type === "func")?.scope;
+	if (!host || host.node_type !== "struct") return fail(`.${node.name} registers a handler on the enclosing struct — it cannot appear outside one`);
+	if (!host.traits.includes("App")) return fail(`up-call handlers dispatch through the app's run_handler — register .${node.name} from the app, not from '${host.name}'`);
+	if (host.functions.some((f) => f.name === "run_handler")) return fail(`'${host.name}' already declares run_handler — the .${node.name} desugar synthesizes it (the name is reserved on the app)`);
+	const root = status.stack[0];
+	let state = run_handler_states.get(host);
+	if (!state) {
+		const run_handler = new FunctionNode(node.start, "pub", "run_handler", new Type(""), [
+			ref_self_param(host),
+			new ParameterNode(node.start, "id", new Type("int")),
+			win_param()
+		]);
+		host.functions.push(run_handler);
+		state = {
+			run_handler,
+			next_id: 1
+		};
+		run_handler_states.set(host, state);
+		let apps = pending_run_handlers.get(root);
+		if (!apps) {
+			apps = [];
+			pending_run_handlers.set(root, apps);
+		}
+		apps.push(host);
+	}
+	const id = state.next_id++;
+	const hoisted = new FunctionNode(closure.start, "private", `#up_${node.name}_${id}`, new Type(""), [ref_self_param(host), win_param()], closure.statements);
+	host.functions.push(hoisted);
+	hoisted.is_closure = true;
+	check_function_node(hoisted, status);
+	const upvalues = hoisted.captures ?? [];
+	hoisted.is_closure = void 0;
+	hoisted.captures = void 0;
+	if (upvalues.length) return fail("handler closures see `self` and the dispatch `win` — copy what you need into fields");
+	state.run_handler.statements.push(up_call_arm(host, node.name, id, node.start));
+	let ticks = tick_states.get(host);
+	if (!ticks) {
+		ticks = {
+			entries: [],
+			seen: /* @__PURE__ */ new Set()
+		};
+		tick_states.set(host, ticks);
+		const tick_root = status.stack[0];
+		let apps = pending_tick_apps.get(tick_root);
+		if (!apps) {
+			apps = [];
+			pending_tick_apps.set(tick_root, apps);
+		}
+		apps.push(host);
+	}
+	const path_key = fields.join(".");
+	if (!ticks.seen.has(path_key)) {
+		ticks.seen.add(path_key);
+		ticks.entries.push({
+			fields,
+			composite: receiver
+		});
+	}
+	node.is_handler_enrollment = true;
+	node.params = [new ValueNode(node.start, String(id), new Type("int"))];
+	return check_access_function_node(target_type, target, node, status);
+}
+/**
+* `if id == N { self.#on_<event>_N(ref win) }` — one arm of the
+* synthesized `run_handler`.
+*/
+function up_call_arm(host, event, id, start) {
+	const condition = new OperationNode(start, "==", new ValueNode(start, "id", new Type("int")), new ValueNode(start, String(id), new Type("int")));
+	const dispatch = new AccessFunctionCallNode(start, `#up_${event}_${id}`);
+	dispatch.ref_param_indices = [0];
+	dispatch.params = [new ValueNode(start, "win")];
+	return new IfElseNode(start, condition, new BranchNode(start, [new AccessNode(start, new ValueNode(start, "self", new Type(host.name)), dispatch)]));
+}
+/**
+* Check every host's synthesized `handle_events`, after first synthesizing
+* the FORWARDING wiring (Stage 2, HANDLERS.md "Handler hosts beyond the
+* root"): a struct with registrations is a handler host — not just the App.
+* Dispatch reaches non-root hosts down static field paths: every struct on a
+* path from an App conformer to a host gets a `handle_events` (its own arms
+* if it registers, pure forwarding if it doesn't) that forwards to each
+* host-reaching field — `self.<field>.handle_events(ref win)` — direct
+* calls, no trait objects. Dispatch order is children-first, then own arms
+* (most specific first, HANDLERS.md "user-authored composites").
+*
+* Runs once, after the whole tree has been checked: the arms reference the
+* hidden `#on_click_N` methods (checked at their registration sites), the
+* drain methods (`take_click` et al) and the `Window` type are resolved, and
+* the full field graph (gathered upfront) decides reachability. Checking the
+* bodies also stamps every node for the build.
+*/
+function finalize_handler_hosts(status) {
+	const root = status.stack[0];
+	const hosts = pending_hosts.get(root);
+	const up_call_apps = pending_run_handlers.get(root);
+	const tick_apps = pending_tick_apps.get(root);
+	if (!hosts && !up_call_apps && !tick_apps) return;
+	pending_hosts.delete(root);
+	pending_tick_apps.delete(root);
+	const host_set = new Set(hosts ?? []);
+	const to_check = [];
+	for (const host of hosts ?? []) {
+		const state = dispatcher_states.get(host);
+		if (state) to_check.push(state.func);
+	}
+	const reaches_memo = /* @__PURE__ */ new Map();
+	const reaches_host = (s, stack) => {
+		if (host_set.has(s)) return true;
+		const memo = reaches_memo.get(s);
+		if (memo !== void 0) return memo;
+		if (stack.has(s)) return false;
+		stack.add(s);
+		let result = false;
+		for (const field of s.fields) {
+			for (const t of reachable_field_targets(field, status)) if (reaches_host(t, stack)) {
+				result = true;
+				break;
+			}
+			if (result) break;
+		}
+		stack.delete(s);
+		reaches_memo.set(s, result);
+		return result;
+	};
+	for (const s of status.structs) {
+		const forwards = [];
+		for (const f of s.fields) {
+			const t = forwardable_field_type(f, status);
+			if (t && reaches_host(t, /* @__PURE__ */ new Set())) forwards.push(forward_statement(s, f.name));
+		}
+		for (const f of s.fields) {
+			const elem = forwardable_list_element(f, status);
+			if (elem && reaches_host(elem, /* @__PURE__ */ new Set())) forwards.push(...list_forward_loop(s, f.name, elem, status));
+		}
+		if (forwards.length === 0) continue;
+		const is_app = s.traits.includes("App");
+		const is_host = host_set.has(s);
+		if (!is_app && !is_host && !reachable_from_an_app(s, status)) continue;
+		let state = dispatcher_states.get(s);
+		if (!state) {
+			if (s.functions.some((f) => f.name === PUMP_NAME)) continue;
+			const pump = new FunctionNode(-1, "pub", PUMP_NAME, new Type(""), [ref_self_param(s), win_param()]);
+			s.functions.push(pump);
+			state = {
+				func: pump,
+				next_index: /* @__PURE__ */ new Map()
+			};
+			dispatcher_states.set(s, state);
+			to_check.push(pump);
+		}
+		state.func.statements.unshift(...forwards);
+	}
+	for (const app of tick_apps ?? []) {
+		const ticks = tick_states.get(app);
+		if (!ticks) continue;
+		let state = dispatcher_states.get(app);
+		if (!state) {
+			if (app.functions.some((f) => f.name === PUMP_NAME)) continue;
+			const pump = new FunctionNode(-1, "pub", PUMP_NAME, new Type(""), [ref_self_param(app), win_param()]);
+			app.functions.push(pump);
+			state = {
+				func: pump,
+				next_index: /* @__PURE__ */ new Map()
+			};
+			dispatcher_states.set(app, state);
+			to_check.push(pump);
+		}
+		for (const entry of ticks.entries) {
+			if (!entry.composite.functions.some((f) => f.name === "tick" && f.params.length === 3 && f.params[0].is_self_param)) continue;
+			const tick_call = new AccessFunctionCallNode(-1, "tick");
+			tick_call.ref_param_indices = [0, 1];
+			tick_call.params = [new ValueNode(-1, "self", new Type(app.name)), new ValueNode(-1, "win")];
+			state.func.statements.push(new AccessNode(-1, arm_receiver(app, entry.fields, -1), tick_call));
+		}
+	}
+	for (const hc of to_check) check_function_node(hc, status);
+	if (up_call_apps) {
+		pending_run_handlers.delete(root);
+		for (const app of up_call_apps) {
+			const state = run_handler_states.get(app);
+			if (!state) continue;
+			check_function_node(state.run_handler, status);
+		}
+	}
+}
+/**
+* The field types dispatch may FORWARD through: direct, owned, concrete
+* struct fields. Boxes/containers/monos/generics are element-dispatch
+* territory (B5, Stage 4) and stop the walk; nullable/borrowed/array fields
+* have no single static target.
+*/
+function forwardable_field_type(field, status) {
+	const type = field.type;
+	if (!type.name || type.is_ref || type.is_view || type.is_array || type.is_nullable) return;
+	if (is_box_type(type.name, status.structs)) return void 0;
+	const s = status.structs.find((st) => st.name === type.name);
+	if (!s) return void 0;
+	if (s.source_type_args?.length || s.type_params.length > 0) return void 0;
+	return s;
+}
+/**
+* The struct types a field makes REACHABLE for host-dispatch purposes: the
+* direct struct field target, plus (Stage 4) the element struct of a
+* `List<Row>` field — dynamic trees are dispatchable, so a composite type
+* hosted in a list is owned by the app exactly like a direct field.
+*/
+function reachable_field_targets(field, status) {
+	const targets = [];
+	const direct = forwardable_field_type(field, status);
+	if (direct) targets.push(direct);
+	const elem = forwardable_list_element(field, status);
+	if (elem) targets.push(elem);
+	return targets;
+}
+/** Whether some App conformer reaches `target` down forwardable field paths. */
+function reachable_from_an_app(target, status) {
+	for (const s of status.structs) {
+		if (!s.traits.includes("App")) continue;
+		if (path_exists(s, target, status, /* @__PURE__ */ new Set())) return true;
+	}
+	return false;
+}
+function path_exists(s, target, status, stack) {
+	if (s === target) return true;
+	if (stack.has(s)) return false;
+	stack.add(s);
+	for (const field of s.fields) for (const t of reachable_field_targets(field, status)) if (path_exists(t, target, status, stack)) return true;
+	stack.delete(s);
+	return false;
+}
+/** `self.<field>.handle_events(ref win)` — one hop down the ownership path. */
+function forward_statement(host, field) {
+	const receiver = new AccessNode(-1, new ValueNode(-1, "self", new Type(host.name)), new AccessFieldNode(-1, field));
+	const dispatch = new AccessFunctionCallNode(-1, "handle_events");
+	dispatch.ref_param_indices = [0];
+	dispatch.params = [new ValueNode(-1, "win")];
+	return new AccessNode(-1, receiver, dispatch);
+}
+/**
+* The element struct a `List<Row>` field dispatches to, when the field is a
+* forwardable dynamic tree (either spelling of the mono). Containers of
+* trait/erased elements stay B5 territory — concrete rows only.
+*/
+function forwardable_list_element(field, status) {
+	const t = field.type;
+	if (t.is_ref || t.is_view || t.is_array || t.is_nullable) return void 0;
+	let elem_name;
+	if (t.name === "List" && t.type_args?.length === 1) elem_name = t.type_args[0].name;
+	else if (t.name.startsWith("List_")) elem_name = status.structs.find((s) => s.name === t.name && s.source_type_args?.length)?.source_type_args?.[0]?.name;
+	if (!elem_name) return void 0;
+	return status.structs.find((s) => s.name === elem_name && !s.is_generic);
+}
+/**
+* The dynamic-tree dispatch body for one `List<Row>` field (docs/HANDLERS.md
+* Stage 4):
+*
+* ```
+* var int _rows_i_N = 0
+* while _rows_i_N < self.rows.length; _rows_i_N += 1 {
+* 	ref Row _row = self.rows.at(_rows_i_N)
+* 	_row.handle_events(ref win)
+* }
+* ```
+*
+* The element borrow binds the SLOT (the checker rewrites `.at` to
+* `slot_ptr`), so each row's own arms run in place — state persists across
+* frames. The bounded-loop condition discharges `.at`'s bounds for the
+* borrow, and any list mutation (`ref self` on the list) invalidates the
+* borrow through the ordinary rules.
+*/
+function list_forward_loop(host, field, elem, status) {
+	const start = -1;
+	const index = `_${field}_i_${status.var_name_counter.value++}`;
+	const index_value = () => new ValueNode(start, index, new Type("int"));
+	const list_access = () => new AccessNode(start, new ValueNode(start, "self", new Type(host.name)), new AccessFieldNode(start, field));
+	const declaration = new DeclarationNode(start, "private", "var", index, new Type("int"), new ValueNode(start, "0", new Type("int")));
+	const element_borrow = new DeclarationNode(start, "private", "ref", `_${field}_row`, new Type(elem.name), new AccessNode(start, list_access(), new AccessFunctionCallNode(start, "at", new Type(""), [index_value()])));
+	element_borrow.is_ref_binding = true;
+	const dispatch = new AccessFunctionCallNode(start, "handle_events");
+	dispatch.ref_param_indices = [0];
+	dispatch.params = [new ValueNode(start, "win")];
+	const call = new AccessNode(start, new ValueNode(start, `_${field}_row`, new Type(elem.name)), dispatch);
+	const condition = new OperationNode(start, "<", index_value(), new AccessNode(start, list_access(), new AccessFieldNode(start, "length")));
+	const update = new AssignmentNode(start, index_value(), new ValueNode(start, "1", new Type("int")), "+=");
+	return [declaration, new WhileLoopNode(start, condition, [element_borrow, call], update)];
+}
+/** `ref self` — the hoisted method's receiver (the host instance). */
+function ref_self_param(host) {
+	const param = new ParameterNode(-1, "self", new Type(host.name));
+	param.is_self_param = true;
+	param.is_ref = true;
+	param.declaration = "var";
+	return param;
+}
+/** `ref Window win` — the dispatch window, lent by the run loop per frame. */
+function win_param() {
+	const type = new Type("Window");
+	type.is_ref = true;
+	return new ParameterNode(-1, "win", type);
+}
+/**
+* The registration receiver's field path when it is `self`-rooted:
+* `self.add_btn` → `["add_btn"]`, `self.pager.prev` → `["pager", "prev"]`.
+* Undefined for any other shape (a bare local, a call result, …).
+*/
+function self_rooted_field_path(target) {
+	const fields = [];
+	let current = target;
+	while (current.node_type === "access") {
+		const access = current;
+		if (access.access.node_type !== "access_field") return void 0;
+		fields.unshift(access.access.name);
+		current = access.target;
+	}
+	if (current.node_type !== "value" || current.value !== "self") return;
+	if (fields.length === 0) return void 0;
+	return fields;
+}
+/** The receiver path re-emitted for the arm: `self.a.b` (handle expression). */
+function arm_receiver(host, fields, start) {
+	let receiver = new ValueNode(start, "self", new Type(host.name));
+	for (const field of fields) receiver = new AccessNode(start, receiver, new AccessFieldNode(start, field));
+	return receiver;
+}
+/**
+* `if <drain>(self.<path>.handle) { self.<hidden>(ref win) }` — one arm of
+* the synthesized dispatcher.
+*/
+function arm_dispatch_statement(host, fields, drain, hidden, start) {
+	const condition = new AccessFunctionCallNode(start, drain);
+	const condition_call = new AccessNode(start, arm_receiver(host, fields, start), condition);
+	const dispatch = new AccessFunctionCallNode(start, hidden);
+	dispatch.ref_param_indices = [0];
+	dispatch.params = [new ValueNode(start, "win")];
+	return new IfElseNode(start, condition_call, new BranchNode(start, [new AccessNode(start, new ValueNode(start, "self", new Type(host.name)), dispatch)]));
+}
+//#endregion
 //#region ../src/check/check_access_node.ts
 function check_access_node(node, status) {
 	if (!check_node(node.target, status)) return false;
@@ -61902,6 +63729,8 @@ function check_access_field_node(target_type, target, node, status) {
 	return true;
 }
 function check_access_function_node(target_type, target, node, status) {
+	const handler = try_check_handler_registration(target_type, target, node, status);
+	if (handler !== void 0) return handler;
 	if (target_type.name === "Nursery" && node.name === "start") return check_nursery_spawn(node, status);
 	if (target_type.name === "Fiber" && node.name === "start_on") {
 		if (!check_spawn_start_on(target, target_type, node, status)) return false;
@@ -62022,6 +63851,13 @@ function check_access_function_node(target_type, target, node, status) {
 		}
 	}
 	if (!func) {
+		if (node.name === "copy" && node.params.length === 0) {
+			const container_is = (prefix) => target_type.name === prefix || target_type.name.startsWith(`${prefix}_`) || !!struct?.name.startsWith(`${prefix}_`);
+			if ((container_is("Map") || container_is("Set") ? target_type.type_args ?? struct?.source_type_args : void 0)?.some((arg) => arg.name && is_owning_ref_type(arg.name, status))) {
+				add_error(status, container_is("Map") ? "Map.copy() is not available when the key or value type is a class or trait — its store is a ClassBuffer with no copy, so the copy would share the stored instances (a double free). Keep one mv map and index into it, or rebuild the map with fresh instances." : "Set.copy() is not available when the element type is a class or trait — its store is a ClassBuffer with no copy, so the copy would share the stored instances (a double free). Keep one mv set and index into it, or rebuild the set with fresh instances.", node.start);
+				return false;
+			}
+		}
 		add_error(status, `Function not found: ${target_type.name}.${node.name}`, node.start);
 		return false;
 	}
@@ -62724,8 +64560,10 @@ function check_assignment_node(assign, status) {
 		add_error(status, `Unknown variable: ${left_value_name}`, assign.left_value.start);
 		return false;
 	} else if (left_value.is_ref_binding && assign.left_value.node_type === "value") {
-		add_error(status, `'${left_value_name}' is a ref — reassign the owner, not the alias`, assign.left_value.start);
-		return false;
+		left_value.class_alias_of = void 0;
+		left_value.ref_source = void 0;
+		left_value.is_ref_binding = void 0;
+		left_value.declaration = "var";
 	} else if (assign.left_value.node_type === "access" && left_value.is_ref_binding) {
 		if (left_value.ref_source) enforce_root_not_frozen(left_value.ref_source, status, assign.left_value.start);
 		if (!(left_value.ref_source && is_var_binding(left_value.ref_source, status))) {
@@ -62818,7 +64656,8 @@ function check_assignment_node(assign, status) {
 	} else check_type_and_value_match(type_from_value_node(assign.left_value, status), type_from_value_node(assign.right_value, status), value_from_value_node(assign.right_value), status, assign.right_value.start, "assignment");
 	if (assign.left_value.node_type === "access" && assign.left_value.access.node_type === "access_field") {
 		const lhs_access = assign.left_value;
-		if (lhs_access.access.type?.is_view) {
+		const lhs_field = lhs_access.access;
+		if (lhs_field.type?.is_view) {
 			const root = root_var_of(lhs_access.target);
 			const rhs = assign.right_value;
 			let infos;
@@ -62829,6 +64668,18 @@ function check_assignment_node(assign, status) {
 			const info = view_source_borrow_info(rhs, status);
 			if (info) merge_view_borrows_into_var(root, /* @__PURE__ */ new Map([[info.owner ?? "", info]]), status);
 			else if (!infos?.size && root && view_fields_invalidated(root, status)) status.invalidated_view_structs?.delete(root);
+		} else if (lhs_field.type?.name && struct_has_view_fields(lhs_field.type.name, status)) {
+			const root = root_var_of(lhs_access.target);
+			const rhs_name = value_from_value_node(assign.right_value);
+			const rhs_sv = rhs_name !== void 0 ? status.values.findLast((v) => v.name === rhs_name) : void 0;
+			if (root && rhs_sv?.has_view_borrows) {
+				const infos = /* @__PURE__ */ new Map();
+				for (const owner of rhs_sv.view_field_owners ?? []) infos.set(owner, {
+					owner,
+					depth: rhs_sv.borrow_depth
+				});
+				merge_view_borrows_into_var(root, infos, status);
+			}
 		}
 	}
 	const lhs_is_owning_field_store = assign.left_value.node_type === "access" && assign.left_value.access.node_type === "access_field" && lhs_field_access_owning(assign.left_value, status);
@@ -63045,7 +64896,7 @@ function check_async_block_node(node, status) {
 	const block_status = clone_status(status);
 	block_status.nursery_depth = (status.nursery_depth ?? 0) + 1;
 	block_status.nursery_scope_depths = [...status.nursery_scope_depths ?? [], status.scope_depth + 1];
-	block_status.nursery_frozen_roots = [...status.nursery_frozen_roots ?? [], /* @__PURE__ */ new Set()];
+	block_status.nursery_frozen_roots = [...status.nursery_frozen_roots ?? [], /* @__PURE__ */ new Map()];
 	if (node.nursery_name) block_status.values.push({
 		declaration: "var",
 		name: node.nursery_name,
@@ -63154,6 +65005,8 @@ function check_enum_node(node, status) {
 	for (let i = 0; i < node.cases.length; i++) for (let j = i + 1; j < node.cases.length; j++) if (node.cases[i].name === node.cases[j].name) add_error(status, `Duplicate enum case: ${node.cases[j].name}`, node.cases[j].params[0]?.start || node.start);
 	for (const tp of node.type_params) if (node.type_params.filter((t) => t === tp).length > 1) add_error(status, `Duplicate type parameter: ${tp}`, node.start);
 	for (let c of node.cases) for (let p of c.params) {
+		if (p.type.is_view) add_error(status, `enum case payloads cannot be 'view' — materialize the value ('.to_string()') or re-slice from the source on use`, p.start || node.start);
+		else if (p.type.name && struct_has_view_fields(p.type.name, status)) add_error(status, `enum case payloads cannot be '${p.type.name}' — structs with 'view' fields are scope-local; store the fields (the views) instead`, p.start || node.start);
 		if (node.type_params.includes(p.type.name)) continue;
 		if (!status.types.includes(p.type.name)) add_error(status, `Unknown type: ${p.type.name}`, p.start);
 	}
@@ -63969,6 +65822,7 @@ function check_return_node(ret, status) {
 		ret.type = new Type("void");
 		return;
 	}
+	if (func?.return_type && !func.return_type.is_view && func.return_type.name && struct_has_view_fields(func.return_type.name, status) && !func.view_bundle_return_rejected) add_error(status, `cannot return a '${func.return_type.name}' — structs with 'view' fields are scope-local; return the fields (the views) instead`, ret.value.start);
 	const old_expected_type = status.expected_type;
 	if (func?.return_type?.name && func.return_type.name !== "?") status.expected_type = func.return_type;
 	const old_allow_null = status.allow_null_value;
@@ -63983,8 +65837,11 @@ function check_return_node(ret, status) {
 	ret.type = type_from_value_node(ret.value, status);
 	if (ret.value.node_type === "access" && ret.value.access.node_type === "access_field") {
 		const af = ret.value.access;
-		const base_type = type_from_value_node(ret.value.target, status);
-		if (base_type.name) {
+		const base_target = ret.value.target;
+		const base_type = type_from_value_node(base_target, status);
+		const base_name = base_target.node_type === "value" ? base_target.value : "";
+		const base_is_binding = !!base_name && status.values.some((v) => v.name === base_name);
+		if (base_type.name && base_is_binding) {
 			const field = status.structs.findLast((s) => s.name === mono_type_name(base_type) && !s.is_generic)?.fields.find((f) => f.name === af.name);
 			if (field?.type.name && !field.type.is_array && !field.type.is_view && !field.type.is_ref && (is_class_type(field.type.name, status) || is_owning_struct_type_requiring_move(new Type(mono_type_name(field.type)), status))) add_error(status, `cannot copy '${field.type.name}' out of field '${af.name}' by value — it owns heap resources; use 'mv ... swap <replacement>'${field.type.name === "string" ? ", or .copy() for a deep copy" : ""}`, ret.value.start);
 		}
@@ -64199,8 +66056,9 @@ function check_value_node(node, status) {
 		return true;
 	}
 	if (node.value.startsWith(".") && node.value.length > 1 && !node.value.startsWith("..")) return check_enum_shorthand(node, status);
-	node.type = type_from_value(node.value, status);
-	if (!node.type.name) {
+	const resolved = type_from_value(node.value, status);
+	if (resolved.name) node.type = resolved;
+	else if (!node.type?.name) {
 		add_error(status, `Unknown value: ${node.value}`, node.start);
 		return false;
 	}
@@ -64611,6 +66469,7 @@ function check(root, options) {
 	};
 	stamp_literal_element_moves(root);
 	check_node(root, status);
+	finalize_handler_hosts(status);
 	unwrap_unsafe_blocks(root);
 	if (!status.errors.length) emit_warnings(root, status);
 	return {
@@ -66229,7 +68088,7 @@ function parse_function(visibility, status, name_override, is_inline, is_foreign
 	let name = name_override || consume(status);
 	if (!name_override && name === "#") {
 		const next = consume(status);
-		if (next === "init" || next === "destroy" || next.startsWith("op_")) name = `#${next}`;
+		if (next === "init" || next === "destroy" || next === "spawn" || next === "weak" || next === "handle" || next.startsWith("op_")) name = `#${next}`;
 	}
 	const op_internal = {
 		"#op_add": "add",
@@ -66296,7 +68155,7 @@ function parse_function(visibility, status, name_override, is_inline, is_foreign
 				parse_statement(status);
 				expect("}", status);
 				status.stack.pop();
-				if (name !== "#init" && name !== "#destroy" && name !== "#spawn") check_missing_return(func, status);
+				if (name !== "#init" && name !== "#destroy" && name !== "#spawn" && name !== "#weak" && name !== "#handle") check_missing_return(func, status);
 			}
 			switch (parent.node_type) {
 				case "root":
@@ -66498,6 +68357,10 @@ function parse_struct(visibility, status, is_owning = false) {
 			struct.functions.unshift(func);
 		}
 		add_to_parent(struct, "Struct", status);
+		if (struct.functions.some((f) => f.name === "#handle")) {
+			struct.functions = struct.functions.filter((f) => f.name !== "#handle");
+			add_to_parent(synthesize_handle_struct(struct, start, visibility), "Struct", status);
+		}
 	}
 	status.namespace = old_namespace;
 }
@@ -66514,6 +68377,34 @@ function parse_optional_type_param_bound(status) {
 	while (accept("+", status)) bounds.push(consume(status));
 	return bounds;
 }
+function synthesize_handle_struct(struct, start, visibility) {
+	if (struct.type_params.length > 0) throw new Error(`#handle is not supported on generic struct '${struct.name}' yet`);
+	const handle = new StructNode(start, visibility, `${struct.name}Handle`);
+	handle.is_owning = false;
+	handle.fields.push(new DeclarationNode(start, "internal", "var", "handle", new Type("uint64")));
+	const init = new FunctionNode(start, visibility, "#init", new Type(handle.name));
+	const self_param = new ParameterNode(start, "self", new Type(handle.name));
+	self_param.is_self_param = true;
+	self_param.declaration = "var";
+	init.params = [self_param, new ParameterNode(start, "from", new Type(struct.name))];
+	init.is_static = false;
+	init.has_body = true;
+	init.statements = [new AssignmentNode(start, new AccessNode(start, new ValueNode(start, "self", new Type(handle.name)), new AccessFieldNode(start, "handle", new Type("uint64"))), new AccessNode(start, new ValueNode(start, "from", new Type(struct.name)), new AccessFieldNode(start, "handle", new Type("uint64"))))];
+	handle.functions.push(init);
+	for (const func of struct.functions) {
+		if (func.visibility !== "pub") continue;
+		if (func.name.startsWith("#")) continue;
+		const receiver = func.params[0];
+		if (!receiver || !receiver.is_self_param) continue;
+		if (receiver.is_ref) continue;
+		const clone = clone_node(func);
+		clone.start = start;
+		clone.visibility = "pub";
+		clone.params[0].type = new Type(handle.name);
+		handle.functions.push(clone);
+	}
+	return handle;
+}
 //#endregion
 //#region ../src/parse/utils/class_retired_error.ts
 /**
@@ -66813,6 +68704,11 @@ function parse_visibility(visibility, status) {
 				consume(status);
 				consume(status);
 				parse_function(visibility, status, "#weak");
+			} else if (next2 === "handle") {
+				consume(status);
+				consume(status);
+				consume(status);
+				parse_function(visibility, status, "#handle");
 			} else {
 				add_error(status, `Expected #init, #destroy, #spawn or #weak after pub`, get_index(status));
 				consume(status);
@@ -66974,8 +68870,12 @@ function parse_statement(status) {
 					consume(status);
 					consume(status);
 					parse_destroy(default_visibility(status), status, "#weak");
+				} else if (next === "handle") {
+					consume(status);
+					consume(status);
+					parse_destroy(default_visibility(status), status, "#handle");
 				} else {
-					add_error(status, `Expected #init, #destroy, #spawn or #weak`, get_index(status));
+					add_error(status, `Expected #init, #destroy, #spawn, #weak or #handle`, get_index(status));
 					consume(status);
 				}
 				break;