nomen-lang 0.5.0 → 0.6.0

package/dist/index.mjs

@@ -1702,6 +1702,7 @@ const MNEMONICS = {
 	]] },
 	dup: { shapes: [["f", "f"], ["f", "r"]] },
 	movz: { shapes: [["r", "i"]] },
+	movk: { shapes: [["r", "i"]] },
 	mvn: { shapes: [["r", "r"]] },
 	fmov: { shapes: [
 		["f", "f"],
@@ -2108,7 +2109,8 @@ function try_parse_operands(parts) {
 			continue;
 		}
 		if (SHIFT_TOKEN_RE.exec(tok) && operands.length > 0) {
-			if (operands[operands.length - 1].kind === "reg") continue;
+			const prev = operands[operands.length - 1];
+			if (prev.kind === "reg" || prev.kind === "imm") continue;
 		}
 		return null;
 	}
@@ -2159,7 +2161,7 @@ function split_operands(s) {
 	return parts;
 }
 const IMM_RE = /^#(-?)(0x[0-9a-fA-F]+|\d+)$/;
-function parse_imm(tok) {
+function parse_imm$1(tok) {
 	const m = IMM_RE.exec(tok);
 	if (!m) return null;
 	return (m[1] ? -1n : 1n) * (m[2].toLowerCase().startsWith("0x") ? BigInt(m[2]) : BigInt(m[2]));
@@ -2168,7 +2170,7 @@ function parse_imm(tok) {
 function parse_pseudo_imm(tok) {
 	const t = tok.trim();
 	if (!t.startsWith("=")) return null;
-	const v = parse_imm("#" + t.slice(1));
+	const v = parse_imm$1("#" + t.slice(1));
 	return v === null && /^=\d+$/.test(t) ? BigInt(t.slice(1)) : v;
 }
 function parse_reg(tok) {
@@ -2225,7 +2227,7 @@ function parse_mem(parts, start) {
 	let next = start + 1;
 	let postOffset;
 	if (next < parts.length && !parts[next].startsWith("[")) {
-		const v = parse_imm(parts[next]);
+		const v = parse_imm$1(parts[next]);
 		if (v !== null && !parsed_inner.offset && !parsed_inner.scale) {
 			postOffset = v;
 			next++;
@@ -2248,7 +2250,7 @@ function parse_mem_inner(inner) {
 	const mem = { base };
 	for (let k = 1; k < comps.length; k++) {
 		const comp = comps[k];
-		const imm = parse_imm(comp);
+		const imm = parse_imm$1(comp);
 		if (imm !== null) {
 			mem.offset = {
 				kind: "imm",
@@ -2287,7 +2289,7 @@ function parse_operand(tok) {
 			width: !(cls === "fpr") ? 64 : reg.startsWith("d") ? 64 : /^[vs]\d+$/.test(reg) ? 32 : 128
 		};
 	}
-	const imm = parse_imm(trimmed);
+	const imm = parse_imm$1(trimmed);
 	if (imm !== null) return {
 		kind: "imm",
 		value: imm,
@@ -3734,6 +3736,110 @@ function eliminate_dead_cycle_moves(code) {
 	}
 	return code;
 }
+//#endregion
+//#region ../src/build_aarch64/asm_expand_adr.ts
+/**
+* Final-address expansion (runs last, after every optimizer that
+* pattern-matches the `adr` form). `adr` is PC-relative with a ±1 MB reach;
+* in a large program (allmark's generated spec tests assemble to 1.5-3 MB of
+* asm) the string and constant labels in `.data` sit more than 1 MB from the
+* code that uses them, and the assembler rejects every `adr xN, _str_KNN`
+* with "fixup value out of range".
+*
+* Rewrite `adr xN, SYM` into the page-relative pair the vtable install already
+* uses — `adrp xN, SYM@PAGE` + `add xN, xN, SYM@PAGEOFF` (adrp reaches ±4 GB).
+*
+* Only NON-LOCAL symbols are rewritten: a label beginning with `.` (or a
+* numeric `Nf`/`Nb` local) is intra-function and within reach, so it stays an
+* `adr` — keeping the emitted text of small programs unchanged.
+*/
+const ADR_RE = /^(\s*)adr (x[0-9]+), ([A-Za-z_][A-Za-z0-9_]*)\s*$/;
+function expand_far_adr_addresses(code) {
+	const lines = code.split("\n");
+	for (let i = 0; i < lines.length; i++) {
+		const m = ADR_RE.exec(lines[i]);
+		if (!m) continue;
+		const [, indent, reg, sym] = m;
+		lines[i] = `${indent}adrp ${reg}, ${sym}@PAGE\n${indent}add ${reg}, ${reg}, ${sym}@PAGEOFF`;
+	}
+	return lines.join("\n");
+}
+//#endregion
+//#region ../src/build_aarch64/asm_expand_mov.ts
+/**
+* Large-immediate expansion (final pass, runs after every optimizer so the
+* passes see the canonical `mov xN, #imm` / `ldr xN, =K` forms).
+*
+* Two AArch64 hazards this pass removes:
+*  - The `mov` alias only encodes a 16-bit immediate (movz; movn for small
+*    negatives). An emitter site that hands a bigger constant to the plain
+*    `mov` form — a long string literal's byte length, a big array count, a
+*    large struct size — produces a line the assembler rejects outright.
+*  - `ldr xN, =K` needs a literal pool the assembler must site within ±1 MB
+*    of the load. In a multi-MB program (allmark's generated spec tests) the
+*    pool falls out of range and the assembler reports "fixup value out of
+*    range".
+*
+* Both are rewritten to a movz/movk chunk chain (positive) or the
+* movn + movk form (negative), exactly materializing the 64-bit constant. The
+* chunks are computed on BigInt so a full-width `uint64` (or a value written
+* as a hex literal) is preserved — a JS `number` rounds and can spill into a
+* fifth chunk (`movk …, lsl #64`, which the assembler rejects).
+*/
+const MASK64 = (1n << 64n) - 1n;
+const MASK16 = 65535n;
+/** Materialize any 64-bit integer constant in `reg`, without a literal pool. */
+function materialize_immediate(reg, k) {
+	if (k >= 0n && k <= 65535n) return [`mov ${reg}, #${k}`];
+	if (k < 0n && k >= -65536n) return [`movn ${reg}, #${-k - 1n}`];
+	const v = k & MASK64;
+	const chunk = (i) => v >> BigInt(16 * i) & MASK16;
+	if (k >= 0n) {
+		const out = [`movz ${reg}, #${chunk(0)}`];
+		for (let i = 1; i < 4; i++) {
+			const c = chunk(i);
+			if (c !== 0n) out.push(`movk ${reg}, #${c}, lsl #${i * 16}`);
+		}
+		return out;
+	}
+	return [
+		`movn ${reg}, #${~chunk(0) & MASK16}`,
+		`movk ${reg}, #${chunk(1)}, lsl #16`,
+		`movk ${reg}, #${chunk(2)}, lsl #32`,
+		`movk ${reg}, #${chunk(3)}, lsl #48`
+	];
+}
+function parse_imm(text) {
+	try {
+		return BigInt(text);
+	} catch {
+		return null;
+	}
+}
+const MOV_IMM_RE = /^(\s*)mov (x|w)([0-9]+), #(-?\d+)$/;
+const LDR_POOL_RE = /^(\s*)ldr (x[0-9]+), =(-?\d+)$/;
+function expand_large_mov_immediates(code) {
+	const lines = code.split("\n");
+	for (let i = 0; i < lines.length; i++) {
+		const m = MOV_IMM_RE.exec(lines[i]);
+		if (m) {
+			const [, indent, cls, num, imm_text] = m;
+			const k = parse_imm(imm_text);
+			if (k === null) continue;
+			if (k >= -65536n && k <= 65535n) continue;
+			const reg = `${cls}${num}`;
+			lines[i] = materialize_immediate(reg, k).map((line) => `${indent}${line}`).join("\n");
+			continue;
+		}
+		const p = LDR_POOL_RE.exec(lines[i]);
+		if (!p) continue;
+		const [, indent, reg, imm_text] = p;
+		const k = parse_imm(imm_text);
+		if (k === null) continue;
+		lines[i] = materialize_immediate(reg, k).map((line) => `${indent}${line}`).join("\n");
+	}
+	return lines.join("\n");
+}
 const LABEL_LINE_RE$2 = /^([A-Za-z_.$][\w.$]*|\d+):$/;
 const NUMERIC_LABEL_RE = /^\d+$/;
 const B_ALIAS_RE = /^(eq|ne|lt|le|gt|ge|hs|lo|ls|hi|mi|pl)$/;
@@ -6309,36 +6415,24 @@ var AccessFunctionCallNode = class extends BaseNode {
 	* escape-hatch call (target type is `Nursery`, method name is `start`).
 	* The build phase reads `function_return_type` and emits the spawn
 	* trampoline against the passed Nursery's runtime futures/count pointers.
-	* See ASYNC.md and ASYNC.md.
+	* See ASYNC.md, "Nursery escape hatch".
 	*/
 	is_nursery_spawn;
 	/**
-	* Set during checking when this is a `Thread(fn(args)).start()` call —
-	* the surface form of a direct spawn (target type is `Thread`, method
-	* name is `start`). The build phase synthesizes a SpawnNode from the
-	* wrapped call and emits the standard spawn trampoline. See ASYNC.md.
+	* 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
+	* older stamps; nothing sets or consumes them on fresh checks.
 	*/
 	is_thread_start;
-	/**
-	* Set during checking when this is a `Thread(fn(args)).detach()` call —
-	* the daemon form. The build synthesizes a SpawnNode from the wrapped
-	* call and emits a detached-pthread trampoline: never a pool worker,
-	* nobody joins it, process exit kills it mid-execution by design (the
-	* std::thread::spawn contract). See ASYNC.md, "Daemon tasks".
-	*/
+	/** Retired — see is_thread_start. */
 	is_thread_detach;
-	/**
-	* Set during checking when this is a `Fiber(fn(args)).start()` call —
-	* the fiber flavor of a direct spawn. The build synthesizes a SpawnNode
-	* from the wrapped call and emits the fiber trampoline (the launch goes
-	* to the fiber scheduler instead of the pool). See ASYNC.md.
-	*/
+	/** Retired — see is_thread_start. */
 	is_fiber_start;
 	/**
-	* Set during checking when this is a `Fiber(fn(args)).start_on(buf)`
-	* call — like is_fiber_start, but the fiber runs on the caller-provided
-	* fixed-size array stack. The single parameter is the buffer. See
-	* ASYNC.md.
+	* RETIRED with the pre-migration launch dispatch: `.start_on(buf)` is
+	* checker-validated and rewritten to the ordinary `Fiber.start` method
+	* (docs/ASYNC.md). Kept only for old clone stamps.
 	*/
 	is_fiber_start_on;
 	/**
@@ -6520,16 +6614,17 @@ var FunctionCallNode = class extends BaseNode {
 	/** Fiber flavor of the magic spawn constructor (see is_thread_ctor). */
 	is_fiber_ctor;
 	/**
-	* The GENERALIZED spawn-constructor flavor (ASYNC.md, "User-defined
-	* async primitives"): the call's name resolves to a user CLASS
-	* conforming to the core `Awaitable` trait and carrying the
-	* spawn-handle field contract (uint64 fields task / result_slot /
-	* cancel_flag / future — Thread/Fiber keep their own flags; they do not
-	* conform to Awaitable). `X(fn(args))` packs the wrapped call eagerly
-	* and yields a heap `X` instance (monomorphized `X<T>` when generic)
-	* whose fields carry the launch machinery; the class's own launch
-	* methods consume them. Typed/stamped by check_magic_ctor exactly like
-	* the Thread/Fiber flavors.
+	* The catch-all spawn-constructor flavor: a `#spawn`-bearing class that
+	* is neither Thread nor Fiber (a user class declaring its own
+	* construction hook — ASYNC.md). The construction is keyed
+	* on the `#spawn` member, never on Awaitable conformance (the old
+	* field-contract sugar retired; see docs/ASYNC.md, "Design decisions"). `X(fn(args))` packs the
+	* wrapped call eagerly and yields a heap `X` instance (monomorphized
+	* `X<T>` when generic) whose fields carry the launch machinery (the
+	* uint64 task / result_slot / cancel_flag / future contract the
+	* Task.* seam drives); the class's own launch methods consume them.
+	* Typed/stamped by check_magic_ctor exactly like the Thread/Fiber
+	* flavors.
 	*/
 	is_awaitable_ctor;
 	/**
@@ -7351,7 +7446,7 @@ function scan_self_string_field_writes(struct, method) {
 	const scan_method = (func) => {
 		if (visited.has(func.name)) return;
 		visited.add(func.name);
-		walk$2(func.statements ?? [], (n) => {
+		walk$3(func.statements ?? [], (n) => {
 			if (n.node_type === "assign") {
 				const lhs = n.left_value;
 				if (lhs?.node_type !== "access") return;
@@ -7395,10 +7490,10 @@ function drop_self_written_string_field_records(status, receiver_name, fields) {
 *  statement arrays) — skipping `parent`/`scope` back-references and NOT
 *  descending INTO nested `func`/`struct`/`trait` declarations (a nested
 *  function's body is a separate function, not part of this one's writes). */
-function walk$2(value, cb) {
+function walk$3(value, cb) {
 	if (!value || typeof value !== "object") return;
 	if (Array.isArray(value)) {
-		for (const item of value) walk$2(item, cb);
+		for (const item of value) walk$3(item, cb);
 		return;
 	}
 	const n = value;
@@ -7407,7 +7502,7 @@ function walk$2(value, cb) {
 	if (is_boundary) return;
 	for (const key of Object.keys(value)) {
 		if (key === "parent" || key === "scope" || key === "node_type") continue;
-		walk$2(value[key], cb);
+		walk$3(value[key], cb);
 	}
 }
 //#endregion
@@ -8983,186 +9078,6 @@ var AsyncBlockNode = class extends BaseNode {
 	}
 };
 //#endregion
-//#region ../src/build_aarch64/utils/aarch64_size.ts
-/**
-* Storage width of a value of `type` in bytes, derived from the
-* built-in type table (see BuiltInTypeInfo.bytes). Non-built-in names are
-* structs/enums/generics — 8 unless overridden by struct layout. `string`
-* is the fat 16-byte { char* ptr; long len; } pair; in registers it rides
-* as a consecutive (ptr, len) pair — the same ABI `view T` uses.
-*/
-function aarch64_size(type) {
-	if (type === "string") return 16;
-	return get_built_in_type(type)?.bytes ?? 8;
-}
-//#endregion
-//#region ../src/build_aarch64/utils/stack_var.ts
-function allocate_stack_space(status, size, alignment = 8) {
-	if (!status.stack_size) status.stack_size = 0;
-	const aligned_size = Math.ceil(status.stack_size / alignment) * alignment;
-	status.stack_size = aligned_size + size;
-	return aligned_size;
-}
-/**
-* Load a stack slot into a promoted (callee-saved) register with the slot's
-* width. A sub-word slot (bool/char/int8 = strb, int16 = strh, int32 = str w)
-* must be loaded with the matching zero-extending ldrb/ldrh/ldr w — a
-* full-width `ldr` picks up dirty stack bytes above the slot and a bool can
-* read as true regardless of its stored value.
-*/
-function emit_promoted_load(status, reg, offset, type_name) {
-	const size = aarch64_size(type_name);
-	if (size === 1) emit_asm(status, `ldrb ${reg.replace("x", "w")}, [x29, #${offset}]\n`);
-	else if (size === 2) emit_asm(status, `ldrh ${reg.replace("x", "w")}, [x29, #${offset}]\n`);
-	else if (size === 4) emit_asm(status, `ldr ${reg.replace("x", "w")}, [x29, #${offset}]\n`);
-	else emit_asm(status, `ldr ${reg}, [x29, #${offset}]\n`);
-}
-/**
-* Write a promoted (callee-saved) register back to its stack slot with the
-* slot's width. A full-width `str` into a sub-word slot clobbers the adjacent
-* stack bytes — whatever variable lives there gets corrupted.
-*/
-function emit_promoted_store(status, reg, offset, type_name) {
-	const size = aarch64_size(type_name);
-	if (size === 1) emit_asm(status, `strb ${reg.replace("x", "w")}, [x29, #${offset}]\n`);
-	else if (size === 2) emit_asm(status, `strh ${reg.replace("x", "w")}, [x29, #${offset}]\n`);
-	else if (size === 4) emit_asm(status, `str ${reg.replace("x", "w")}, [x29, #${offset}]\n`);
-	else emit_asm(status, `str ${reg}, [x29, #${offset}]\n`);
-}
-function is_local_ref_var(name, status) {
-	return !!status.function_ref_params?.has(name) && !status.function_param_regs?.has(name);
-}
-function emit_var_address(status, reg, name) {
-	if (status.closure_env_offsets?.has(name) && status.closure_env_slot !== void 0) {
-		emit_asm(status, `ldr ${reg}, [x29, #${status.closure_env_slot}]\n`);
-		const off = status.closure_env_offsets.get(name);
-		if (off !== 0) emit_asm(status, `add ${reg}, ${reg}, #${off}\n`);
-		return;
-	}
-	const alloc_reg = status.register_allocations?.get(name);
-	if (alloc_reg) {
-		const offset = status.stack_offsets?.get(name);
-		if (offset !== void 0) {
-			const type_name = status.scoped_declarations.find((d) => d.name === name)?.type?.name || status.variable_types?.get(name)?.name || "";
-			if (type_name) emit_promoted_store(status, alloc_reg, offset, type_name);
-			else emit_asm(status, `str ${alloc_reg}, [x29, #${offset}]\n`);
-		}
-	}
-	const offset = status.stack_offsets?.get(name);
-	if (offset !== void 0) {
-		if (status.function_struct_param_slots?.has(name)) emit_asm(status, `ldr ${reg}, [x29, #${offset}]\n`);
-		else emit_asm(status, `add ${reg}, x29, #${offset}\n`);
-	} else {
-		const param_reg = status.function_param_regs?.get(name);
-		if (param_reg) emit_asm(status, `mov ${reg}, ${param_reg}\n`);
-		else emit_asm(status, `adr ${reg}, ${name}\n`);
-	}
-}
-function emit_deref_var_address(status, reg, name) {
-	emit_var_address(status, reg, name);
-	if (is_local_ref_var(name, status)) emit_asm(status, `ldr ${reg}, [${reg}]\n`);
-}
-function emit_var_load(status, reg, name, size) {
-	if (name === "null") {
-		emit_asm(status, `mov ${reg}, #0\n`);
-		return;
-	}
-	if (status.closure_env_offsets?.has(name) && status.closure_env_slot !== void 0) {
-		const off = status.closure_env_offsets.get(name);
-		emit_asm(status, `ldr ${reg}, [x29, #${status.closure_env_slot}]\n`);
-		if (size === 16 && reg.startsWith("x")) {
-			emit_asm(status, `ldr x${parseInt(reg.substring(1), 10) + 1}, [${reg}, #${off + 8}]\n`);
-			emit_asm(status, `ldr ${reg}, [${reg}, #${off}]\n`);
-		} else if (size === 1) emit_asm(status, `ldrb ${reg.replace("x", "w")}, [${reg}, #${off}]\n`);
-		else if (size === 2) emit_asm(status, `ldrh ${reg.replace("x", "w")}, [${reg}, #${off}]\n`);
-		else if (size === 4) emit_asm(status, `ldr ${reg.replace("x", "w")}, [${reg}, #${off}]\n`);
-		else emit_asm(status, `ldr ${reg}, [${reg}, #${off}]\n`);
-		return;
-	}
-	const alloc_reg = status.register_allocations?.get(name);
-	if (alloc_reg) {
-		if (alloc_reg.startsWith("d") && reg.startsWith("d")) {
-			if (reg !== alloc_reg) emit_asm(status, `fmov ${reg}, ${alloc_reg}\n`);
-		} else if (alloc_reg.startsWith("d")) emit_asm(status, `fmov ${reg}, ${alloc_reg}\n`);
-		else if (reg !== alloc_reg) emit_asm(status, `mov ${reg}, ${alloc_reg}\n`);
-		return;
-	}
-	const offset = status.stack_offsets?.get(name);
-	if (offset !== void 0) {
-		if (size === 16 && reg.startsWith("x")) {
-			const n = parseInt(reg.substring(1), 10);
-			if (offset + 8 > 504) {
-				emit_asm(status, `ldr ${reg}, [x29, #${offset}]\n`);
-				emit_asm(status, `ldr x${n + 1}, [x29, #${offset + 8}]\n`);
-			} else emit_asm(status, `ldp ${reg}, x${n + 1}, [x29, #${offset}]\n`);
-			return;
-		}
-		if (size === 1) emit_asm(status, `ldrb ${reg.replace("x", "w")}, [x29, #${offset}]\n`);
-		else if (size === 2) emit_asm(status, `ldrh ${reg.replace("x", "w")}, [x29, #${offset}]\n`);
-		else if (size === 4) emit_asm(status, `ldr ${reg.replace("x", "w")}, [x29, #${offset}]\n`);
-		else emit_asm(status, `ldr ${reg}, [x29, #${offset}]\n`);
-	} else {
-		const param_reg = status.function_param_regs?.get(name);
-		if (param_reg) {
-			if (reg !== param_reg) emit_asm(status, `mov ${reg}, ${param_reg}\n`);
-		} else {
-			emit_asm(status, `adr ${reg}, ${name}\n`);
-			if (size === 1) emit_asm(status, `ldrb ${reg.replace("x", "w")}, [${reg}]\n`);
-			else if (size === 2) emit_asm(status, `ldrh ${reg.replace("x", "w")}, [${reg}]\n`);
-			else if (size === 4) emit_asm(status, `ldr ${reg.replace("x", "w")}, [${reg}]\n`);
-			else emit_asm(status, `ldr ${reg}, [${reg}]\n`);
-		}
-	}
-}
-function emit_var_store(status, reg, name, size) {
-	if (status.closure_env_offsets?.has(name) && status.closure_env_slot !== void 0) {
-		const off = status.closure_env_offsets.get(name);
-		emit_asm(status, `ldr x9, [x29, #${status.closure_env_slot}]\n`);
-		if (size === 16 && reg.startsWith("x")) {
-			const n = parseInt(reg.substring(1), 10);
-			emit_asm(status, `str ${reg}, [x9, #${off}]\n`);
-			emit_asm(status, `str x${n + 1}, [x9, #${off + 8}]\n`);
-		} else if (size === 1) emit_asm(status, `strb ${reg.replace("x", "w")}, [x9, #${off}]\n`);
-		else if (size === 2) emit_asm(status, `strh ${reg.replace("x", "w")}, [x9, #${off}]\n`);
-		else if (size === 4) emit_asm(status, `str ${reg.replace("x", "w")}, [x9, #${off}]\n`);
-		else emit_asm(status, `str ${reg}, [x9, #${off}]\n`);
-		return;
-	}
-	const alloc_reg = status.register_allocations?.get(name);
-	if (alloc_reg) {
-		if (alloc_reg.startsWith("d") && reg.startsWith("d")) {
-			if (reg !== alloc_reg) emit_asm(status, `fmov ${alloc_reg}, ${reg}\n`);
-		} else if (alloc_reg.startsWith("d")) emit_asm(status, `fmov ${alloc_reg}, ${reg}\n`);
-		else if (reg !== alloc_reg) emit_asm(status, `mov ${alloc_reg}, ${reg}\n`);
-		return;
-	}
-	const offset = status.stack_offsets?.get(name);
-	if (offset !== void 0) {
-		if (size === 16 && reg.startsWith("x")) {
-			const n = parseInt(reg.substring(1), 10);
-			if (offset + 8 > 504) {
-				emit_asm(status, `str ${reg}, [x29, #${offset}]\n`);
-				emit_asm(status, `str x${n + 1}, [x29, #${offset + 8}]\n`);
-			} else emit_asm(status, `stp ${reg}, x${n + 1}, [x29, #${offset}]\n`);
-			return;
-		}
-		if (size === 1) emit_asm(status, `strb ${reg.replace("x", "w")}, [x29, #${offset}]\n`);
-		else if (size === 2) emit_asm(status, `strh ${reg.replace("x", "w")}, [x29, #${offset}]\n`);
-		else if (size === 4) emit_asm(status, `str ${reg.replace("x", "w")}, [x29, #${offset}]\n`);
-		else emit_asm(status, `str ${reg}, [x29, #${offset}]\n`);
-	} else {
-		const param_reg = status.function_param_regs?.get(name);
-		if (param_reg) emit_asm(status, `mov ${param_reg}, ${reg}\n`);
-		else {
-			emit_asm(status, `adr x1, ${name}\n`);
-			if (size === 1) emit_asm(status, `strb ${reg.replace("x", "w")}, [x1]\n`);
-			else if (size === 2) emit_asm(status, `strh ${reg.replace("x", "w")}, [x1]\n`);
-			else if (size === 4) emit_asm(status, `str ${reg.replace("x", "w")}, [x1]\n`);
-			else emit_asm(status, `str ${reg}, [x1]\n`);
-		}
-	}
-}
-//#endregion
 //#region ../src/build_aarch64/build_spawn_node.ts
 /**
 * Pool infrastructure emitted as file-scope C on the first spawn.
@@ -9234,6 +9149,14 @@ struct nomen_future {
 	// The fiber whose task this future is (set at fiber spawn). Cancellation
 	// uses it to wake a fiber parked on a primitive waitq.
 	struct nomen_fiber *owning_fiber;
+	// 1 when the result slot holds a FAT string (set at construction, which
+	// knows the wrapped call's return type). The last release frees an
+	// unconsumed string buffer from the cell: result() zeroes the cell when
+	// it moves the value out, and Task's #destroy zeroes after its own
+	// free, so a non-NULL ptr at the last release means "never consumed".
+	// Appended LAST: raw bodies read refs/result_slot/owner_args at fixed
+	// offsets (#116/#128/#136), which must not shift.
+	int slot_fat;
 };
 // Fiber seam (defined in FIBER_HEADER_C, appended after this block).
 // Declared here — after struct nomen_future is complete — so the
@@ -9343,6 +9266,15 @@ int __nomen_future_timedwait(struct nomen_future *f, long long deadline_ms) {
 	pthread_mutex_unlock(&f->mu);
 	return 1;
 }
+// Non-blocking completion peek (Task.is_done) — non-static: raw asm
+// branches into it.
+int __nomen_future_is_done(struct nomen_future *f) {
+	if (!f) return 0;
+	pthread_mutex_lock(&f->mu);
+	int done = f->done;
+	pthread_mutex_unlock(&f->mu);
+	return done;
+}
 void __nomen_future_release(struct nomen_future *f) {
 	pthread_mutex_lock(&f->mu);
 	int last = --f->refs == 0;
@@ -9351,6 +9283,19 @@ void __nomen_future_release(struct nomen_future *f) {
 		pthread_mutex_destroy(&f->mu);
 		pthread_cond_destroy(&f->cv);
 		free(f->cancel_flag);
+		// An unconsumed fat-string result: free the buffer the trampoline
+		// stored (race-mode and fire-and-forget tasks never hand it to a
+		// consumer). Every consumer path zeroes the cell first — result()
+		// on move-out, Task's #destroy after its own free — so a non-NULL
+		// ptr here is unambiguous and the free happens exactly once.
+		if (f->slot_fat && f->result_slot) {
+			unsigned long long *_s = (unsigned long long *)f->result_slot;
+			if (_s[0]) {
+				free((void *)_s[0]);
+				_s[0] = 0;
+				_s[1] = 0;
+			}
+		}
 		free(f->result_slot);
 		// The task closure is owned by the future — disposed at the last
 		// release (see __nomen_closure_dispose above for the lifetime note).
@@ -9474,13 +9419,9 @@ void __nomen_future_cancel(struct nomen_future *f) {
 	// schedule it so it resumes and observes the flag (idempotent).
 	if (f->owning_fiber) __nomen_fiber_schedule(f->owning_fiber);
 }
-// Race-mode helpers — see build_c POOL_HEADER for semantics.
-int __nomen_future_is_done(struct nomen_future *f) {
-	pthread_mutex_lock(&f->mu);
-	int d = f->done;
-	pthread_mutex_unlock(&f->mu);
-	return d;
-}
+// Race-mode helpers — see build_c POOL_HEADER for semantics. (The
+// non-blocking peek itself, __nomen_future_is_done, lives with the future
+// machinery above — non-static: Task.is_done's raw asm branches into it.)
 int __nomen_nursery_race_wait(struct nomen_future **futures, int count, long long deadline_ms) {
 	if (count <= 0) return 0;
 	struct timespec sleep_ts = {0, 1000000};
@@ -9524,7 +9465,8 @@ static void *__nomen_detached_run(void *p) {
 	free(d);
 	return NULL;
 }
-static void __nomen_task_detach(struct nomen_closure *task) {
+// Non-static: raw asm (Thread.nm's #destroy/detach bodies) branches into it.
+void __nomen_task_detach(struct nomen_closure *task) {
 	struct nomen_detached_start *d =
 		(struct nomen_detached_start *)malloc(sizeof(struct nomen_detached_start));
 	d->task = task;
@@ -9548,6 +9490,7 @@ static void __nomen_task_detach(struct nomen_closure *task) {
 * linked program must define them.
 */
 function ensure_concurrency_runtime_a64(status) {
+	status.used_fibers = true;
 	if (status.emit_mode === "system") return;
 	if (status.pool_runtime_emitted && status.fiber_runtime_emitted) return;
 	if (!status.pool_runtime_emitted) {
@@ -10299,116 +10242,6 @@ static int __nomen_deadlock_check_worker(void) {
 }
 `;
 /**
-* Build a `.start()` launch on a `Thread(fn(args))` construction (or a
-* stored Thread binding) — aarch64 backend (CLOSURE.md Phase 3b).
-* A companion-C helper reads the packed handles from the receiver's fields,
-* submits the task closure to the pool, registers the future with the
-* enclosing nursery (if any), transfers the handles out of the instance,
-* and returns the Task<T> handle (or NULL, fire-and-forget); the assembly
-* builds the receiver pointer and calls it.
-*/
-function build_thread_start$1(access_func, target, status) {
-	ensure_concurrency_runtime_a64(status);
-	const id = status.spawn_counter ?? 0;
-	status.spawn_counter = id + 1;
-	const helper_name = `nomen_thread_${id}_start`;
-	const t_arg = spawn_result_type_arg$5(access_func.function_return_type);
-	const mono_thread = mono_type_name("Thread", [t_arg]);
-	const mono_task_name = mono_type_name("Task", [t_arg]);
-	const nursery_id = status.nursery_stack?.at(-1);
-	const nursery_off = nursery_id !== void 0 ? status.nursery_offsets?.get(nursery_id) : void 0;
-	const fire_and_forget = !!access_func.is_statement;
-	const target_is_temp = target.node_type === "func_call" && !!(target.is_thread_ctor || target.is_fiber_ctor);
-	const refs = fire_and_forget ? nursery_id !== void 0 ? 2 : 1 : nursery_id !== void 0 ? 3 : 2;
-	let c = `// --- thread start site ${id} ---\n`;
-	c += `void *${helper_name}(void *self`;
-	if (nursery_off) c += `, void **__nomen_nursery_futures, int *__nomen_nursery_count, int *__nomen_nursery_cap`;
-	c += `) {\n`;
-	c += `\textern void *${mono_task_name}_traits[];\n\tstruct ${mono_thread} *t = (struct ${mono_thread} *)self;\n`;
-	c += `\tstruct nomen_future *f = (struct nomen_future *)t->future;\n`;
-	c += `\tvoid *result_ptr = (void *)t->result_slot;\n`;
-	c += `\tunsigned long long *cancel_ptr = (unsigned long long *)t->cancel_flag;\n`;
-	c += `\tstruct nomen_closure *cl = (struct nomen_closure *)t->task;\n`;
-	c += `\tf->refs = ${refs};\n`;
-	c += `\t__nomen_pool_submit(cl);\n`;
-	if (nursery_off) c += `\t__nomen_nursery_track(__nomen_nursery_futures, __nomen_nursery_count, __nomen_nursery_cap, f);\n`;
-	c += `\tt->task = 0;\n`;
-	c += `\tt->future = 0;\n`;
-	c += `\tt->result_slot = 0;\n`;
-	c += `\tt->cancel_flag = 0;\n`;
-	c += `\tt->started = 1;\n`;
-	if (target_is_temp) c += `\tfree(t);\n`;
-	if (fire_and_forget) c += `\treturn (void *)0;\n`;
-	else {
-		c += `\tstruct ${mono_task_name} *task = (struct ${mono_task_name} *)malloc(sizeof(struct ${mono_task_name}));\n`;
-		c += `\ttask->_vt = (void **)${mono_task_name}_traits;\n`;
-		c += `\ttask->handle = 0;\n`;
-		c += `\ttask->done = 0;\n`;
-		c += `\ttask->result_slot = (unsigned long long)result_ptr;\n`;
-		c += `\ttask->cancel_flag = (unsigned long long)cancel_ptr;\n`;
-		c += `\ttask->future = (unsigned long long)f;\n`;
-		c += `\treturn task;\n`;
-	}
-	c += `}\n`;
-	if (!status.file_scope_c) status.file_scope_c = "";
-	status.file_scope_c += c;
-	emit_asm(status, `// thread start site ${id}\n`);
-	build_node(target, status);
-	ensure_newline(status);
-	if (nursery_off) {
-		const park = allocate_stack_space(status, 8, 8);
-		emit_asm(status, `str x0, [x29, #${park}]\n`);
-		emit_asm(status, `add x1, x29, #${nursery_off.futures_off}\n`);
-		emit_asm(status, `add x2, x29, #${nursery_off.count_off}\n`);
-		emit_asm(status, `add x3, x29, #${nursery_off.cap_off}\n`);
-		emit_asm(status, `ldr x0, [x29, #${park}]\n`);
-	}
-	emit_asm(status, `bl _${helper_name}\n`);
-}
-/**
-* Build a `.detach()` launch on a Thread construction — the daemon form
-* (ASYNC.md, "Daemon tasks"), aarch64 backend. The companion helper
-* releases the construction's unused future (detaching the closure from
-* it — the daemon runner owns the closure), hands the task to the detached
-* launcher, and marks the instance started; the assembly calls it.
-*/
-function build_thread_detach$1(access_func, target, status) {
-	ensure_concurrency_runtime_a64(status);
-	const id = status.spawn_counter ?? 0;
-	status.spawn_counter = id + 1;
-	const helper_name = `nomen_detach_${id}_start`;
-	const mono_thread = mono_type_name("Thread", [spawn_result_type_arg$5(access_func.function_return_type)]);
-	const target_is_temp = target.node_type === "func_call" && !!(target.is_thread_ctor || target.is_fiber_ctor);
-	let c = `// --- thread detach site ${id} ---\n`;
-	c += `void *${helper_name}(void *self) {\n`;
-	c += `\tstruct ${mono_thread} *t = (struct ${mono_thread} *)self;\n`;
-	c += `\tstruct nomen_future *unused = (struct nomen_future *)t->future;\n`;
-	c += `\tif (unused) {\n`;
-	c += `\t\tunused->owner_args = NULL;\n`;
-	c += `\t\t__nomen_future_release(unused);\n`;
-	c += `\t}\n`;
-	c += `\t__nomen_task_detach((struct nomen_closure *)t->task);\n`;
-	c += `\tt->task = 0;\n`;
-	c += `\tt->future = 0;\n`;
-	c += `\tt->result_slot = 0;\n`;
-	c += `\tt->cancel_flag = 0;\n`;
-	c += `\tt->started = 1;\n`;
-	if (target_is_temp) c += `\tfree(t);\n`;
-	c += `\treturn (void *)0;\n`;
-	c += `}\n`;
-	if (!status.file_scope_c) status.file_scope_c = "";
-	status.file_scope_c += c;
-	emit_asm(status, `// thread detach site ${id}\n`);
-	build_node(target, status);
-	ensure_newline(status);
-	emit_asm(status, `bl _${helper_name}\n`);
-}
-/** The launch's T as a Type: the stamped wrapped-call return type, with
-*  void coerced to uint64 (Task's result-slot convention). */
-function spawn_result_type_arg$5(return_type) {
-	return return_type?.name && return_type.name !== "void" && return_type.name !== "?" ? new Type(return_type.name) : new Type("uint64");
-}
-/**
 * Whether a spawn argument rides the fat-string (ptr, len) pair ABI: its
 * static type names `string`, or it is a string literal (whose ValueNode.type
 * may be unset). Mirrors arg_is_string in build_function_call_node.
@@ -10419,6 +10252,35 @@ function spawn_arg_is_string(node) {
 	const t = type_from_value_node$1(node);
 	return t?.name === "string" && !t.is_view && !t.is_array;
 }
+/**
+* Aarch64 backend: pull the concurrency runtime in
+* when this struct method's raw bodies reference it — keyed on body
+* content, never on a type name. See the C backend's
+* ensure_runtime_for_method.
+*/
+function ensure_runtime_for_method_a64(func, status) {
+	for (const stmt of func.statements ?? []) if (raw_bodies_reference_runtime$1(stmt)) {
+		ensure_concurrency_runtime_a64(status);
+		return;
+	}
+}
+function raw_bodies_reference_runtime$1(node) {
+	if (!node || typeof node !== "object") return false;
+	if (node.node_type === "raw") {
+		const raw = node.value;
+		return typeof raw === "string" && raw.includes("__nomen_");
+	}
+	for (const key of Object.keys(node)) {
+		if (key === "parent" || key === "scope") continue;
+		const v = node[key];
+		if (Array.isArray(v)) {
+			for (const item of v) if (raw_bodies_reference_runtime$1(item)) return true;
+		} else if (v && typeof v === "object" && "node_type" in v) {
+			if (raw_bodies_reference_runtime$1(v)) return true;
+		}
+	}
+	return false;
+}
 //#endregion
 //#region ../src/nir/from_ast.ts
 /**
@@ -11054,14 +10916,14 @@ function array_struct_name(type, status) {
 //#region ../src/build_common/scan_force_heap_strings.ts
 function scan_force_heap_strings(statements, structs) {
 	const result = /* @__PURE__ */ new Set();
-	walk$1(statements, result, structs);
+	walk$2(statements, result, structs);
 	return result;
 }
-function walk$1(statements, result, structs) {
+function walk$2(statements, result, structs) {
 	if (!statements) return;
-	for (const stmt of statements) visit(stmt, result, structs);
+	for (const stmt of statements) visit$1(stmt, result, structs);
 }
-function visit(node, result, structs) {
+function visit$1(node, result, structs) {
 	if (!node) return;
 	switch (node.node_type) {
 		case "assign": {
@@ -11070,7 +10932,7 @@ function visit(node, result, structs) {
 				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);
 			}
-			visit(a.right_value, result, structs);
+			visit$1(a.right_value, result, structs);
 			break;
 		}
 		case "access": {
@@ -11083,30 +10945,37 @@ function visit(node, result, structs) {
 		}
 		case "while":
 		case "for":
-			walk$1(node.statements, result, structs);
+			walk$2(node.statements, result, structs);
+			break;
+		case "async_block":
+			walk$2(node.statements, result, structs);
 			break;
 		case "if": {
 			const n = node;
-			walk$1(n.if_branch?.statements, result, structs);
-			walk$1(n.else_branch?.statements, result, structs);
+			walk$2(n.if_branch?.statements, result, structs);
+			walk$2(n.else_branch?.statements, result, structs);
 			break;
 		}
 		case "switch": {
 			const n = node;
-			for (const c of n.cases) walk$1(c.branch?.statements, result, structs);
-			walk$1(n.else_branch?.statements, result, structs);
+			for (const c of n.cases) walk$2(c.branch?.statements, result, structs);
+			walk$2(n.else_branch?.statements, result, structs);
 			break;
 		}
 		case "match": {
 			const m = node;
-			for (const c of m.cases ?? []) walk$1(c.branch?.statements, result, structs);
-			walk$1(m.else_branch?.statements, result, structs);
+			for (const c of m.cases ?? []) walk$2(c.branch?.statements, result, structs);
+			walk$2(m.else_branch?.statements, result, structs);
 			break;
 		}
 	}
 }
 function is_fresh_heap_string(node) {
 	if (!node) return false;
+	if (node.node_type === "access") {
+		const access = node.access;
+		if (access.node_type === "access_func" && access.name === "to_string") return true;
+	}
 	if (node.type?.name !== "string") return false;
 	if (node.node_type === "op") return true;
 	if (node.node_type === "func_call") return true;
@@ -11249,6 +11118,61 @@ function receiver_escapes(func, owner_struct_name, state) {
 	return escapes;
 }
 //#endregion
+//#region ../src/build_common/scan_reassigned_vars.ts
+/**
+* Collect the names reassigned anywhere in a function body (any nested
+* scope). The aarch64 string-concat constant folder (`resolve_string_value`)
+* resolves a variable operand to its DECLARATION initializer; that is only
+* sound while the variable still holds it. Once the name is reassigned, the
+* fold must be suppressed (`var tag = ""; tag = f(); "</" + tag + ">"` folded
+* to `"</>"` using the stale `""`).
+*/
+function scan_reassigned_vars(statements) {
+	const result = /* @__PURE__ */ new Set();
+	walk$1(statements, result);
+	return result;
+}
+function walk$1(statements, result) {
+	if (!statements) return;
+	for (const stmt of statements) visit(stmt, result);
+}
+function visit(node, result) {
+	if (!node) return;
+	switch (node.node_type) {
+		case "assign": {
+			const a = node;
+			if (a.left_value.node_type === "value") {
+				const name = a.left_value.value;
+				if (typeof name === "string") result.add(name);
+			} else if (a.left_value.node_type === "access") a.left_value;
+			visit(a.right_value, result);
+			break;
+		}
+		case "while":
+		case "for":
+			walk$1(node.statements, result);
+			break;
+		case "if": {
+			const n = node;
+			walk$1(n.if_branch?.statements, result);
+			walk$1(n.else_branch?.statements, result);
+			break;
+		}
+		case "switch": {
+			const n = node;
+			for (const c of n.cases) walk$1(c.branch?.statements, result);
+			walk$1(n.else_branch?.statements, result);
+			break;
+		}
+		case "match": {
+			const m = node;
+			for (const c of m.cases ?? []) walk$1(c.branch?.statements, result);
+			walk$1(m.else_branch?.statements, result);
+			break;
+		}
+	}
+}
+//#endregion
 //#region ../src/build_aarch64/build_extern.ts
 /**
 * Emit an `extern func` for the aarch64 backend: a fixed-shape adapter that
@@ -11371,6 +11295,19 @@ function raw_reload_lines_for(code, plan, current_length) {
 	return out;
 }
 //#endregion
+//#region ../src/build_aarch64/utils/aarch64_size.ts
+/**
+* Storage width of a value of `type` in bytes, derived from the
+* built-in type table (see BuiltInTypeInfo.bytes). Non-built-in names are
+* structs/enums/generics — 8 unless overridden by struct layout. `string`
+* is the fat 16-byte { char* ptr; long len; } pair; in registers it rides
+* as a consecutive (ptr, len) pair — the same ABI `view T` uses.
+*/
+function aarch64_size(type) {
+	if (type === "string") return 16;
+	return get_built_in_type(type)?.bytes ?? 8;
+}
+//#endregion
 //#region ../src/build_aarch64/utils/struct_layout.ts
 const VT_SIZE = 8;
 /**
@@ -12595,6 +12532,173 @@ function cset_flag_is_write_only(ctx, name) {
 	return ctx.write_only?.has(name) ?? false;
 }
 //#endregion
+//#region ../src/build_aarch64/utils/stack_var.ts
+function allocate_stack_space(status, size, alignment = 8) {
+	if (!status.stack_size) status.stack_size = 0;
+	const aligned_size = Math.ceil(status.stack_size / alignment) * alignment;
+	status.stack_size = aligned_size + size;
+	return aligned_size;
+}
+/**
+* Load a stack slot into a promoted (callee-saved) register with the slot's
+* width. A sub-word slot (bool/char/int8 = strb, int16 = strh, int32 = str w)
+* must be loaded with the matching zero-extending ldrb/ldrh/ldr w — a
+* full-width `ldr` picks up dirty stack bytes above the slot and a bool can
+* read as true regardless of its stored value.
+*/
+function emit_promoted_load(status, reg, offset, type_name) {
+	const size = aarch64_size(type_name);
+	if (size === 1) emit_asm(status, `ldrb ${reg.replace("x", "w")}, [x29, #${offset}]\n`);
+	else if (size === 2) emit_asm(status, `ldrh ${reg.replace("x", "w")}, [x29, #${offset}]\n`);
+	else if (size === 4) emit_asm(status, `ldr ${reg.replace("x", "w")}, [x29, #${offset}]\n`);
+	else emit_asm(status, `ldr ${reg}, [x29, #${offset}]\n`);
+}
+/**
+* Write a promoted (callee-saved) register back to its stack slot with the
+* slot's width. A full-width `str` into a sub-word slot clobbers the adjacent
+* stack bytes — whatever variable lives there gets corrupted.
+*/
+function emit_promoted_store(status, reg, offset, type_name) {
+	const size = aarch64_size(type_name);
+	if (size === 1) emit_asm(status, `strb ${reg.replace("x", "w")}, [x29, #${offset}]\n`);
+	else if (size === 2) emit_asm(status, `strh ${reg.replace("x", "w")}, [x29, #${offset}]\n`);
+	else if (size === 4) emit_asm(status, `str ${reg.replace("x", "w")}, [x29, #${offset}]\n`);
+	else emit_asm(status, `str ${reg}, [x29, #${offset}]\n`);
+}
+function is_local_ref_var(name, status) {
+	return !!status.function_ref_params?.has(name) && !status.function_param_regs?.has(name);
+}
+function emit_var_address(status, reg, name) {
+	if (status.closure_env_offsets?.has(name) && status.closure_env_slot !== void 0) {
+		emit_asm(status, `ldr ${reg}, [x29, #${status.closure_env_slot}]\n`);
+		const off = status.closure_env_offsets.get(name);
+		if (off !== 0) emit_asm(status, `add ${reg}, ${reg}, #${off}\n`);
+		return;
+	}
+	const alloc_reg = status.register_allocations?.get(name);
+	if (alloc_reg) {
+		const offset = status.stack_offsets?.get(name);
+		if (offset !== void 0) {
+			const type_name = status.scoped_declarations.find((d) => d.name === name)?.type?.name || status.variable_types?.get(name)?.name || "";
+			if (type_name) emit_promoted_store(status, alloc_reg, offset, type_name);
+			else emit_asm(status, `str ${alloc_reg}, [x29, #${offset}]\n`);
+		}
+	}
+	const offset = status.stack_offsets?.get(name);
+	if (offset !== void 0) {
+		if (status.function_struct_param_slots?.has(name)) emit_asm(status, `ldr ${reg}, [x29, #${offset}]\n`);
+		else emit_asm(status, `add ${reg}, x29, #${offset}\n`);
+	} else {
+		const param_reg = status.function_param_regs?.get(name);
+		if (param_reg) emit_asm(status, `mov ${reg}, ${param_reg}\n`);
+		else emit_asm(status, `adr ${reg}, ${name}\n`);
+	}
+}
+function emit_deref_var_address(status, reg, name) {
+	emit_var_address(status, reg, name);
+	if (is_local_ref_var(name, status)) emit_asm(status, `ldr ${reg}, [${reg}]\n`);
+}
+function emit_var_load(status, reg, name, size) {
+	if (name === "null") {
+		emit_asm(status, `mov ${reg}, #0\n`);
+		return;
+	}
+	if (status.closure_env_offsets?.has(name) && status.closure_env_slot !== void 0) {
+		const off = status.closure_env_offsets.get(name);
+		emit_asm(status, `ldr ${reg}, [x29, #${status.closure_env_slot}]\n`);
+		if (size === 16 && reg.startsWith("x")) {
+			emit_asm(status, `ldr x${parseInt(reg.substring(1), 10) + 1}, [${reg}, #${off + 8}]\n`);
+			emit_asm(status, `ldr ${reg}, [${reg}, #${off}]\n`);
+		} else if (size === 1) emit_asm(status, `ldrb ${reg.replace("x", "w")}, [${reg}, #${off}]\n`);
+		else if (size === 2) emit_asm(status, `ldrh ${reg.replace("x", "w")}, [${reg}, #${off}]\n`);
+		else if (size === 4) emit_asm(status, `ldr ${reg.replace("x", "w")}, [${reg}, #${off}]\n`);
+		else emit_asm(status, `ldr ${reg}, [${reg}, #${off}]\n`);
+		return;
+	}
+	const alloc_reg = status.register_allocations?.get(name);
+	if (alloc_reg) {
+		if (alloc_reg.startsWith("d") && reg.startsWith("d")) {
+			if (reg !== alloc_reg) emit_asm(status, `fmov ${reg}, ${alloc_reg}\n`);
+		} else if (alloc_reg.startsWith("d")) emit_asm(status, `fmov ${reg}, ${alloc_reg}\n`);
+		else if (reg !== alloc_reg) emit_asm(status, `mov ${reg}, ${alloc_reg}\n`);
+		return;
+	}
+	const offset = status.stack_offsets?.get(name);
+	if (offset !== void 0) {
+		if (size === 16 && reg.startsWith("x")) {
+			const n = parseInt(reg.substring(1), 10);
+			if (offset + 8 > 504) {
+				emit_asm(status, `ldr ${reg}, [x29, #${offset}]\n`);
+				emit_asm(status, `ldr x${n + 1}, [x29, #${offset + 8}]\n`);
+			} else emit_asm(status, `ldp ${reg}, x${n + 1}, [x29, #${offset}]\n`);
+			return;
+		}
+		if (size === 1) emit_asm(status, `ldrb ${reg.replace("x", "w")}, [x29, #${offset}]\n`);
+		else if (size === 2) emit_asm(status, `ldrh ${reg.replace("x", "w")}, [x29, #${offset}]\n`);
+		else if (size === 4) emit_asm(status, `ldr ${reg.replace("x", "w")}, [x29, #${offset}]\n`);
+		else emit_asm(status, `ldr ${reg}, [x29, #${offset}]\n`);
+	} else {
+		const param_reg = status.function_param_regs?.get(name);
+		if (param_reg) {
+			if (reg !== param_reg) emit_asm(status, `mov ${reg}, ${param_reg}\n`);
+		} else {
+			emit_asm(status, `adr ${reg}, ${name}\n`);
+			if (size === 1) emit_asm(status, `ldrb ${reg.replace("x", "w")}, [${reg}]\n`);
+			else if (size === 2) emit_asm(status, `ldrh ${reg.replace("x", "w")}, [${reg}]\n`);
+			else if (size === 4) emit_asm(status, `ldr ${reg.replace("x", "w")}, [${reg}]\n`);
+			else emit_asm(status, `ldr ${reg}, [${reg}]\n`);
+		}
+	}
+}
+function emit_var_store(status, reg, name, size) {
+	if (status.closure_env_offsets?.has(name) && status.closure_env_slot !== void 0) {
+		const off = status.closure_env_offsets.get(name);
+		emit_asm(status, `ldr x9, [x29, #${status.closure_env_slot}]\n`);
+		if (size === 16 && reg.startsWith("x")) {
+			const n = parseInt(reg.substring(1), 10);
+			emit_asm(status, `str ${reg}, [x9, #${off}]\n`);
+			emit_asm(status, `str x${n + 1}, [x9, #${off + 8}]\n`);
+		} else if (size === 1) emit_asm(status, `strb ${reg.replace("x", "w")}, [x9, #${off}]\n`);
+		else if (size === 2) emit_asm(status, `strh ${reg.replace("x", "w")}, [x9, #${off}]\n`);
+		else if (size === 4) emit_asm(status, `str ${reg.replace("x", "w")}, [x9, #${off}]\n`);
+		else emit_asm(status, `str ${reg}, [x9, #${off}]\n`);
+		return;
+	}
+	const alloc_reg = status.register_allocations?.get(name);
+	if (alloc_reg) {
+		if (alloc_reg.startsWith("d") && reg.startsWith("d")) {
+			if (reg !== alloc_reg) emit_asm(status, `fmov ${alloc_reg}, ${reg}\n`);
+		} else if (alloc_reg.startsWith("d")) emit_asm(status, `fmov ${alloc_reg}, ${reg}\n`);
+		else if (reg !== alloc_reg) emit_asm(status, `mov ${alloc_reg}, ${reg}\n`);
+		return;
+	}
+	const offset = status.stack_offsets?.get(name);
+	if (offset !== void 0) {
+		if (size === 16 && reg.startsWith("x")) {
+			const n = parseInt(reg.substring(1), 10);
+			if (offset + 8 > 504) {
+				emit_asm(status, `str ${reg}, [x29, #${offset}]\n`);
+				emit_asm(status, `str x${n + 1}, [x29, #${offset + 8}]\n`);
+			} else emit_asm(status, `stp ${reg}, x${n + 1}, [x29, #${offset}]\n`);
+			return;
+		}
+		if (size === 1) emit_asm(status, `strb ${reg.replace("x", "w")}, [x29, #${offset}]\n`);
+		else if (size === 2) emit_asm(status, `strh ${reg.replace("x", "w")}, [x29, #${offset}]\n`);
+		else if (size === 4) emit_asm(status, `str ${reg.replace("x", "w")}, [x29, #${offset}]\n`);
+		else emit_asm(status, `str ${reg}, [x29, #${offset}]\n`);
+	} else {
+		const param_reg = status.function_param_regs?.get(name);
+		if (param_reg) emit_asm(status, `mov ${param_reg}, ${reg}\n`);
+		else {
+			emit_asm(status, `adr x1, ${name}\n`);
+			if (size === 1) emit_asm(status, `strb ${reg.replace("x", "w")}, [x1]\n`);
+			else if (size === 2) emit_asm(status, `strh ${reg.replace("x", "w")}, [x1]\n`);
+			else if (size === 4) emit_asm(status, `str ${reg.replace("x", "w")}, [x1]\n`);
+			else emit_asm(status, `str ${reg}, [x1]\n`);
+		}
+	}
+}
+//#endregion
 //#region ../src/build_aarch64/slp_pair.ts
 /**
 * Field-pair SLP (ASM_PLAN_4 remaining step 1 — the PLAN_3 D-step-2
@@ -13641,14 +13745,32 @@ function emit_destroy_for_anchor_slot(status, offset, type_name, type_args, is_n
 	emit_field_destroys_from_slot(status, struct_type, offset);
 	if (skip_label) emit_asm(status, `${skip_label}:\n`);
 }
+/**
+* Load the address of the sub-object at accumulated offset `acc` from the
+* object rooted at frame slot `root_slot` into x0. A CLASS root is a pointer
+* stored in the slot; a VALUE-struct root is inline AT the slot. Nested
+* value-struct fields keep accumulating offsets from that single base — they
+* are never re-addressed as if each nested field had its own frame slot. (The
+* old bug loaded `[x29, root_slot + field_offset]` for a heap class's inline
+* `List` field, feeding a garbage buffer header to the destroy loop.)
+*/
+function emit_slot_base(status, root_slot, root_is_class, acc) {
+	if (root_is_class) emit_asm(status, `ldr x0, [x29, #${root_slot}]\n`);
+	else emit_asm(status, `add x0, x29, #${root_slot}\n`);
+	if (acc !== 0) emit_asm(status, `add x0, x0, #${acc}\n`);
+}
 function emit_field_destroys_from_slot(status, struct_type, base_offset) {
+	emit_field_destroys_at(status, struct_type, base_offset, 0, !!struct_type.is_class);
+}
+function emit_field_destroys_at(status, struct_type, root_slot, acc, root_is_class) {
 	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);
+		const field_acc = acc + offset;
 		if (field_struct) {
 			if (field_struct.is_class && !field.type.is_ref) {
-				emit_asm(status, `ldr x0, [x29, #${base_offset}]\n`);
-				emit_asm(status, `ldr x0, [x0, #${offset}]\n`);
+				emit_slot_base(status, root_slot, root_is_class, field_acc);
+				emit_asm(status, `ldr x0, [x0]\n`);
 				emit_asm(status, `str x0, [sp, #-16]!\n`);
 				const skip_label = `.Lskip_defer_${status.label_counter = (status.label_counter ?? 0) + 1}`;
 				emit_asm(status, `cbz x0, ${skip_label}\n`);
@@ -13657,32 +13779,17 @@ function emit_field_destroys_from_slot(status, struct_type, base_offset) {
 				emit_asm(status, `ldr x0, [sp], #16\n`);
 				emit_free(status);
 			} else if (has_destroy(field_struct)) {
-				emit_asm(status, `ldr x0, [x29, #${base_offset}]\n`);
-				emit_asm(status, `add x0, x0, #${offset}\n`);
+				emit_slot_base(status, root_slot, root_is_class, field_acc);
 				emit_asm(status, `bl ${resolve_struct_name(field_struct.name, field.type.type_args, status)}_destroy\n`);
 			}
-			emit_nested_field_destroys_from_slot(status, field_struct, base_offset + offset);
+			emit_field_destroys_at(status, field_struct, root_slot, field_acc, root_is_class);
 		} else if (field.type.name === "string" && !field.type.is_array && !field.type.is_ref && !field.type.is_view) {
-			emit_asm(status, `ldr x0, [x29, #${base_offset}]\n`);
-			emit_asm(status, `ldr x0, [x0, #${offset}]\n`);
+			emit_slot_base(status, root_slot, root_is_class, field_acc);
+			emit_asm(status, `ldr x0, [x0]\n`);
 			emit_free(status);
 		}
 	}
 }
-function emit_nested_field_destroys_from_slot(status, struct_type, 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_asm(status, `ldr x0, [x29, #${base_offset}]\n`);
-				emit_asm(status, `add x0, x0, #${offset}\n`);
-				emit_asm(status, `bl ${resolve_struct_name(field_struct.name, field.type.type_args, status)}_destroy\n`);
-			}
-			emit_nested_field_destroys_from_slot(status, field_struct, base_offset + offset);
-		}
-	}
-}
 /**
 * Free an anchor slot, running its deferred destroy (if any) first.
 */
@@ -18963,6 +19070,7 @@ function build_function_node$1(node, status) {
 	if (check_c_fallback(node, void 0, status)) return;
 	const old_function_name = status.current_function_name;
 	status.current_function_name = emission_label(node);
+	status.function_nursery_depth = status.nursery_stack?.length ?? 0;
 	const old_scoped_declarations = status.scoped_declarations;
 	status.scoped_declarations = [];
 	status.last_result_is_heap = false;
@@ -19133,6 +19241,7 @@ function build_function_node$1(node, status) {
 	const old_ref_class_slots = status.ref_class_slots;
 	const old_struct_param_slots = status.function_struct_param_slots;
 	const old_function_param_types = status.function_param_types;
+	const old_function_local_types = status.function_local_types;
 	status.function_param_regs = /* @__PURE__ */ new Map();
 	status.function_param_vars = /* @__PURE__ */ new Set();
 	status.function_array_params = /* @__PURE__ */ new Set();
@@ -19140,6 +19249,7 @@ function build_function_node$1(node, status) {
 	status.ref_class_slots = /* @__PURE__ */ new Map();
 	status.function_struct_param_slots = /* @__PURE__ */ new Set();
 	status.function_param_types = /* @__PURE__ */ new Map();
+	status.function_local_types = /* @__PURE__ */ new Map();
 	const old_variadic_params_aarch64 = status.function_variadic_params;
 	const old_view_params = status.function_view_params;
 	status.function_variadic_params = /* @__PURE__ */ new Set();
@@ -19387,6 +19497,8 @@ function build_function_node$1(node, status) {
 	}
 	const old_force_heap = status.force_heap_strings;
 	status.force_heap_strings = scan_force_heap_strings(node.statements, status.structs);
+	const old_reassigned_vars = status.reassigned_vars;
+	status.reassigned_vars = scan_reassigned_vars(node.statements);
 	const old_buffer_data_cache = status.buffer_data_cache;
 	status.buffer_data_cache = void 0;
 	const old_array_ptr_cache = status.array_ptr_cache;
@@ -19421,6 +19533,7 @@ function build_function_node$1(node, status) {
 	status.buffer_data_cache = old_buffer_data_cache;
 	status.array_ptr_cache = old_array_ptr_cache;
 	status.force_heap_strings = old_force_heap;
+	status.reassigned_vars = old_reassigned_vars;
 	const loop_regs_used = status.callee_saved_regs_used ? [...status.callee_saved_regs_used].sort() : [];
 	status.callee_saved_regs_used = old_callee_saved_regs;
 	status.register_allocations = old_register_allocations;
@@ -19544,6 +19657,7 @@ function build_function_node$1(node, status) {
 	status.ref_class_slots = old_ref_class_slots;
 	status.function_struct_param_slots = old_struct_param_slots;
 	status.function_param_types = old_function_param_types;
+	status.function_local_types = old_function_local_types;
 	status.function_variadic_params = old_variadic_params_aarch64;
 	status.function_view_params = old_view_params;
 	status.function_return_label = old_return_label;
@@ -19788,10 +19902,7 @@ function resolve_global_const_value(name, status) {
 function build_struct_node$1(node, status) {
 	if (node.is_generic) return;
 	const is_nested = !!status.function_return_label;
-	if (node.name === "Fiber" || node.name === "Thread") {
-		ensure_concurrency_runtime_a64(status);
-		status.used_fibers = true;
-	}
+	for (const func of node.functions) ensure_runtime_for_method_a64(func, status);
 	let old_code;
 	if (is_nested) {
 		old_code = status.code;
@@ -20172,14 +20283,18 @@ function build_init_function(node, status) {
 			}
 			emit_typed_store(status, "x1", "x19", offset, get_type_size(field.type, status));
 		} else if (field.value.node_type === "func_call") {
-			if (status.structs.find((s) => s.name === field.type.name && !s.is_simple_type)) {
+			const field_struct = status.structs.find((s) => s.name === field.type.name && !s.is_simple_type);
+			if (field_struct) {
 				build_node(field.value, status);
 				ensure_newline(status);
-				const field_size = get_struct_size(field.type.name, status);
-				const words = Math.ceil(field_size / 8);
-				for (let w = 0; w < words; w++) {
-					emit_asm(status, `ldr x9, [x0, #${w * 8}]\n`);
-					emit_asm(status, `str x9, [x19, #${offset + w * 8}]\n`);
+				if (field_struct.is_class) emit_typed_store(status, "x0", "x19", offset, 8);
+				else {
+					const field_size = get_struct_size(field.type.name, status);
+					const words = Math.ceil(field_size / 8);
+					for (let w = 0; w < words; w++) {
+						emit_asm(status, `ldr x9, [x0, #${w * 8}]\n`);
+						emit_asm(status, `str x9, [x19, #${offset + w * 8}]\n`);
+					}
 				}
 			}
 		} else if (field.value.node_type === "func" && field.type.name === "func") {
@@ -20390,14 +20505,18 @@ function build_custom_init_function(node, func, status) {
 			}
 			emit_typed_store(status, "x1", "x19", offset, get_type_size(field.type, status));
 		} else if (field.value.node_type === "func_call") {
-			if (status.structs.find((s) => s.name === field.type.name && !s.is_simple_type)) {
+			const field_struct = status.structs.find((s) => s.name === field.type.name && !s.is_simple_type);
+			if (field_struct) {
 				build_node(field.value, status);
 				ensure_newline(status);
-				const field_size = get_struct_size(field.type.name, status);
-				const words = Math.ceil(field_size / 8);
-				for (let w = 0; w < words; w++) {
-					emit_asm(status, `ldr x9, [x0, #${w * 8}]\n`);
-					emit_asm(status, `str x9, [x19, #${offset + w * 8}]\n`);
+				if (field_struct.is_class) emit_typed_store(status, "x0", "x19", offset, 8);
+				else {
+					const field_size = get_struct_size(field.type.name, status);
+					const words = Math.ceil(field_size / 8);
+					for (let w = 0; w < words; w++) {
+						emit_asm(status, `ldr x9, [x0, #${w * 8}]\n`);
+						emit_asm(status, `str x9, [x19, #${offset + w * 8}]\n`);
+					}
 				}
 			}
 		}
@@ -20451,6 +20570,7 @@ function build_custom_init_function(node, func, status) {
 }
 function build_struct_functions$1(node, status) {
 	for (const func of node.functions) {
+		if (func.name === "#spawn") continue;
 		if (func.name === "#init" && !func.has_body) continue;
 		if (func.name === "#init" && func.has_body) {
 			if (!check_c_fallback(func, node.name, status)) build_custom_init_function(node, func, status);
@@ -20481,6 +20601,7 @@ function build_struct_functions$1(node, status) {
 		const old_param_vars = status.function_param_vars;
 		const old_return_label = status.function_return_label;
 		const old_force_heap = status.force_heap_strings;
+		const old_reassigned_vars = status.reassigned_vars;
 		const old_function_name = status.current_function_name;
 		const old_register_allocations = status.register_allocations;
 		const old_nir_site_allocs = status.nir_site_allocs;
@@ -20572,7 +20693,7 @@ function build_struct_functions$1(node, status) {
 				slot_idx += 2;
 				continue;
 			}
-			if ((!!status.structs.find((s) => s.name === param.type.name && !s.is_simple_type) || !!status.enums.find((e) => e.name === param.type.name && e.has_associated_data)) && callee_idx < callee_saved.length) {
+			if ((!!status.structs.find((s) => s.name === param.type.name && !s.is_simple_type) || !!status.enums.find((e) => e.name === param.type.name && e.has_associated_data) || !!status.traits.find((t) => t.name === param.type.name)) && callee_idx < callee_saved.length) {
 				const saved_reg = callee_saved[callee_idx++];
 				if (saved_reg !== "x19" || !needs_x19) emit_asm(status, `str ${saved_reg}, [sp, #-16]!\n`);
 				if (slot_idx < 8) emit_asm(status, `mov ${saved_reg}, ${param_regs[slot_idx]}\n`);
@@ -20650,7 +20771,7 @@ function build_struct_functions$1(node, status) {
 				second_slot_idx += 2;
 				continue;
 			}
-			if (!(!!status.structs.find((s) => s.name === param.type.name && !s.is_simple_type) || !!status.enums.find((e) => e.name === param.type.name && e.has_associated_data))) {
+			if (!(!!status.structs.find((s) => s.name === param.type.name && !s.is_simple_type) || !!status.enums.find((e) => e.name === param.type.name && e.has_associated_data) || !!status.traits.find((t) => t.name === param.type.name))) {
 				const is_ref = param.type.is_ref;
 				const size = is_ref ? 8 : aarch64_size(param.type.name);
 				const offset = allocate_stack_space(status, size, is_ref ? 8 : size);
@@ -20735,6 +20856,7 @@ function build_struct_functions$1(node, status) {
 			}
 		}
 		status.force_heap_strings = scan_force_heap_strings(func.statements, status.structs);
+		status.reassigned_vars = scan_reassigned_vars(func.statements);
 		status.buffer_data_cache = void 0;
 		status.array_ptr_cache = void 0;
 		const moved_before = new Set(status.moved ?? []);
@@ -20820,6 +20942,7 @@ function build_struct_functions$1(node, status) {
 		status.function_view_params = old_view_params;
 		status.function_return_label = old_return_label;
 		status.force_heap_strings = old_force_heap;
+		status.reassigned_vars = old_reassigned_vars;
 		status.struct_return_buffer = void 0;
 		status.function_return_type = void 0;
 		status.current_function_name = old_function_name;
@@ -22070,6 +22193,7 @@ function resolve_string_value(node, status) {
 	if (node.node_type === "value") {
 		const val = node.value;
 		if (val.startsWith("\"") && val.endsWith("\"")) return val;
+		if (status.reassigned_vars?.has(val)) return null;
 		const decl = status.scoped_declarations.find((d) => d.name === val);
 		if (decl && decl.value) return resolve_string_value(decl.value, status);
 	}
@@ -22122,6 +22246,10 @@ function nir_array_element(nir, arr, i) {
 	return nir?.kind === "call" && nir.node === arr ? nir.facts.args[i] : void 0;
 }
 function build_declaration_node$1(node, status, nir_init, nir_swap) {
+	if (node.name && node.type?.name) {
+		if (!status.function_local_types) status.function_local_types = /* @__PURE__ */ new Map();
+		status.function_local_types.set(node.name, node.type.name);
+	}
 	hoist_field_overrides(node.value, build_node, status, "", node.name);
 	status.last_result_is_heap = false;
 	const prev_heap = status.last_result_is_heap;
@@ -23807,6 +23935,7 @@ function promote_loop_locals(status, scoped_declarations, sources, options) {
 				if (!ptype.name || !SCALAR_TYPES.includes(ptype.name) || ptype.is_array || ptype.is_view || ptype.is_ref || ptype.is_nullable) continue;
 				type_name = ptype.name;
 			}
+			if (status.function_local_types?.get(name) === "string") continue;
 		}
 		let offset = status.stack_offsets?.get(name);
 		if (offset === void 0) {
@@ -24250,18 +24379,24 @@ function build_if_else_node$1(node, status, nir) {
 	const pre_cache = status.buffer_data_cache;
 	const pre_array_cache = status.array_ptr_cache;
 	if (node.else_branch) {
+		const then_frame = enter_scope_frame(status);
 		status.buffer_data_cache = new Map(pre_cache);
 		status.array_ptr_cache = new Map(pre_array_cache);
 		build_block_with_cursor$1(node.if_branch, nir?.then_branch, status);
+		exit_scope_frame(status, then_frame);
 		emit_asm(status, `b end_${label}\n`);
 		emit_asm(status, `else_${label}:\n`);
+		const else_frame = enter_scope_frame(status);
 		status.buffer_data_cache = new Map(pre_cache);
 		status.array_ptr_cache = new Map(pre_array_cache);
 		build_block_with_cursor$1(node.else_branch, nir?.else_branch, status);
+		exit_scope_frame(status, else_frame);
 	} else if (node.if_branch) {
+		const then_frame = enter_scope_frame(status);
 		status.buffer_data_cache = new Map(pre_cache);
 		status.array_ptr_cache = new Map(pre_array_cache);
 		build_block_with_cursor$1(node.if_branch, nir?.then_branch, status);
+		exit_scope_frame(status, then_frame);
 	}
 	status.buffer_data_cache = pre_cache;
 	status.array_ptr_cache = pre_array_cache;
@@ -24483,6 +24618,7 @@ function build_return_node$1(node, status, nir_value) {
 			emit_asm(status, `ldr x8, [x29, #${status.return_buffer_stack_offset}]\n`);
 			emit_asm(status, `str xzr, [x8, #${struct_size}]\n`);
 		}
+		emit_nursery_joins_on_return_a64(status);
 		const finalized = status.moved ?? /* @__PURE__ */ new Set();
 		for (const decl of all_scope_frames(status).flat()) {
 			if (finalized.has(decl.name)) {
@@ -24502,6 +24638,7 @@ function build_return_node$1(node, status, nir_value) {
 			emit_asm(status, `mov x0, #0\n`);
 			emit_var_store(status, "x0", status.return_assign, size);
 		} else if (status.function_return_label) {
+			emit_nursery_joins_on_return_a64(status);
 			const finalized = status.moved ?? /* @__PURE__ */ new Set();
 			for (const decl of all_scope_frames(status).flat()) {
 				if (finalized.has(decl.name)) {
@@ -24620,7 +24757,7 @@ function build_return_node$1(node, status, nir_value) {
 			const raw_value = node.value.value;
 			const is_str_lit = raw_value.length >= 2 && raw_value.startsWith("\"") && raw_value.endsWith("\"");
 			const is_numeric = /^(\+|-)?\d+$/.test(raw_value);
-			if (!is_str_lit && !is_numeric && !status.heap_strings?.has(raw_value)) needs_borrow_strdup = true;
+			if (!is_str_lit && !is_numeric && raw_value !== "null" && !status.heap_strings?.has(raw_value)) needs_borrow_strdup = true;
 		} else if (is_container_borrow_access(node.value)) needs_borrow_strdup = true;
 		else if (node.value.node_type === "access" && node.value.access.node_type === "access_field") needs_borrow_strdup = true;
 		else if ((node.value.node_type === "match" || node.value.node_type === "switch") && !return_join_owned_string) needs_borrow_strdup = true;
@@ -24731,6 +24868,7 @@ function build_return_node$1(node, status, nir_value) {
 		if (returns_fat_pair) emit_asm(status, `stp x0, x1, [sp, #-16]!\n`);
 		else if (returns_float) emit_asm(status, `str d0, [sp, #-16]!\n`);
 		else emit_asm(status, `str x0, [sp, #-16]!\n`);
+		emit_nursery_joins_on_return_a64(status);
 		for (const decl of all_scope_frames(status).flat()) {
 			if (finalized.has(decl.name)) {
 				release_heap_string_fields(status, decl.name, decl.type.name);
@@ -26485,7 +26623,7 @@ function emit_stmt_dispatch(child, index, statements, status) {
 				const eval_node = nstmt.expr.node;
 				if (eval_node.node_type === "access") {
 					const inner = eval_node.access;
-					if (inner.node_type === "access_func" && (inner.is_nursery_spawn || inner.is_thread_start || inner.is_thread_detach || inner.is_fiber_start)) inner.is_statement = true;
+					if (inner.node_type === "access_func" && inner.is_nursery_spawn) inner.is_statement = true;
 				}
 				const restore_eval = apply_forward_use(ctx.use_sites, nstmt.expr.node);
 				try {
@@ -26891,7 +27029,7 @@ function emit_expr_from_nir$1(expr, status) {
 function build_async_block_node$1(node, status, nir) {
 	const id = status.spawn_counter ?? 0;
 	status.spawn_counter = id + 1;
-	if (node.mode === "race") ensure_concurrency_runtime_a64(status);
+	ensure_concurrency_runtime_a64(status);
 	const futures_off = allocate_stack_space(status, 8, 8);
 	const count_off = allocate_stack_space(status, 8, 8);
 	const cap_off = allocate_stack_space(status, 8, 8);
@@ -26913,28 +27051,6 @@ function build_async_block_node$1(node, status, nir) {
 	let deadline_off;
 	if (node.timeout) {
 		deadline_off = allocate_stack_space(status, 8, 8);
-		emit_asm(status, `mov x0, #-1\n`);
-		emit_asm(status, `str x0, [x29, #${deadline_off}]\n`);
-	}
-	if (!status.nursery_offsets) status.nursery_offsets = /* @__PURE__ */ new Map();
-	status.nursery_offsets.set(id, {
-		futures_off,
-		count_off,
-		cap_off,
-		deadline_off
-	});
-	status.nursery_stack ??= [];
-	status.nursery_stack.push(id);
-	const old_scoped_declarations = status.scoped_declarations;
-	status.scoped_declarations = [];
-	build_block_with_cursor$1(node, nir?.body, status);
-	status.scoped_declarations = old_scoped_declarations;
-	status.nursery_stack.pop();
-	status.nursery_offsets.delete(id);
-	emit_asm(status, `// nursery ${id}: join all futures\n`);
-	emit_asm(status, `ldr x20, [x29, #${futures_off}]\n`);
-	emit_asm(status, `ldr w22, [x29, #${count_off}]\n`);
-	if (deadline_off !== void 0) {
 		emit_asm(status, `// Compute deadline: now + timeout_ms\n`);
 		build_node(node.timeout, status);
 		ensure_newline(status);
@@ -26955,11 +27071,57 @@ function build_async_block_node$1(node, status, nir) {
 		emit_asm(status, `add x0, x1, x0\n`);
 		emit_asm(status, `str x0, [x29, #${deadline_off}]\n`);
 	}
-	emit_asm(status, `mov x23, #0\n`);
-	const loop_start = `__nursery_${id}_join_start`;
-	const loop_end = `__nursery_${id}_join_end`;
-	const loop_release = `__nursery_${id}_release`;
-	const is_race = node.mode === "race";
+	if (!status.nursery_offsets) status.nursery_offsets = /* @__PURE__ */ new Map();
+	status.nursery_offsets.set(id, {
+		futures_off,
+		count_off,
+		cap_off,
+		deadline_off
+	});
+	if (!status.nursery_meta) status.nursery_meta = /* @__PURE__ */ new Map();
+	status.nursery_meta.set(id, {
+		mode: node.mode ?? "all",
+		has_deadline: !!node.timeout
+	});
+	status.nursery_stack ??= [];
+	status.nursery_stack.push(id);
+	const old_scoped_declarations = status.scoped_declarations;
+	status.scoped_declarations = [];
+	build_block_with_cursor$1(node, nir?.body, status);
+	status.scoped_declarations = old_scoped_declarations;
+	status.nursery_stack.pop();
+	emit_asm(status, `// nursery ${id}: join all futures\n`);
+	emit_nursery_join_a64(status, id, `__nursery_${id}`);
+	status.nursery_offsets.delete(id);
+	status.nursery_meta?.delete(id);
+}
+/**
+* Emit one nursery's join sequence in assembly: the race-mode wait (if any),
+* the wait+release loop over every registered future, and the futures-list
+* free. Shared by the block exit and the RETURN path — a `return` inside an
+* `async { }` block must route through the join (the structured-concurrency
+* contract). The nursery's per-invocation state lives at this function's
+* stack frame (offsets from x29), so a return site inside the block reaches
+* the same state. `label_prefix` must be unique per emission: the block exit
+* uses `__nursery_<id>`, a return site `__nursery_<id>_retjoin<N>` (the
+* block-exit labels would collide with a second loop in the same function).
+* Clobbers x0-x3, x20, x22, x23 (backend scratch — nothing live across a
+* join).
+*/
+function emit_nursery_join_a64(status, id, label_prefix) {
+	const offsets = status.nursery_offsets?.get(id);
+	if (!offsets) return;
+	const { futures_off, count_off, deadline_off } = offsets;
+	const is_race = (status.nursery_meta?.get(id) ?? {
+		mode: "all",
+		has_deadline: false
+	}).mode === "race";
+	const loop_start = `${label_prefix}_join_start`;
+	const loop_end = `${label_prefix}_join_end`;
+	const loop_release = `${label_prefix}_release`;
+	const no_list = `${label_prefix}_no_list`;
+	emit_asm(status, `ldr x20, [x29, #${futures_off}]\n`);
+	emit_asm(status, `ldr w22, [x29, #${count_off}]\n`);
 	if (is_race) {
 		emit_asm(status, `mov x0, x20\n`);
 		emit_asm(status, `mov x1, x22\n`);
@@ -26967,6 +27129,7 @@ function build_async_block_node$1(node, status, nir) {
 		else emit_asm(status, `mov x2, #0\n`);
 		emit_asm(status, `bl ___nomen_nursery_race_wait\n`);
 	}
+	emit_asm(status, `mov x23, xzr\n`);
 	emit_asm(status, `${loop_start}:\n`);
 	emit_asm(status, `cmp x23, x22\n`);
 	emit_asm(status, `b.ge ${loop_end}\n`);
@@ -26991,9 +27154,28 @@ function build_async_block_node$1(node, status, nir) {
 	emit_asm(status, `b ${loop_start}\n`);
 	emit_asm(status, `${loop_end}:\n`);
 	emit_asm(status, `ldr x0, [x29, #${futures_off}]\n`);
-	emit_asm(status, `cbz x0, __nursery_${id}_no_list\n`);
+	emit_asm(status, `cbz x0, ${no_list}\n`);
 	emit_asm(status, `bl _free\n`);
-	emit_asm(status, `__nursery_${id}_no_list:\n`);
+	emit_asm(status, `${no_list}:\n`);
+}
+let retjoin_counter = 0;
+/**
+* Emit the join sequence for every nursery the current `return` must route
+* through — innermost first. Only nurseries belonging to the CURRENT
+* function (stack depth >= the function's entry depth) apply: a lambda
+* defined inside an `async { }` block inherits the block's id on
+* nursery_stack (for lexical spawn captures), but its `return` exits the
+* lambda, whose frame has no nursery state. The return value must already
+* be parked (the join's `bl`s clobber x0/x1).
+*/
+function emit_nursery_joins_on_return_a64(status) {
+	if (!status.nursery_stack?.length) return;
+	const base = status.function_nursery_depth ?? 0;
+	for (let i = status.nursery_stack.length - 1; i >= base; i--) {
+		const id = status.nursery_stack[i];
+		emit_asm(status, `// return inside async block: join nursery ${id} before leaving\n`);
+		emit_nursery_join_a64(status, id, `__nursery_${id}_retjoin${retjoin_counter++}`);
+	}
 }
 //#endregion
 //#region ../src/build_aarch64/build_break_node.ts
@@ -27482,6 +27664,7 @@ function build_inline_method(struct_node, func, status) {
 	const old_param_vars = status.function_param_vars;
 	status.stack_offsets = /* @__PURE__ */ new Map();
 	const old_param_types = status.function_param_types;
+	const old_local_types = status.function_local_types;
 	const old_return_label = status.function_return_label;
 	const old_ref_params = status.function_ref_params;
 	const old_struct_return_buffer = status.struct_return_buffer;
@@ -27548,6 +27731,7 @@ function build_inline_method(struct_node, func, status) {
 	status.function_ref_params = /* @__PURE__ */ new Set();
 	status.function_param_types = /* @__PURE__ */ new Map();
 	for (const p of func.params) if (p.type) status.function_param_types.set(p.name, p.type);
+	status.function_local_types = /* @__PURE__ */ new Map();
 	if (needs_x19) status.function_param_regs.set("self", "x19");
 	if (process.env.AMI_HOMES && func.name === "get") console.log(`HOMES-DBG get: needs_x19=${needs_x19} self_is_var=${self_is_var} code_tail=${JSON.stringify(status.code.slice(-120))}`);
 	const saved_stack_slots = [];
@@ -27628,6 +27812,7 @@ function build_inline_method(struct_node, func, status) {
 	status.function_param_regs = old_param_regs;
 	status.function_param_vars = old_param_vars;
 	status.function_param_types = old_param_types;
+	status.function_local_types = old_local_types;
 	status.function_ref_params = old_ref_params;
 	status.function_return_label = old_return_label;
 	status.stack_offsets = old_stack_offsets;
@@ -27658,6 +27843,7 @@ function build_inline_function(func, status) {
 	const old_param_vars = status.function_param_vars;
 	status.stack_offsets = /* @__PURE__ */ new Map();
 	const old_param_types = status.function_param_types;
+	const old_local_types = status.function_local_types;
 	const old_return_label = status.function_return_label;
 	const old_ref_params = status.function_ref_params;
 	const old_struct_return_buffer = status.struct_return_buffer;
@@ -27716,6 +27902,7 @@ function build_inline_function(func, status) {
 	status.function_ref_params = /* @__PURE__ */ new Set();
 	status.function_param_types = /* @__PURE__ */ new Map();
 	for (const p of func.params) if (p.type) status.function_param_types.set(p.name, p.type);
+	status.function_local_types = /* @__PURE__ */ new Map();
 	const saved_stack_slots = [];
 	const inline_reloads = [];
 	const inline_push_slots = [];
@@ -27785,6 +27972,7 @@ function build_inline_function(func, status) {
 	status.function_param_regs = old_param_regs;
 	status.function_param_vars = old_param_vars;
 	status.function_param_types = old_param_types;
+	status.function_local_types = old_local_types;
 	status.function_ref_params = old_ref_params;
 	status.function_return_label = old_return_label;
 	status.stack_offsets = old_stack_offsets;
@@ -28217,7 +28405,7 @@ function build_function_call_node$1(node, status) {
 					let arg_is_class = false;
 					if (arg_name) {
 						const tn = arg.type?.name ?? status.variable_types?.get(arg_name)?.name;
-						arg_is_class = !!tn && !!status.structs.find((s) => s.name === tn && s.is_class);
+						arg_is_class = !!tn && (!!status.structs.find((s) => s.name === tn && s.is_class) || !!status.traits.find((t) => t.name === tn));
 					}
 					const ref_param_slot = arg_name !== void 0 ? status.ref_class_slots?.get(arg_name) : void 0;
 					if (ref_param_slot !== void 0) emit_ref_class_param_slot(status, ref_param_slot, arg_name, ref_class_param_reload);
@@ -28286,11 +28474,11 @@ function build_function_call_node$1(node, status) {
 				}
 			}
 		}
-		if (is_struct && status.struct_return_buffer) {
+		if (is_struct && is_struct.is_class) emit_asm(status, `ldr x0, [sp]\n`);
+		else if (is_struct && status.struct_return_buffer) {
 			if (status.return_buffer_stack_offset !== void 0) emit_asm(status, `ldr x8, [x29, #${status.return_buffer_stack_offset}]\n`);
 			emit_asm(status, `mov x0, ${status.struct_return_buffer}\n`);
-		} else if (is_struct && is_struct.is_class) emit_asm(status, `ldr x0, [sp]\n`);
-		else if (is_struct && !is_struct.is_class) {
+		} else if (is_struct && !is_struct.is_class) {
 			const temp_addr = `_temp_${temp_counter - 1}`;
 			emit_asm(status, `add x0, x29, #${status.stack_offsets.get(temp_addr)}\n`);
 		} else if (!is_struct && node.type?.name && !status.call_x8_preset) {
@@ -28352,16 +28540,17 @@ function build_function_call_node$1(node, status) {
 		}
 	}
 	build_swap_params(node, status);
-	if (is_struct && !status.struct_return_buffer) {
-		if (is_struct.is_class) emit_asm(status, `ldr x0, [sp], #16\n`);
-		else {
-			const temp_addr = `_temp_${temp_counter - 1}`;
-			const offset = status.stack_offsets.get(temp_addr);
+	if (is_struct && is_struct.is_class) emit_asm(status, `ldr x0, [sp], #16\n`);
+	else if (is_struct && status.struct_return_buffer) {
+		if (status.return_buffer_stack_offset !== void 0) emit_asm(status, `ldr x0, [x29, #${status.return_buffer_stack_offset}]\n`);
+		else emit_asm(status, `mov x0, ${status.struct_return_buffer}\n`);
+	} else if (is_struct && !status.struct_return_buffer) {
+		const temp_addr = `_temp_${temp_counter - 1}`;
+		const offset = status.stack_offsets.get(temp_addr);
+		emit_asm(status, `add x0, x29, #${offset}\n`);
+		if (node.field_overrides?.length) {
+			emit_field_overrides(temp_addr, node, build_node, status);
 			emit_asm(status, `add x0, x29, #${offset}\n`);
-			if (node.field_overrides?.length) {
-				emit_field_overrides(temp_addr, node, build_node, status);
-				emit_asm(status, `add x0, x29, #${offset}\n`);
-			}
 		}
 	}
 	if (node.name.startsWith("_string_interpolate_")) {
@@ -28752,6 +28941,14 @@ struct nomen_future {
 	// The fiber whose task this future is (set at fiber spawn). Cancellation
 	// uses it to wake a fiber parked on a primitive waitq.
 	struct nomen_fiber *owning_fiber;
+	// 1 when the result slot holds a FAT string (set at construction, which
+	// knows the wrapped call's return type). The last release frees an
+	// unconsumed string buffer from the cell: result() zeroes the cell when
+	// it moves the value out, and Task's #destroy zeroes after its own
+	// free, so a non-NULL ptr at the last release means "never consumed".
+	// Appended LAST: raw aarch64 bodies read refs/result_slot/owner_args at
+	// fixed offsets (#116/#128/#136), which must not shift.
+	int slot_fat;
 };
 // Fiber seam (defined in FIBER_HEADER, appended after this block). Declared
 // here — after struct nomen_future is complete — so the prototypes bind to
@@ -28877,6 +29074,19 @@ static void __nomen_future_release(struct nomen_future *f) {
 		pthread_mutex_destroy(&f->mu);
 		pthread_cond_destroy(&f->cv);
 		free(f->cancel_flag);
+		// An unconsumed fat-string result: free the buffer the trampoline
+		// stored (race-mode and fire-and-forget tasks never hand it to a
+		// consumer). Every consumer path zeroes the cell first — result()
+		// on move-out, Task's #destroy after its own free — so a non-NULL
+		// ptr here is unambiguous and the free happens exactly once.
+		if (f->slot_fat && f->result_slot) {
+			unsigned long long *_s = (unsigned long long *)f->result_slot;
+			if (_s[0]) {
+				free((void *)_s[0]);
+				_s[0] = 0;
+				_s[1] = 0;
+			}
+		}
 		free(f->result_slot);
 		// The task closure is owned by the future: disposing it here (the
 		// last release, ordered after every use — trampoline, Task destroy,
@@ -29013,7 +29223,11 @@ static void __nomen_future_cancel(struct nomen_future *f) {
 	// schedule() only queues PARKED fibers, so a double wake is harmless.
 	if (f->owning_fiber) __nomen_fiber_schedule(f->owning_fiber);
 }
+// Non-blocking completion peek (Task.is_done): 1 once the future's task has
+// finished, 0 while it may still be running (and for a NULL — a consumed or
+// never-launched handle).
 static int __nomen_future_is_done(struct nomen_future *f) {
+	if (!f) return 0;
 	pthread_mutex_lock(&f->mu);
 	int d = f->done;
 	pthread_mutex_unlock(&f->mu);
@@ -29885,95 +30099,6 @@ static int __nomen_deadlock_check_worker(void) {
 }
 `;
 /**
-* Build a `.start()` launch on a `Thread(fn(args))` construction — the
-* surface form of a direct spawn (CLOSURE.md Phase 3b). The
-* receiver is the construction expression itself or any Thread-typed
-* expression (a stored `var t = Thread(...)` binding); its fields carry the
-* task closure packed eagerly at the construction site, plus the result
-* slot, cancel flag, and future. This submits the closure to the worker
-* pool, registers the future with the enclosing nursery (if any), transfers
-* the handles out of the instance (so its #destroy becomes a no-op), and
-* yields a Task<T> handle — or nothing, for a fire-and-forget statement.
-*/
-function build_thread_start(access_func, target, status) {
-	ensure_concurrency_runtime(status);
-	status.spawn_counter = (status.spawn_counter ?? 0) + 1;
-	const t_arg = spawn_result_type_arg$4(access_func.function_return_type);
-	const mono_thread = mono_type_name("Thread", [t_arg]);
-	const mono_task_name = mono_type_name("Task", [t_arg]);
-	const nursery_id = status.nursery_stack?.at(-1);
-	const fire_and_forget = !!access_func.is_statement;
-	const refs = fire_and_forget ? nursery_id !== void 0 ? 2 : 1 : nursery_id !== void 0 ? 3 : 2;
-	const target_is_temp = target.node_type === "func_call" && !!(target.is_thread_ctor || target.is_fiber_ctor);
-	status.code += `({\n`;
-	status.code += `\tstruct ${mono_thread} *_self = `;
-	build_node$1(target, status);
-	status.code += `;\n`;
-	status.code += `\tstruct nomen_future *_future = (struct nomen_future *)_self->future;\n`;
-	status.code += `\tvoid *_result_ptr = (void *)_self->result_slot;\n`;
-	status.code += `\tunsigned long long *_cancel_ptr = (unsigned long long *)_self->cancel_flag;\n`;
-	status.code += `\tstruct nomen_closure *_closure = (struct nomen_closure *)_self->task;\n`;
-	status.code += `\t_future->refs = ${refs};\n`;
-	status.code += `\t__nomen_pool_submit(_closure);\n`;
-	if (nursery_id !== void 0) status.code += `\t__nomen_nursery_track((void **)&__nomen_nursery_${nursery_id}_futures, &__nomen_nursery_${nursery_id}_count, &__nomen_nursery_${nursery_id}_cap, _future);\n`;
-	status.code += `\t_self->task = 0;\n`;
-	status.code += `\t_self->future = 0;\n`;
-	status.code += `\t_self->result_slot = 0;\n`;
-	status.code += `\t_self->cancel_flag = 0;\n`;
-	status.code += `\t_self->started = 1;\n`;
-	if (target_is_temp) status.code += `\tfree(_self);\n`;
-	if (fire_and_forget) status.code += `\t(void)0;\n`;
-	else {
-		status.code += `\tstruct ${mono_task_name} *_task = (struct ${mono_task_name} *)malloc(sizeof(struct ${mono_task_name}));\n`;
-		status.code += `\t_task->_vt = &_${mono_task_name}_traits;\n`;
-		status.code += `\t_task->handle = 0;\n`;
-		status.code += `\t_task->done = 0;\n`;
-		status.code += `\t_task->result_slot = (unsigned long long)_result_ptr;\n`;
-		status.code += `\t_task->cancel_flag = (unsigned long long)_cancel_ptr;\n`;
-		status.code += `\t_task->future = (unsigned long long)_future;\n`;
-		status.code += `\t_task;\n`;
-	}
-	status.code += `})\n`;
-}
-/**
-* Build a `.detach()` launch on a `Thread(fn(args))` construction — the
-* daemon form (ASYNC.md, "Daemon tasks"). The packed task closure runs on a
-* dedicated detached pthread: never a pool worker, never joined, killed by
-* process exit by design. No future is used: the construction allocated one
-* (a Thread always carries the full launch machinery), so detach releases
-* that unused future (first detaching the closure from it — the daemon
-* runner owns the closure now) and marks the instance started.
-*/
-function build_thread_detach(access_func, target, status) {
-	ensure_concurrency_runtime(status);
-	status.spawn_counter = (status.spawn_counter ?? 0) + 1;
-	const mono_thread = mono_type_name("Thread", [spawn_result_type_arg$4(access_func.function_return_type)]);
-	const target_is_temp = target.node_type === "func_call" && !!(target.is_thread_ctor || target.is_fiber_ctor);
-	status.code += `({\n`;
-	status.code += `\tstruct ${mono_thread} *_self = `;
-	build_node$1(target, status);
-	status.code += `;\n`;
-	status.code += `\tstruct nomen_future *_unused_future = (struct nomen_future *)_self->future;\n`;
-	status.code += `\tif (_unused_future) {\n`;
-	status.code += `\t\t_unused_future->owner_args = NULL;\n`;
-	status.code += `\t\t__nomen_future_release(_unused_future);\n`;
-	status.code += `\t}\n`;
-	status.code += `\t__nomen_task_detach((struct nomen_closure *)_self->task);\n`;
-	status.code += `\t_self->task = 0;\n`;
-	status.code += `\t_self->future = 0;\n`;
-	status.code += `\t_self->result_slot = 0;\n`;
-	status.code += `\t_self->cancel_flag = 0;\n`;
-	status.code += `\t_self->started = 1;\n`;
-	if (target_is_temp) status.code += `\tfree(_self);\n`;
-	status.code += `\t(void)0;\n`;
-	status.code += `})\n`;
-}
-/** The launch's T as a Type: the stamped wrapped-call return type, with
-*  void coerced to uint64 (Task's result-slot convention). */
-function spawn_result_type_arg$4(return_type) {
-	return return_type?.name && return_type.name !== "void" && return_type.name !== "?" ? new Type(return_type.name) : new Type("uint64");
-}
-/**
 * Resolve each spawn argument's C type. Classes/traits are pointers;
 * primitives and by-value structs use c_type's output directly. Generic
 * instantiations (e.g. Channel<uint64>) use the monomorphized C name
@@ -30058,98 +30183,41 @@ function find_spawn_callee(name, status) {
 	visit(status.root);
 	return found;
 }
-//#endregion
-//#region ../src/build_c/build_fiber_spawn.ts
 /**
-* Fiber scheduler runtime (ASYNC.md Phase 1), C backend.
-*
-* Appended immediately after POOL_HEADER (which forward-declares the fiber
-* seam, owns `__nomen_current_fiber` — Runtime.current() — and owns the
-* worker loop that drains the fiber queue between pool tasks). The context
-* switch is ucontext-based here: portable across every target the C backend
-* serves. The aarch64 backend's FIBER_HEADER_C is the same scheduler with a
-* naked-asm switch instead.
-*
-* Execution model: a fiber is a heap (or caller-provided) stack plus a
-* context. `__nomen_fiber_spawn` enqueues it; pool workers drain the fiber
-* queue between pool tasks, so a parked fiber frees its worker. In
-* cooperative mode (Fiber.set_cooperative) the spawning thread drains the
-* queue itself — no worker threads are ever started, which is the
-* no-thread/embedded path.
-*
-* Swap protocol: the runner captures its continuation into a stack-local
-* `ret` (its address rides the per-thread `__nomen_fiber_ret` pointer) and
-* switches into `f->ctx`. A suspending fiber saves ITS continuation into
-* `f->ctx` (overwriting the entry state after the first suspension) and
-* switches into `__nomen_fiber_ret`. Resume therefore always continues where
-* the fiber last suspended.
+* Whether any raw `#arch` body under this node
+* references the concurrency runtime (`__nomen_*` symbols — pool, futures,
+* fiber scheduler, nursery tracking, netpoller). The runtime is the
+* LIBRARY's dependency: a method whose raw body drives it pulls it in,
+* keyed on body CONTENT — never on a type name.
 */
+function raw_bodies_reference_runtime(node) {
+	if (!node || typeof node !== "object") return false;
+	if (node.node_type === "raw") {
+		const raw = node.value;
+		return typeof raw === "string" && raw.includes("__nomen_");
+	}
+	for (const key of Object.keys(node)) {
+		if (key === "parent" || key === "scope") continue;
+		const v = node[key];
+		if (Array.isArray(v)) {
+			for (const item of v) if (raw_bodies_reference_runtime(item)) return true;
+		} else if (v && typeof v === "object" && "node_type" in v) {
+			if (raw_bodies_reference_runtime(v)) return true;
+		}
+	}
+	return false;
+}
 /**
-* Build a `.start()` / `.start_on(buf)` launch on a `Fiber(fn(args))`
-* construction (or a stored Fiber binding) — C backend
-* (CLOSURE.md Phase 3b). The receiver's fields carry the task
-* closure packed eagerly at the construction site, plus the result slot,
-* cancel flag, and future. This launches the closure on the fiber
-* scheduler (a heap stack, or the caller's fixed-size array buffer for
-* start_on — validated at check time, >= 16 KB), registers the future with
-* the enclosing nursery (if any), transfers the handles out of the
-* instance, and yields Task<T> (or nothing, fire-and-forget).
+* Pull the concurrency runtime in when this struct method's raw bodies
+* reference it (deduped by the ensure flags). Replaces the old per-type-name
+* gates (CONCURRENCY_TYPES / the aarch64 Fiber||Thread check): the runtime
+* dependency now belongs to the library code itself.
 */
-function build_fiber_spawn_node$1(access_func, target, status, start_on) {
-	ensure_concurrency_runtime(status);
-	status.used_fibers = true;
-	const t_arg = spawn_result_type_arg$3(access_func.function_return_type);
-	const mono_fiber = mono_type_name("Fiber", [t_arg]);
-	const mono_task_name = mono_type_name("Task", [t_arg]);
-	const nursery_id = status.nursery_stack?.at(-1);
-	const fire_and_forget = !!access_func.is_statement;
-	const target_is_temp = target.node_type === "func_call" && !!(target.is_thread_ctor || target.is_fiber_ctor);
-	const refs = fire_and_forget ? nursery_id !== void 0 ? 2 : 1 : nursery_id !== void 0 ? 3 : 2;
-	status.code += `({\n`;
-	status.code += `\tstruct ${mono_fiber} *_self = `;
-	build_node$1(target, status);
-	status.code += `;\n`;
-	status.code += `\tstruct nomen_future *_future = (struct nomen_future *)_self->future;\n`;
-	status.code += `\tvoid *_result_ptr = (void *)_self->result_slot;\n`;
-	status.code += `\tunsigned long long *_cancel_ptr = (unsigned long long *)_self->cancel_flag;\n`;
-	status.code += `\tstruct nomen_closure *_closure = (struct nomen_closure *)_self->task;\n`;
-	status.code += `\t_future->refs = ${refs};\n`;
-	status.code += `\t__nomen_fiber_spawn${start_on ? "_on" : ""}(_closure, _future`;
-	if (start_on) {
-		const buf_type = type_from_value_node$1(start_on);
-		const elem_size = buf_type.name === "string" ? 16 : 8;
-		const len_node = buf_type.length;
-		const len = len_node && len_node.node_type === "value" ? parseInt(len_node.value, 10) : NaN;
-		const stack_bytes = Number.isNaN(len) ? 0 : len * elem_size;
-		status.code += `, (void *)`;
-		build_node$1(start_on, status);
-		status.code += `, (size_t)${stack_bytes}`;
-	}
-	status.code += `);\n`;
-	if (nursery_id !== void 0) status.code += `\t__nomen_nursery_track((void **)&__nomen_nursery_${nursery_id}_futures, &__nomen_nursery_${nursery_id}_count, &__nomen_nursery_${nursery_id}_cap, _future);\n`;
-	status.code += `\t_self->task = 0;\n`;
-	status.code += `\t_self->future = 0;\n`;
-	status.code += `\t_self->result_slot = 0;\n`;
-	status.code += `\t_self->cancel_flag = 0;\n`;
-	status.code += `\t_self->started = 1;\n`;
-	if (target_is_temp) status.code += `\tfree(_self);\n`;
-	if (fire_and_forget) status.code += `\t(void)0;\n`;
-	else {
-		status.code += `\tstruct ${mono_task_name} *_task = (struct ${mono_task_name} *)malloc(sizeof(struct ${mono_task_name}));\n`;
-		status.code += `\t_task->_vt = &_${mono_task_name}_traits;\n`;
-		status.code += `\t_task->handle = 0;\n`;
-		status.code += `\t_task->done = 0;\n`;
-		status.code += `\t_task->result_slot = (unsigned long long)_result_ptr;\n`;
-		status.code += `\t_task->cancel_flag = (unsigned long long)_cancel_ptr;\n`;
-		status.code += `\t_task->future = (unsigned long long)_future;\n`;
-		status.code += `\t_task;\n`;
+function ensure_runtime_for_method(func, status) {
+	for (const stmt of func.statements ?? []) if (raw_bodies_reference_runtime(stmt)) {
+		ensure_concurrency_runtime(status);
+		return;
 	}
-	status.code += `})\n`;
-}
-/** The launch's T as a Type: the stamped wrapped-call return type, with
-*  void coerced to uint64 (Task's result-slot convention). */
-function spawn_result_type_arg$3(return_type) {
-	return return_type?.name && return_type.name !== "void" && return_type.name !== "?" ? new Type(return_type.name) : new Type("uint64");
 }
 //#endregion
 //#region ../src/build_c/build_nursery_spawn.ts
@@ -30174,7 +30242,7 @@ function build_nursery_spawn$1(node, nursery_ptr, status) {
 	const fire_and_forget = !!node.is_statement;
 	const refs = fire_and_forget ? 2 : 3;
 	ensure_concurrency_runtime(status);
-	const t_arg = spawn_result_type_arg$2(node.function_return_type);
+	const t_arg = spawn_result_type_arg$1(node.function_return_type);
 	const mono_thread = mono_type_name("Thread", [t_arg]);
 	const mono_task_name = mono_type_name("Task", [t_arg]);
 	const arg = node.params[0];
@@ -30211,7 +30279,7 @@ function build_nursery_spawn$1(node, nursery_ptr, status) {
 }
 /** The launch's T as a Type: the stamped wrapped-call return type, with
 *  void coerced to uint64 (Task's result-slot convention). */
-function spawn_result_type_arg$2(return_type) {
+function spawn_result_type_arg$1(return_type) {
 	return return_type?.name && return_type.name !== "void" && return_type.name !== "?" ? new Type(return_type.name) : new Type("uint64");
 }
 //#endregion
@@ -31512,7 +31580,8 @@ function build_assignment_node$1(node, status, nir_rhs, nir_swap) {
 		const lhs_decl = status.scoped_declarations.find((d) => d.name === lhs_name);
 		const lhs_in_class_vars = !!status.class_vars?.has(lhs_name);
 		const lhs_type = lhs_decl?.type || status.variable_types?.get(lhs_name);
-		const lhs_struct = lhs_type ? status.structs.find((s) => s.name === lhs_type.name) : null;
+		const lhs_mono_name = lhs_type ? mono_type_name(lhs_type) : "";
+		const lhs_struct = lhs_mono_name ? status.structs.find((s) => s.name === lhs_mono_name) : null;
 		const lhs_is_string = lhs_type?.name === "string";
 		const lhs_is_class = !!lhs_struct?.is_class || lhs_in_class_vars;
 		const lhs_trait_class = lhs_scope_hit ? lhs_scope_hit.frame[lhs_scope_hit.index].trait_class_trait : void 0;
@@ -31580,11 +31649,12 @@ function build_assignment_node$1(node, status, nir_rhs, nir_swap) {
 				}
 			} else if (lhs_is_class && lhs_struct && !lhs_is_alias && (lhs_decl || lhs_in_class_vars)) {
 				const temp = `_deferred_${status.label_counter = (status.label_counter ?? 0) + 1}`;
-				status.code += `struct ${lhs_struct.name}* ${temp} = ${lhs_name};\n`;
+				const destroy_name = lhs_struct.name.startsWith(lhs_type.name) ? lhs_struct.name : lhs_type.name;
+				status.code += `struct ${destroy_name}* ${temp} = ${lhs_name};\n`;
 				if (!status.deferred_frees) status.deferred_frees = [];
 				status.deferred_frees.push({
 					temp,
-					struct_name: lhs_struct.name,
+					struct_name: destroy_name,
 					is_nullable: !!lhs_type?.is_nullable
 				});
 			} else if (lhs_is_class && lhs_is_alias && status.c_alias_owns_flags?.has(lhs_name)) {
@@ -31930,11 +32000,15 @@ function string_var_owns_heap(status, name) {
 function build_async_block_node(node, status, nir) {
 	const id = status.spawn_counter ?? 0;
 	status.spawn_counter = id + 1;
-	if (node.mode === "race") ensure_concurrency_runtime(status);
+	ensure_concurrency_runtime(status);
 	const futures_name = `__nomen_nursery_${id}_futures`;
 	const count_name = `__nomen_nursery_${id}_count`;
 	const cap_name = `__nomen_nursery_${id}_cap`;
-	const idx_name = `__nomen_nursery_${id}_i`;
+	if (!status.nursery_meta) status.nursery_meta = /* @__PURE__ */ new Map();
+	status.nursery_meta.set(id, {
+		mode: node.mode ?? "all",
+		has_deadline: !!node.timeout
+	});
 	status.code += `{\n`;
 	status.code += `\tstruct nomen_future **${futures_name} = NULL;\n`;
 	status.code += `\tint ${count_name} = 0;\n`;
@@ -31966,7 +32040,35 @@ function build_async_block_node(node, status, nir) {
 	status.nursery_stack.push(id);
 	build_block_with_cursor(node, nir?.body, status);
 	status.nursery_stack.pop();
-	const is_race = node.mode === "race";
+	emit_nursery_join_c(status, id);
+	build_auto_free(status);
+	status.code += `}\n`;
+	leave_c_scope(status);
+	status.scoped_declarations = old_scoped_declarations;
+	status.deferred_frees = old_deferred_frees;
+}
+/**
+* Emit one nursery's join sequence: the race-mode wait (if any), the
+* wait+release loop over every registered future, and the futures-list
+* free. Shared by the block exit and the RETURN path — a `return` inside an
+* `async { }` block must route through the join (the structured-concurrency
+* contract: the block's scoped resources must not die under still-running
+* tasks, and the per-future release must not be skipped). The names are
+* deterministic per nursery id, so a return site inside the block can
+* re-emit the same sequence textually (the block's tracking locals are
+* still in C scope there).
+*/
+function emit_nursery_join_c(status, id, is_return_path = false) {
+	const meta = status.nursery_meta?.get(id) ?? {
+		mode: "all",
+		has_deadline: false
+	};
+	const futures_name = `__nomen_nursery_${id}_futures`;
+	const count_name = `__nomen_nursery_${id}_count`;
+	const idx_name = `__nomen_nursery_${id}_i`;
+	const deadline_var = meta.has_deadline ? `_deadline_ms_${id}` : "";
+	if (is_return_path) status.code += `\t// return inside async block: join nursery ${id} before leaving\n`;
+	const is_race = meta.mode === "race";
 	if (is_race) status.code += `\t__nomen_nursery_race_wait((struct nomen_future **)${futures_name}, ${count_name}, ${deadline_var ? deadline_var : "0"});\n`;
 	status.code += `\tfor (int ${idx_name} = 0; ${idx_name} < ${count_name}; ${idx_name}++) {\n`;
 	status.code += `\t\tstruct nomen_future *_f = (struct nomen_future *)${futures_name}[${idx_name}];\n`;
@@ -31983,11 +32085,19 @@ function build_async_block_node(node, status, nir) {
 	status.code += `\t\t__nomen_future_release(_f);\n`;
 	status.code += `\t}\n`;
 	status.code += `\tfree(${futures_name});\n`;
-	build_auto_free(status);
-	status.code += `}\n`;
-	leave_c_scope(status);
-	status.scoped_declarations = old_scoped_declarations;
-	status.deferred_frees = old_deferred_frees;
+}
+/**
+* Emit the join sequence for every nursery the current `return` must route
+* through — innermost first. Only nurseries belonging to the CURRENT
+* function (stack depth >= the function's entry depth) apply: a lambda
+* defined inside an `async { }` block inherits the block's id on
+* nursery_stack (for lexical spawn captures), but its `return` exits the
+* lambda, whose frame has no nursery state.
+*/
+function emit_nursery_joins_on_return_c(status) {
+	if (!status.nursery_stack?.length) return;
+	const base = status.function_nursery_depth ?? 0;
+	for (let i = status.nursery_stack.length - 1; i >= base; i--) emit_nursery_join_c(status, status.nursery_stack[i], true);
 }
 //#endregion
 //#region ../src/build_c/build_array_values_node.ts
@@ -32945,6 +33055,7 @@ function build_return_node(node, status, nir_value) {
 	const ret_is_null = returns_nullable_struct && (!node.value || node.value.node_type === "value" && node.value.value === "null");
 	if (returns_nullable_struct) {
 		if (ret_is_null) {
+			emit_nursery_joins_on_return_c(status);
 			reclaim_all_c_scopes(status);
 			status.code += `*${ret_has} = 0;\n`;
 			status.code += `return (struct ${status.function_return_type.name}){0};\n`;
@@ -32953,6 +33064,7 @@ function build_return_node(node, status, nir_value) {
 		status.code += `*${ret_has} = 1;\n`;
 	}
 	if (!node.value) {
+		emit_nursery_joins_on_return_c(status);
 		reclaim_all_c_scopes(status);
 		if (status.return_assign) status.code += `${status.return_assign} = 0;\n`;
 		else if (status.current_function_name?.toLocaleLowerCase() === "main") status.code += `return 0;\n`;
@@ -33005,6 +33117,7 @@ function build_return_node(node, status, nir_value) {
 		status.code += `_return_val->length = ${return_array_len};\n`;
 		status.code += `${elem_c_type}* _return_data = (${elem_c_type}*)((char*)_return_val + sizeof(struct ${array_struct}));\n`;
 		status.code += `for (long _i = 0; _i < ${return_array_len}; _i++) _return_data[_i] = ${return_array_var}[_i];\n`;
+		emit_nursery_joins_on_return_c(status);
 		reclaim_all_c_scopes(status);
 		status.code += `return _return_val;\n`;
 		return;
@@ -33020,6 +33133,7 @@ function build_return_node(node, status, nir_value) {
 		emit_allocations(node.value, status);
 		emit_return_value(node.value, nir_value, status);
 		status.code += `;\n`;
+		emit_nursery_joins_on_return_c(status);
 		reclaim_all_c_scopes(status);
 		status.code += `return;\n`;
 	} else {
@@ -33042,6 +33156,7 @@ function build_return_node(node, status, nir_value) {
 			build_node$1(node.value, status);
 			status.join_needs_owned_string = old_join_owned;
 			status.return_assign = old_return_assign;
+			emit_nursery_joins_on_return_c(status);
 			reclaim_all_c_scopes(status);
 			if (string_join) status.code += any_branch_owned ? `return _return_val;\n` : `return nomen_str_dup(_return_val);\n`;
 			else status.code += `return _return_val;\n`;
@@ -33100,6 +33215,7 @@ function build_return_node(node, status, nir_value) {
 		status.code += `;\n`;
 		if (node.value.node_type === "access" && node.value.access?.node_type === "access_field" && !returns_string_zero && !returns_struct_zero && !returns_view_value && ret_type.name !== "string" && !ret_type.is_view && !ret_type.is_array && status.enums.find((e) => e.name === ret_type.name && e.has_associated_data)) status.code += `_return_val = ${ret_type.name}_copy(_return_val);\n`;
 		if (has_field_overrides(node.value)) emit_field_overrides("_return_val", node.value, build_node$1, status, "", ";\n");
+		emit_nursery_joins_on_return_c(status);
 		reclaim_all_c_scopes(status);
 		status.code += `return _return_val;\n`;
 	}
@@ -33382,7 +33498,7 @@ function emit_stmt_from_nir(child, index, statements, status) {
 				const eval_node = nstmt.expr.node;
 				if (eval_node.node_type === "access") {
 					const inner = eval_node.access;
-					if (inner.node_type === "access_func" && (inner.is_nursery_spawn || inner.is_thread_start || inner.is_thread_detach || inner.is_fiber_start)) inner.is_statement = true;
+					if (inner.node_type === "access_func" && inner.is_nursery_spawn) inner.is_statement = true;
 				}
 				emit_expr_from_nir(nstmt.expr, status);
 				with_semicolon_tail(status, eval_node);
@@ -33911,22 +34027,9 @@ function scan_borrow_only_strings(body) {
 }
 //#endregion
 //#region ../src/build_c/build_struct_node.ts
-/** System types whose method bodies call into the concurrency runtime. */
-const CONCURRENCY_TYPES = /* @__PURE__ */ new Set([
-	"Task",
-	"Thread",
-	"Fiber",
-	"Channel",
-	"Mutex",
-	"Nursery",
-	"Tcp"
-]);
 function build_struct_node(node, status) {
 	if (node.is_generic) return;
-	if (CONCURRENCY_TYPES.has(node.name)) {
-		ensure_concurrency_runtime(status);
-		status.used_fibers = true;
-	}
+	for (const func of node.functions) ensure_runtime_for_method(func, status);
 	if (node.is_simple_type) {
 		status.code += `// Struct ${node.name}\n`;
 		build_struct_functions(node, status);
@@ -34165,6 +34268,7 @@ function build_struct_functions(node, status, skip_init = false) {
 	const old_current_struct = status.current_struct;
 	status.current_struct = node;
 	for (let func of node.functions) {
+		if (func.name === "#spawn") continue;
 		if (func.name === "#init" && !func.has_body) continue;
 		if (func.name === "#init" && skip_init) continue;
 		if (func.is_extern) {
@@ -35027,6 +35131,7 @@ function build_function_node(node, status) {
 	else status.nullable_ret_has_param = void 0;
 	const old_function_name = status.current_function_name;
 	status.current_function_name = emission_label(node);
+	status.function_nursery_depth = status.nursery_stack?.length ?? 0;
 	const old_current_function = status.current_function;
 	status.current_function = node;
 	for (let param of node.params) {
@@ -35645,22 +35750,6 @@ function build_access_node$1(node, status) {
 		}
 		case "access_func": {
 			const access_func = node.access;
-			if (node.target.node_type === "value" && node.target.value === "Fiber") {
-				ensure_concurrency_runtime(status);
-				status.used_fibers = true;
-			}
-			if (access_func.is_thread_start) {
-				build_thread_start(access_func, node.target, status);
-				return;
-			}
-			if (access_func.is_thread_detach) {
-				build_thread_detach(access_func, node.target, status);
-				return;
-			}
-			if (access_func.is_fiber_start) {
-				build_fiber_spawn_node$1(access_func, node.target, status, access_func.is_fiber_start_on ? access_func.params[0] : void 0);
-				return;
-			}
 			if (access_func.is_nursery_spawn) {
 				build_nursery_spawn$1(access_func, nursery_pointer_expr(node.target, status), status);
 				return;
@@ -35965,10 +36054,35 @@ function build_access_node$1(node, status) {
 				const label = access_func.mangled_name || trait_default_label || `${mono_struct_name}_${access_func.name.replace(/#/g, "")}`;
 				const array_wrap = array_receiver_wrap(node, method_type, target_method, mono_struct_name, status);
 				if (array_wrap) status.code += array_wrap.prefix;
+				const ctor_target_node = node.target.node_type === "func_call" ? node.target : void 0;
+				const ctor_temp_receiver = !!(ctor_target_node && (ctor_target_node.is_thread_ctor || ctor_target_node.is_fiber_ctor || ctor_target_node.is_awaitable_ctor));
+				let ctor_temp_free;
+				let ctor_temp_val;
+				if (ctor_temp_receiver) {
+					const id = status.label_counter = (status.label_counter ?? 0) + 1;
+					ctor_temp_free = `_ctorr_${id}`;
+					const ctor_mono = mono_type_name(type_from_value_node$1(node.target));
+					status.code += `({ struct ${ctor_mono} *${ctor_temp_free} = `;
+					{
+						const saved_suppress = status.suppress_dereference;
+						status.suppress_dereference = true;
+						build_node$1(node.target, status);
+						status.suppress_dereference = saved_suppress;
+					}
+					status.code += `; `;
+					const ret = (target_method ?? trait_default_func)?.return_type;
+					if (ret?.name && ret.name !== "void") {
+						const mono_ret = mono_type_name(access_func.type);
+						const ret_c = !!status.structs.find((s) => s.name === mono_ret && s.is_class) || !!status.traits.find((t) => t.name === mono_ret) ? `struct ${mono_ret} *` : c_type(mono_ret);
+						ctor_temp_val = `_ctorv_${id}`;
+						status.code += `${ret_c} ${ctor_temp_val} = `;
+					}
+				}
 				if (lambda_ret_tmp) status.code += `${lambda_ret_c} ${lambda_ret_tmp} = `;
 				status.code += `${label}(`;
 				if (!access_func.is_static) {
-					if (array_wrap) status.code += array_wrap.self_expr;
+					if (ctor_temp_free) status.code += ctor_temp_free;
+					else if (array_wrap) status.code += array_wrap.self_expr;
 					else {
 						const method_self_is_ref = !!target_method?.params?.some((p) => p.is_self_param && (p.is_ref || p.type?.is_ref));
 						const method_self = target_method?.params?.find((p) => p.is_self_param);
@@ -36037,6 +36151,11 @@ function build_access_node$1(node, status) {
 					}
 				}
 				status.code += ")";
+				if (ctor_temp_free) {
+					status.code += `; free(${ctor_temp_free});`;
+					if (ctor_temp_val) status.code += ` ${ctor_temp_val};`;
+					status.code += ` })`;
+				}
 				if (lambda_arg_temps.size > 0) {
 					for (const tmp of lambda_arg_temps.values()) status.code += `; ${closure_dispose_arm(tmp)}`;
 					if (lambda_ret_tmp) status.code += `; ${lambda_ret_tmp}`;
@@ -36758,7 +36877,7 @@ function build_node$1(node, status, with_semicolon = false) {
 			const access = node;
 			if (with_semicolon && access.access.node_type === "access_func") {
 				const afn = access.access;
-				if (afn.is_nursery_spawn || afn.is_thread_start || afn.is_thread_detach || afn.is_fiber_start) afn.is_statement = true;
+				if (afn.is_nursery_spawn) afn.is_statement = true;
 			}
 			build_access_node$1(access, status);
 			break;
@@ -36861,9 +36980,10 @@ function build_node$1(node, status, with_semicolon = false) {
 //#endregion
 //#region ../src/build_c/build_magic_ctor.ts
 /**
-* The compiler-special `Thread(fn(args))` / `Fiber(fn(args))` constructor —
-* and its generalized flavor, a user Awaitable class's `MyThing(fn(args))`
-* (ASYNC.md, "User-defined async primitives") — packs the wrapped call's
+* The `#spawn` construction (the deferred-call special form — the library
+* `Thread(fn(args))` / `Fiber(fn(args))`, or any class declaring its own
+* `#spawn` hook; docs/ASYNC.md, "The construction special form") — packs
+* the wrapped call's
 * arguments EAGERLY into a task environment, allocates the result slot,
 * cancel flag, and future, and builds the task closure — a heap descriptor
 * over that environment (the same ABI every lambda lowers to; the runtime's
@@ -37058,6 +37178,7 @@ function build_magic_ctor_node$1(node, status) {
 	status.code += `\t_future->done = 0;\n`;
 	status.code += `\t_future->cancel_flag = _cancel_ptr;\n`;
 	status.code += `\t_future->result_slot = _result_ptr;\n`;
+	status.code += `\t_future->slot_fat = ${slot_c_type === "nomen_string" ? 1 : 0};\n`;
 	status.code += `\t_future->fiber_waiters = NULL;\n`;
 	status.code += `\t_future->owning_fiber = NULL;\n`;
 	status.code += `\t_future->refs = 1;\n`;
@@ -37075,10 +37196,29 @@ function build_magic_ctor_node$1(node, status) {
 	status.code += `\t_self->cancel_flag = (unsigned long long)_cancel_ptr;\n`;
 	status.code += `\t_self->future = (unsigned long long)_future;\n`;
 	if (info.has_started) status.code += `\t_self->started = 0;\n`;
+	emit_nursery_capture_c(status, kind, (field, expr) => {
+		status.code += `\t_self->${field} = ${expr};\n`;
+	});
 	status.code += `\t_self;\n`;
 	status.code += `})\n`;
 }
 /**
+* LEXICAL NURSERY CAPTURE (ASYNC.md): a construction lexically
+* inside an `async` block stores the block's tracking-slot pointers in the
+* instance, so `.start()` — an ordinary method on the spawn class —
+* registers the future with the scope that CREATED the deferred call rather
+* than wherever the launch happens. Library spawn classes only: Thread/Fiber
+* carry the three capture fields (the generalized Awaitable flavor's field
+* contract predates them and keeps its historical emission).
+*/
+function emit_nursery_capture_c(status, kind, emit_field) {
+	const nursery_id = status.nursery_stack?.at(-1);
+	if (nursery_id === void 0 || kind !== "Thread" && kind !== "Fiber") return;
+	emit_field("nursery_futures", `(unsigned long long)&__nomen_nursery_${nursery_id}_futures`);
+	emit_field("nursery_count", `(unsigned long long)&__nomen_nursery_${nursery_id}_count`);
+	emit_field("nursery_cap", `(unsigned long long)&__nomen_nursery_${nursery_id}_cap`);
+}
+/**
 * The Phase 3c function-value construction (`Thread(() => work(n))` /
 * `Thread(job)` with a zero-argument func-typed local): the task closure is
 * an ADAPTER over the given closure. The adapter env carries the user
@@ -37152,6 +37292,7 @@ function build_fn_value_ctor(node, status, id, kind, info) {
 	status.code += `\t_future->done = 0;\n`;
 	status.code += `\t_future->cancel_flag = _cancel_ptr;\n`;
 	status.code += `\t_future->result_slot = _result_ptr;\n`;
+	status.code += `\t_future->slot_fat = ${dup_result ? 1 : 0};\n`;
 	status.code += `\t_future->fiber_waiters = NULL;\n`;
 	status.code += `\t_future->owning_fiber = NULL;\n`;
 	status.code += `\t_future->refs = 1;\n`;
@@ -37173,6 +37314,9 @@ function build_fn_value_ctor(node, status, id, kind, info) {
 	status.code += `\t_self->cancel_flag = (unsigned long long)_cancel_ptr;\n`;
 	status.code += `\t_self->future = (unsigned long long)_future;\n`;
 	if (info.has_started) status.code += `\t_self->started = 0;\n`;
+	emit_nursery_capture_c(status, kind, (field, expr) => {
+		status.code += `\t_self->${field} = ${expr};\n`;
+	});
 	status.code += `\t_self;\n`;
 	status.code += `})\n`;
 }
@@ -37193,10 +37337,10 @@ function is_struct_ret(node, status) {
 //#endregion
 //#region ../src/build_aarch64/build_magic_ctor.ts
 /**
-* The spawn-sugar construction (the compiler-special
-* `Thread(fn(args))` / `Fiber(fn(args))`, or the generalized user
-* Awaitable class's `MyThing(fn(args))` — CLOSURE.md Phase 3b, ASYNC.md
-* "User-defined async primitives"), aarch64 backend: the per-site
+* The `#spawn` construction (the deferred-call special form — the library
+* `Thread(fn(args))` / `Fiber(fn(args))`, or any class declaring its own
+* `#spawn` hook; docs/ASYNC.md, "The construction special form"),
+* aarch64 backend: the per-site
 * trampoline and a constructor helper are emitted as C in the companion
 * file; the assembly stages the wrapped call's arguments and calls the
 * helper, which packs the env, allocates the future machinery, builds the
@@ -37218,10 +37362,14 @@ function build_magic_ctor_node(node, status) {
 	const tramp_name = `__nomen_spawn_${id}_trampoline`;
 	const desc_name = `__nomen_spawn_${id}_descriptor`;
 	const struct_name = `__nomen_spawn_${id}_args`;
+	const nursery_id = status.nursery_stack?.at(-1);
+	const nursery_off = nursery_id !== void 0 ? status.nursery_offsets?.get(nursery_id) : void 0;
+	const capture = nursery_capture_a64(status, kind);
+	const arg_types = spawn_arg_types(call, status);
 	const arg_c_types = [];
 	const fat_string_args = [];
 	for (let i = 0; i < call.params.length; i++) {
-		const mono_name = mono_type_name(type_from_value_node$1(call.params[i]));
+		const mono_name = mono_type_name(arg_types[i]);
 		const is_class = !!status.structs.find((s) => s.name === mono_name && s.is_class);
 		const is_trait = !!status.traits.find((t) => t.name === mono_name);
 		arg_c_types.push(is_class || is_trait ? `struct ${mono_name} *` : `${c_type(mono_name)}`);
@@ -37277,6 +37425,10 @@ function build_magic_ctor_node(node, status) {
 		if (i > 0) c += ", ";
 		c += `${arg_c_types[i]} arg${i}`;
 	}
+	if (capture) {
+		if (arg_c_types.length > 0) c += ", ";
+		c += capture.helper_params;
+	}
 	c += `) {\n`;
 	c += `\tstruct ${struct_name} *a = (struct ${struct_name} *)malloc(sizeof(struct ${struct_name}));\n`;
 	for (let i = 0; i < arg_c_types.length; i++) c += `\ta->arg${i} = ${fat_string_args[i] ? "nomen_str_dup(arg" + i + ")" : `arg${i}`};\n`;
@@ -37291,6 +37443,7 @@ function build_magic_ctor_node(node, status) {
 	c += `\tf->refs = 1;\n`;
 	c += `\tf->cancel_flag = a->cancel_flag;\n`;
 	c += `\tf->result_slot = a->result_slot;\n`;
+	c += `\tf->slot_fat = ${slot_c_type === "nomen_string" ? 1 : 0};\n`;
 	c += `\tf->fiber_waiters = NULL;\n`;
 	c += `\tf->owning_fiber = 0;\n`;
 	c += `\ta->future = f;\n`;
@@ -37307,6 +37460,7 @@ function build_magic_ctor_node(node, status) {
 	c += `\tself->cancel_flag = (unsigned long long)a->cancel_flag;\n`;
 	c += `\tself->future = (unsigned long long)f;\n`;
 	if (info.has_started) c += `\tself->started = 0;\n`;
+	if (capture) c += capture.field_stores.join("");
 	c += `\treturn self;\n`;
 	c += `}\n`;
 	if (!status.file_scope_c) status.file_scope_c = "";
@@ -37318,6 +37472,8 @@ function build_magic_ctor_node(node, status) {
 		arg_slot.push(total_arg_slots);
 		total_arg_slots += fat_string_args[i] ? 2 : 1;
 	}
+	const capture_base_slot = total_arg_slots;
+	if (capture) total_arg_slots += capture.arg_count;
 	if (total_arg_slots === 0) emit_asm(status, `bl _${helper_name}\n`);
 	else {
 		const args_base = allocate_stack_space(status, total_arg_slots * 8, 16);
@@ -37328,6 +37484,17 @@ function build_magic_ctor_node(node, status) {
 			emit_asm(status, `str x0, [x29, #${args_base + arg_slot[i] * 8}]\n`);
 			if (fat_string_args[i]) emit_asm(status, `str x1, [x29, #${args_base + (arg_slot[i] + 1) * 8}]\n`);
 		}
+		if (capture && nursery_off) {
+			const addrs = [
+				nursery_off.futures_off,
+				nursery_off.count_off,
+				nursery_off.cap_off
+			];
+			for (let k = 0; k < addrs.length; k++) {
+				emit_asm(status, `add x9, x29, #${addrs[k]}\n`);
+				emit_asm(status, `str x9, [x29, #${args_base + (capture_base_slot + k) * 8}]\n`);
+			}
+		}
 		const NUM_REG_ARGS = 8;
 		const overflow_count = Math.max(0, total_arg_slots - NUM_REG_ARGS);
 		if (overflow_count > 0) {
@@ -37402,7 +37569,8 @@ function build_fn_value_ctor_a64(node, status, id, kind, info) {
 	c += `\t__nomen_future_release(a->future);\n`;
 	c += `}\n`;
 	c += `static struct nomen_closure ${desc_name} = { (void *)${tramp_name}, NULL, 0, NULL };\n`;
-	c += `void *${helper_name}(struct nomen_closure *fn) {\n`;
+	const fnval_capture = nursery_capture_a64(status, kind);
+	c += `void *${helper_name}(struct nomen_closure *fn${fnval_capture ? `, ${fnval_capture.helper_params}` : ""}) {\n`;
 	c += `\tstruct ${struct_name} *a = (struct ${struct_name} *)malloc(sizeof(struct ${struct_name}));\n`;
 	c += `\ta->fn = fn;\n`;
 	c += `\ta->result_slot = (${slot_c_type} *)${returns_value ? `malloc(sizeof(${slot_c_type}))` : "malloc(16)"};\n`;
@@ -37416,6 +37584,7 @@ function build_fn_value_ctor_a64(node, status, id, kind, info) {
 	c += `\tf->refs = 1;\n`;
 	c += `\tf->cancel_flag = a->cancel_flag;\n`;
 	c += `\tf->result_slot = a->result_slot;\n`;
+	c += `\tf->slot_fat = ${dup_result ? 1 : 0};\n`;
 	c += `\tf->fiber_waiters = NULL;\n`;
 	c += `\tf->owning_fiber = 0;\n`;
 	c += `\ta->future = f;\n`;
@@ -37432,6 +37601,7 @@ function build_fn_value_ctor_a64(node, status, id, kind, info) {
 	c += `\tself->cancel_flag = (unsigned long long)a->cancel_flag;\n`;
 	c += `\tself->future = (unsigned long long)f;\n`;
 	if (info.has_started) c += `\tself->started = 0;\n`;
+	if (fnval_capture) c += fnval_capture.field_stores.join("");
 	c += `\treturn self;\n`;
 	c += `}\n`;
 	if (!status.file_scope_c) status.file_scope_c = "";
@@ -37447,8 +37617,41 @@ function build_fn_value_ctor_a64(node, status, id, kind, info) {
 		if (!status.moved) status.moved = /* @__PURE__ */ new Set();
 		status.moved.add(name);
 	}
+	if (fnval_capture) {
+		const fnval_nursery_id = status.nursery_stack?.at(-1);
+		const fnval_off = fnval_nursery_id !== void 0 ? status.nursery_offsets?.get(fnval_nursery_id) : void 0;
+		if (fnval_off) {
+			const fnval_park = allocate_stack_space(status, 8, 8);
+			emit_asm(status, `str x0, [x29, #${fnval_park}]\n`);
+			emit_asm(status, `add x1, x29, #${fnval_off.futures_off}\n`);
+			emit_asm(status, `add x2, x29, #${fnval_off.count_off}\n`);
+			emit_asm(status, `add x3, x29, #${fnval_off.cap_off}\n`);
+			emit_asm(status, `ldr x0, [x29, #${fnval_park}]\n`);
+		}
+	}
 	emit_asm(status, `bl _${helper_name}\n`);
 }
+/**
+* LEXICAL NURSERY CAPTURE (ASYNC.md), aarch64 backend. The
+* construction helper is companion C and cannot address the enclosing async
+* block's frame, so the assembly passes the three tracking-slot addresses as
+* trailing helper arguments and the helper stores them into the instance's
+* capture fields — the lexical-at-construction counterpart of the C
+* backend's emit_nursery_capture_c. Applies to Thread/Fiber only (they
+* carry the capture fields).
+*/
+function nursery_capture_a64(status, kind) {
+	if (status.nursery_stack?.at(-1) === void 0 || kind !== "Thread" && kind !== "Fiber") return void 0;
+	return {
+		helper_params: "unsigned long long nursery_futures, unsigned long long nursery_count, unsigned long long nursery_cap",
+		field_stores: [
+			`\tself->nursery_futures = nursery_futures;\n`,
+			`\tself->nursery_count = nursery_count;\n`,
+			`\tself->nursery_cap = nursery_cap;\n`
+		],
+		arg_count: 3
+	};
+}
 //#endregion
 //#region ../src/build_aarch64/build_panic_node.ts
 function build_panic_node(node, status) {
@@ -37576,7 +37779,7 @@ function build_value_node(node, status) {
 			if (paramReg !== "x0") emit_asm(status, `mov x0, ${paramReg}`);
 		} else if (status.function_param_vars?.has(original_value) || status.function_param_vars?.has(value) || status.function_ref_params?.has(original_value) || status.function_ref_params?.has(value)) {
 			const param_type_name = node.type?.name;
-			if (param_type_name && status.structs.find((s) => s.name === param_type_name && s.is_class) || !!status.class_vars?.has(value) || !!status.class_vars?.has(original_value)) {
+			if (param_type_name && status.structs.find((s) => s.name === param_type_name && s.is_class) || !!param_type_name && !!status.traits.find((t) => t.name === param_type_name) || !!status.class_vars?.has(value) || !!status.class_vars?.has(original_value)) {
 				if (paramReg !== "x0") emit_asm(status, `mov x0, ${paramReg}`);
 			} else emit_asm(status, deref_load_instr(paramReg, param_type_name));
 		} else if (paramReg !== "x0") emit_asm(status, `mov x0, ${paramReg}`);
@@ -37628,7 +37831,7 @@ function build_value_node(node, status) {
 		if (status.function_ref_params?.has(value) || status.function_ref_params?.has(original_value)) {
 			if (alloc_reg !== "x0") emit_asm(status, `mov x0, ${alloc_reg}\n`);
 			const param_type_name = node.type?.name;
-			if (!(param_type_name && status.structs.find((s) => s.name === param_type_name && s.is_class) || !!status.class_vars?.has(value) || !!status.class_vars?.has(original_value))) emit_asm(status, deref_load_instr("x0", param_type_name));
+			if (!(param_type_name && status.structs.find((s) => s.name === param_type_name && s.is_class) || !!param_type_name && !!status.traits.find((t) => t.name === param_type_name) || !!status.class_vars?.has(value) || !!status.class_vars?.has(original_value))) emit_asm(status, deref_load_instr("x0", param_type_name));
 		} else if (alloc_reg !== "x0") {
 			if (alloc_reg.startsWith("d")) emit_asm(status, `fmov x0, ${alloc_reg}`);
 			else emit_asm(status, `mov x0, ${alloc_reg}`);
@@ -37836,7 +38039,7 @@ function build_node(node, status, with_semicolon = false) {
 			const access = node;
 			if (with_semicolon && access.access.node_type === "access_func") {
 				const afn = access.access;
-				if (afn.is_nursery_spawn || afn.is_thread_start || afn.is_thread_detach || afn.is_fiber_start) afn.is_statement = true;
+				if (afn.is_nursery_spawn) afn.is_statement = true;
 			}
 			build_access_node(access, status);
 			break;
@@ -39757,7 +39960,7 @@ function build_operand(node, target_reg, status) {
 		if (paramReg) {
 			if (status.function_param_vars?.has(value) || status.function_ref_params?.has(value)) {
 				const param_type_name = node.type?.name;
-				if (param_type_name && status.structs.find((s) => s.name === param_type_name && s.is_class)) {
+				if (param_type_name && status.structs.find((s) => s.name === param_type_name && s.is_class) || !!param_type_name && !!status.traits.find((t) => t.name === param_type_name)) {
 					if (paramReg !== target_reg) emit_asm(status, `mov ${target_reg}, ${paramReg}`);
 				} else emit_asm(status, `ldr ${target_reg}, [${paramReg}]`);
 			} else if (paramReg !== target_reg) emit_asm(status, `mov ${target_reg}, ${paramReg}`);
@@ -40990,113 +41193,6 @@ function array_licm_enabled() {
 	return array_licm_on;
 }
 //#endregion
-//#region ../src/build_aarch64/build_fiber_spawn.ts
-/**
-* Fiber scheduler runtime (ASYNC.md Phase 1), aarch64 backend.
-*
-* Same scheduler as the C backend's FIBER_HEADER (which see), but the
-* context switch is a naked-asm function compiled into the companion C —
-* 13 words (x19–x28, FP, LR, SP) per context, ~30 instructions per switch,
-* no ucontext. The raw-asm-called helpers (__nomen_fiber_yield,
-* __nomen_fiber_is_active, __nomen_fiber_set_cooperative — reached from
-* Fiber.nm's `#arch: aarch64` bodies as ___nomen_fiber_*) are non-static.
-*/
-/**
-* Build a `.start()` / `.start_on(buf)` launch on a `Fiber(fn(args))`
-* construction (or a stored Fiber binding) — aarch64 backend
-* (CLOSURE.md Phase 3b). A companion-C helper reads the packed
-* handles from the receiver's fields and launches the task closure on the
-* fiber scheduler (a heap stack, or the caller's fixed-size array buffer
-* for start_on — validated at check time, >= 16 KB), registers the future
-* with the enclosing nursery (if any), transfers the handles out of the
-* instance, and returns Task<T> (or NULL, fire-and-forget); the assembly
-* builds the receiver pointer and calls it.
-*/
-function build_fiber_spawn_node(access_func, target, status, start_on) {
-	ensure_concurrency_runtime_a64(status);
-	status.used_fibers = true;
-	const id = status.spawn_counter ?? 0;
-	status.spawn_counter = id + 1;
-	const helper_name = `nomen_fiber_${id}_start`;
-	const t_arg = spawn_result_type_arg$1(access_func.function_return_type);
-	const mono_fiber = mono_type_name("Fiber", [t_arg]);
-	const mono_task_name = mono_type_name("Task", [t_arg]);
-	const nursery_id = status.nursery_stack?.at(-1);
-	const nursery_off = nursery_id !== void 0 ? status.nursery_offsets?.get(nursery_id) : void 0;
-	const fire_and_forget = !!access_func.is_statement;
-	const target_is_temp = target.node_type === "func_call" && !!(target.is_thread_ctor || target.is_fiber_ctor);
-	const refs = fire_and_forget ? nursery_id !== void 0 ? 2 : 1 : nursery_id !== void 0 ? 3 : 2;
-	let c = `// --- fiber start site ${id} ---\n`;
-	c += `void *${helper_name}(void *self`;
-	let trailing = "";
-	if (nursery_off) trailing += `void **__nomen_nursery_futures, int *__nomen_nursery_count, int *__nomen_nursery_cap`;
-	if (start_on) trailing += `${trailing ? ", " : ""}void *__nomen_stack, unsigned long long __nomen_stack_size`;
-	if (trailing) c += `, ${trailing}`;
-	c += `) {\n`;
-	c += `\textern void *${mono_task_name}_traits[];\n\tstruct ${mono_fiber} *t = (struct ${mono_fiber} *)self;\n`;
-	c += `\tstruct nomen_future *f = (struct nomen_future *)t->future;\n`;
-	c += `\tvoid *result_ptr = (void *)t->result_slot;\n`;
-	c += `\tunsigned long long *cancel_ptr = (unsigned long long *)t->cancel_flag;\n`;
-	c += `\tstruct nomen_closure *cl = (struct nomen_closure *)t->task;\n`;
-	c += `\tf->refs = ${refs};\n`;
-	c += `\t__nomen_fiber_spawn${start_on ? "_on" : ""}(cl, f${start_on ? ", __nomen_stack, (size_t)__nomen_stack_size" : ""});\n`;
-	if (nursery_off) c += `\t__nomen_nursery_track(__nomen_nursery_futures, __nomen_nursery_count, __nomen_nursery_cap, f);\n`;
-	c += `\tt->task = 0;\n`;
-	c += `\tt->future = 0;\n`;
-	c += `\tt->result_slot = 0;\n`;
-	c += `\tt->cancel_flag = 0;\n`;
-	c += `\tt->started = 1;\n`;
-	if (target_is_temp) c += `\tfree(t);\n`;
-	if (fire_and_forget) c += `\treturn (void *)0;\n`;
-	else {
-		c += `\tstruct ${mono_task_name} *task = (struct ${mono_task_name} *)malloc(sizeof(struct ${mono_task_name}));\n`;
-		c += `\ttask->_vt = (void **)${mono_task_name}_traits;\n`;
-		c += `\ttask->handle = 0;\n`;
-		c += `\ttask->done = 0;\n`;
-		c += `\ttask->result_slot = (unsigned long long)result_ptr;\n`;
-		c += `\ttask->cancel_flag = (unsigned long long)cancel_ptr;\n`;
-		c += `\ttask->future = (unsigned long long)f;\n`;
-		c += `\treturn task;\n`;
-	}
-	c += `}\n`;
-	if (!status.file_scope_c) status.file_scope_c = "";
-	status.file_scope_c += c;
-	emit_asm(status, `// fiber start site ${id}\n`);
-	build_node(target, status);
-	ensure_newline(status);
-	let extra_slots = 0;
-	if (nursery_off) extra_slots += 3;
-	if (start_on) extra_slots += 2;
-	if (extra_slots > 0) {
-		const park = allocate_stack_space(status, 8, 8);
-		emit_asm(status, `str x0, [x29, #${park}]\n`);
-		if (nursery_off) {
-			emit_asm(status, `add x1, x29, #${nursery_off.futures_off}\n`);
-			emit_asm(status, `add x2, x29, #${nursery_off.count_off}\n`);
-			emit_asm(status, `add x3, x29, #${nursery_off.cap_off}\n`);
-		}
-		if (start_on) {
-			emit_asm(status, `// Build stack buffer address\n`);
-			emit_address_of(start_on, status);
-			ensure_newline(status);
-			emit_asm(status, `mov x${nursery_off ? 4 : 1}, x0\n`);
-			const buf_type = type_from_value_node$1(start_on);
-			const elem_size = buf_type.name === "string" ? 16 : 8;
-			const len_node = buf_type.length;
-			const len = len_node && len_node.node_type === "value" ? parseInt(len_node.value, 10) : NaN;
-			emit_asm(status, `// stack size = ${Number.isNaN(len) ? 0 : len} * ${elem_size}\n`);
-			emit_asm(status, `mov x${nursery_off ? 5 : 2}, #${Number.isNaN(len) ? 0 : len * elem_size}\n`);
-		}
-		emit_asm(status, `ldr x0, [x29, #${park}]\n`);
-	}
-	emit_asm(status, `bl _${helper_name}\n`);
-}
-/** The launch's T as a Type: the stamped wrapped-call return type, with
-*  void coerced to uint64 (Task's result-slot convention). */
-function spawn_result_type_arg$1(return_type) {
-	return return_type?.name && return_type.name !== "void" && return_type.name !== "?" ? new Type(return_type.name) : new Type("uint64");
-}
-//#endregion
 //#region ../src/build_aarch64/build_nursery_spawn.ts
 /**
 * Build a `name.start(Thread(fn(args)))` escape-hatch call for aarch64
@@ -41680,22 +41776,6 @@ function build_access_node(node, status) {
 			break;
 		case "access_func": {
 			const access_func = node.access;
-			if (node.target.node_type === "value" && node.target.value === "Fiber" && !status.used_fibers) {
-				ensure_concurrency_runtime_a64(status);
-				status.used_fibers = true;
-			}
-			if (access_func.is_thread_start) {
-				build_thread_start$1(access_func, node.target, status);
-				return;
-			}
-			if (access_func.is_thread_detach) {
-				build_thread_detach$1(access_func, node.target, status);
-				return;
-			}
-			if (access_func.is_fiber_start) {
-				build_fiber_spawn_node(access_func, node.target, status, access_func.is_fiber_start_on ? access_func.params[0] : void 0);
-				return;
-			}
 			if (access_func.is_nursery_spawn) {
 				build_nursery_spawn(node, access_func, status);
 				return;
@@ -41741,6 +41821,46 @@ function get_base_target(node) {
 	if (node.target.node_type === "access") return get_base_target(node.target);
 	return node.target;
 }
+/**
+* Resolve the concrete type of an access target (a local/param/`self` value or
+* a nested access), consulting the containing struct's field declarations when
+* a cached type is absent — an inferred `move` class field
+* (`pub move rules = RuleSet()`) carries no cached AccessFieldNode.type.
+*/
+function resolve_access_target_type(target, status) {
+	if (target.node_type === "value") {
+		const name = target.value;
+		if (name === "self" && status.current_struct) return new Type(status.current_struct.name);
+		if (status.variable_types?.has(name)) return status.variable_types.get(name);
+		const decl = status.scoped_declarations.findLast((d) => d.name === name);
+		if (decl?.type?.name) return decl.type;
+		return type_from_value_node$1(target);
+	}
+	if (target.node_type === "access") return type_from_value_node$1(target) ?? resolve_access_type(target, status) ?? void 0;
+	return type_from_value_node$1(target);
+}
+/**
+* Whether reading the final field of `node` must dereference an intermediate
+* pointer. The summed-offset-from-root load (`compute_field_offset` + the
+* base address) is only valid while every hop is an INLINE value struct. A
+* class-typed field — or a class-typed root value — stores a POINTER, so the
+* chain has to be built recursively (each pointer hop loaded) before the
+* final field is read. Without this, `state.rules.blocks.length` (State/
+* BlockParserState is a class) summed 8+8+8 and loaded from `state + 24`.
+*/
+function access_chain_crosses_class(node, status) {
+	const base_type = resolve_access_target_type(get_base_target(node), status);
+	if (base_type?.name && status.structs.find((s) => s.name === base_type.name && s.is_class)) return true;
+	let cursor = node;
+	while (cursor.node_type === "access") {
+		const acc = cursor;
+		if (acc.access.node_type !== "access_field") return false;
+		const ft = resolve_field_type(acc.access, resolve_access_target_type(acc.target, status)?.name, status);
+		if (ft?.name && status.structs.find((s) => s.name === ft.name && s.is_class)) return true;
+		cursor = acc.target;
+	}
+	return false;
+}
 function get_param_reg(name, status) {
 	return status.function_param_regs?.get(name);
 }
@@ -42140,9 +42260,11 @@ function build_access_field(node, status) {
 		emit_string_length(node.target, status);
 		return;
 	}
-	const offset = compute_field_offset(node, status);
+	let offset = compute_field_offset(node, status);
 	const base = get_base_target(node);
-	const target_is_class_access = node.target.node_type === "access" && node.target.access.node_type === "access_field" && !!status.structs.find((s) => s.name === node.target.access.type?.name && s.is_class);
+	const target_access_field = node.target.node_type === "access" && node.target.access.node_type === "access_field" ? node.target.access : void 0;
+	const target_class_field_type = target_access_field ? resolve_field_type(target_access_field, resolve_access_target_type(node.target.target, status)?.name, status) : void 0;
+	const target_is_class_access = !!target_class_field_type?.name && !!status.structs.find((s) => s.name === target_class_field_type.name && s.is_class);
 	if (node.target.node_type === "access" && node.target.access.node_type === "access_func") {
 		build_node(node.target, status);
 		ensure_newline(status);
@@ -42173,8 +42295,13 @@ function build_access_field(node, status) {
 		build_node(node.target, status);
 		ensure_newline(status);
 		const final_offset = get_field_offset(target_type?.name || "", access_field.name, status);
-		const field_type = access_field.type?.name || "";
-		if (field_type === "string" || access_field.type?.is_view) {
+		const class_access_field_type = status.structs.find((s) => s.name === (target_type?.name || "") && !s.is_simple_type)?.fields.find((f) => f.name === access_field.name)?.type ?? resolve_field_type(access_field, target_type?.name, status);
+		const field_type = class_access_field_type?.type_args?.length ? mono_type_name(class_access_field_type) : class_access_field_type?.name || access_field.type?.name || "";
+		if (!!field_type && !class_access_field_type?.is_ref && !class_access_field_type?.is_nullable && is_struct_type(field_type, status)) {
+			if (final_offset > 0) emit_asm(status, `add x0, x0, #${final_offset}\n`);
+			return;
+		}
+		if (field_type === "string" || class_access_field_type?.is_view) {
 			emit_string_pair_load_at(status, "x0", final_offset);
 			return;
 		}
@@ -42204,14 +42331,14 @@ function build_access_field(node, status) {
 			if (paramReg !== "x0") emit_asm(status, `mov x0, ${paramReg}\n`);
 		} else emit_var_load(status, "x0", name, 8);
 		const final_offset = get_field_offset(target_type?.name || "", access_field.name, status);
-		const field_type_obj = resolve_field_type(access_field, target_type?.name, status);
-		const resolved_field_type = field_type_obj?.name || "";
+		const field_type_obj = status.structs.find((s) => s.name === (target_type?.name || "") && !s.is_simple_type)?.fields.find((f) => f.name === access_field.name)?.type ?? resolve_field_type(access_field, target_type?.name, status);
+		const resolved_field_type = field_type_obj?.type_args?.length ? mono_type_name(field_type_obj) : field_type_obj?.name || "";
 		if (!!resolved_field_type && !field_type_obj?.is_ref && !field_type_obj?.is_nullable && is_struct_type(resolved_field_type, status)) {
 			if (final_offset > 0) emit_asm(status, `add x0, x0, #${final_offset}\n`);
 			return;
 		}
-		const field_type = access_field.type?.name || "";
-		if (field_type === "string" || access_field.type?.is_view) {
+		const field_type = resolved_field_type;
+		if (field_type === "string" || field_type_obj?.is_view) {
 			emit_string_pair_load_at(status, "x0", final_offset);
 			return;
 		}
@@ -42222,16 +42349,25 @@ function build_access_field(node, status) {
 		else emit_asm(status, `ldr x0, [x0, #${final_offset}]\n`);
 		return;
 	}
-	if (base.node_type === "value") {
-		const name = base.value;
-		const paramReg = get_param_reg(name, status);
-		if (paramReg) {
-			if (paramReg !== "x0") emit_asm(status, `mov x0, ${paramReg}\n`);
-		} else if (is_local_ref_var(name, status)) emit_deref_var_address(status, "x0", name);
-		else emit_var_address(status, "x0", name);
-	} else {
-		build_node(base, status);
+	let target_built = false;
+	if (node.target.node_type === "access" && access_chain_crosses_class(node, status)) {
+		build_node(node.target, status);
 		ensure_newline(status);
+		offset = get_field_offset(target_type?.name || "", access_field.name, status);
+		target_built = true;
+	}
+	if (!target_built) {
+		if (base.node_type === "value") {
+			const name = base.value;
+			const paramReg = get_param_reg(name, status);
+			if (paramReg) {
+				if (paramReg !== "x0") emit_asm(status, `mov x0, ${paramReg}\n`);
+			} else if (is_local_ref_var(name, status)) emit_deref_var_address(status, "x0", name);
+			else emit_var_address(status, "x0", name);
+		} else {
+			build_node(base, status);
+			ensure_newline(status);
+		}
 	}
 	const field_type_obj = resolve_field_type(access_field, target_type?.name, status);
 	const resolved_field_type = field_type_obj?.name || "";
@@ -42758,20 +42894,25 @@ function build_access_method(node, access_func, status) {
 		} else if (!target_is_simple && node.target.node_type === "access") {
 			const access_target = node.target;
 			if (access_target.access.node_type === "access_field") {
-				const offset = compute_field_offset(access_target, status);
-				const base = get_base_target(access_target);
-				if (base.node_type === "value") {
-					const name = base.value;
-					const paramReg = get_param_reg(name, status);
-					if (paramReg) {
-						if (paramReg !== "x0") emit_asm(status, `mov x0, ${paramReg}\n`);
-					} else if (is_local_ref_var(name, status)) emit_deref_var_address(status, "x0", name);
-					else emit_var_address(status, "x0", name);
-				} else {
-					build_node(base, status);
+				if (access_chain_crosses_class(access_target, status)) {
+					build_node(access_target, status);
 					ensure_newline(status);
+				} else {
+					const offset = compute_field_offset(access_target, status);
+					const base = get_base_target(access_target);
+					if (base.node_type === "value") {
+						const name = base.value;
+						const paramReg = get_param_reg(name, status);
+						if (paramReg) {
+							if (paramReg !== "x0") emit_asm(status, `mov x0, ${paramReg}\n`);
+						} else if (is_local_ref_var(name, status)) emit_deref_var_address(status, "x0", name);
+						else emit_var_address(status, "x0", name);
+					} else {
+						build_node(base, status);
+						ensure_newline(status);
+					}
+					if (offset > 0) emit_asm(status, `add x0, x0, #${offset}\n`);
 				}
-				if (offset > 0) emit_asm(status, `add x0, x0, #${offset}\n`);
 				if (target_type.is_array && target_type.is_array_heap) {
 					emit_asm(status, `ldr x0, [x0]\n`);
 					emit_asm(status, `add x0, x0, #8\n`);
@@ -42793,6 +42934,13 @@ function build_access_method(node, access_func, status) {
 		trait_recv_slot = allocate_stack_space(status, 8, 8);
 		emit_asm(status, `str x0, [x29, #${trait_recv_slot}]\n`);
 	}
+	const ctor_temp_node = node.target.node_type === "func_call" ? node.target : void 0;
+	const ctor_temp_receiver = !!(ctor_temp_node && (ctor_temp_node.is_thread_ctor || ctor_temp_node.is_fiber_ctor || ctor_temp_node.is_awaitable_ctor));
+	let ctor_recv_slot;
+	if (ctor_temp_receiver && !access_func.is_static && !receiver_is_string) {
+		ctor_recv_slot = allocate_stack_space(status, 8, 8);
+		emit_asm(status, `str x0, [x29, #${ctor_recv_slot}]\n`);
+	}
 	const raw_needs_self = !access_func.is_static && access_func.params.length > 0 && !receiver_is_string;
 	const inline_func0 = status.structs.find((s) => s.name === mono_struct_name)?.functions.find((f) => f.is_inline && f.name === access_func.name && (access_func.mangled_name ? mangled_label(f, mono_struct_name) === access_func.mangled_name : true));
 	const elide_self_save = raw_needs_self && !!inline_func0 && naked_inline_skips_self(inline_func0, status.platform);
@@ -43010,6 +43158,14 @@ function build_access_method(node, access_func, status) {
 	}
 	if (outgoing_size > 0) emit_asm(status, `add sp, sp, #${outgoing_size}\n`);
 	emit_dispose_lambda_args_a64(status, lambda_arg_slots);
+	if (ctor_recv_slot !== void 0) {
+		emit_asm(status, `str x0, [sp, #-16]!\n`);
+		emit_asm(status, `str x1, [sp, #-16]!\n`);
+		emit_asm(status, `ldr x0, [x29, #${ctor_recv_slot}]\n`);
+		emit_free(status);
+		emit_asm(status, `ldr x1, [sp], #16\n`);
+		emit_asm(status, `ldr x0, [sp], #16\n`);
+	}
 	if (frees_string_receiver) {
 		emit_asm(status, `ldr x9, [sp]\n`);
 		emit_asm(status, `str x0, [sp, #-16]!\n`);
@@ -43415,15 +43571,22 @@ function scan_spawn_callees(root, result) {
 		if (node.node_type === "spawn") {
 			spawn_call = node.call;
 			spawn_ret = node.function_return_type;
+		} else if (node.node_type === "func_call") {
+			if (node.is_thread_ctor || node.is_fiber_ctor) {
+				spawn_call = node.params?.[0];
+				spawn_ret = node.function_return_type;
+			}
 		} else if (node.node_type === "access" && node.access?.node_type === "access_func") {
-			if (node.access.is_thread_start || node.access.is_fiber_start) {
-				spawn_call = node.target?.params?.[0];
-				spawn_ret = node.access.function_return_type;
-			} else if (node.access.is_nursery_spawn) {
+			if (node.access.is_nursery_spawn) {
 				spawn_call = node.access.params?.[0]?.params?.[0];
 				spawn_ret = node.access.function_return_type;
 			}
 		}
+		if (spawn_call && spawn_call.node_type === "func") {
+			mark_fn_value_callees(spawn_call, spawn_ret, result);
+			spawn_call = void 0;
+			spawn_ret = void 0;
+		}
 		const name_and_ret = spawn_call && spawn_call.node_type === "func_call" ? [emission_label(spawn_call.resolved_function ?? { name: spawn_call.name }), spawn_ret ?? {}] : void 0;
 		if (name_and_ret && name_and_ret[0] && name_and_ret[1].name === "string") result.add(name_and_ret[0]);
 		for (const key of Object.keys(node)) {
@@ -43435,6 +43598,34 @@ function scan_spawn_callees(root, result) {
 	};
 	visit(root);
 }
+/**
+* Heap-normalize a function-value spawn's lambda (spawn_ret is the
+* construction's function return type; the lambda's own signature is the
+* fallback). Two marks:
+*
+* 1. The LAMBDA's emission label — a literal or borrowed-variable return
+*    inside the lambda is then strdup'd at the lambda's return site (the
+*    return build classifies through the same label).
+* 2. Every string-returning call the lambda returns DIRECTLY
+*    (`() => fn(args)`): the call's pair flows to the slot unchanged (a call
+*    result is not re-strdup'd at return), so the callee itself must
+*    normalize — the same mark the direct-call form puts on its callee.
+*/
+function mark_fn_value_callees(lambda, spawn_ret, result) {
+	if ((spawn_ret?.name ?? lambda.return_type?.name) !== "string") return;
+	result.add(emission_label(lambda));
+	const visit = (node) => {
+		if (!node || typeof node !== "object") return;
+		if (node.node_type === "return" && node.value?.node_type === "func_call" && node.value.type?.name === "string") result.add(emission_label(node.value.resolved_function ?? { name: node.value.name }));
+		for (const key of Object.keys(node)) {
+			if (key === "parent" || key === "scope") continue;
+			const val = node[key];
+			if (Array.isArray(val)) for (const item of val) visit(item);
+			else if (val && typeof val === "object") visit(val);
+		}
+	};
+	for (const s of lambda.statements ?? []) visit(s);
+}
 function scan_statements(statements, result, struct_name) {
 	for (const stmt of statements) {
 		if (stmt.node_type === "struct") {
@@ -44072,6 +44263,8 @@ function build(root, options = {}) {
 		status.code = reduce_pointer_walks(status.code);
 		status.code = unroll_loops_x2(status.code);
 		status.code = eliminate_dead_cycle_moves(status.code);
+		status.code = expand_large_mov_immediates(status.code);
+		status.code = expand_far_adr_addresses(status.code);
 		if (options.audit) {
 			status.code = status.code.replaceAll("bl _malloc\n", "bl _nomen_malloc_wrap\n");
 			status.code = status.code.replaceAll("bl _calloc\n", "bl _nomen_calloc_wrap\n");
@@ -44235,7 +44428,9 @@ const CALL_KEYWORDS = /* @__PURE__ */ new Set([
 	"trait",
 	"enum",
 	"bitset",
-	"cast"
+	"cast",
+	"panic",
+	"todo"
 ]);
 const NO_SPACE_BEFORE = /* @__PURE__ */ new Set([
 	",",
@@ -44316,8 +44511,8 @@ function needs_space(pieces, i) {
 	if (NO_SPACE_AFTER.has(previous.text)) return false;
 	if (previous.text === "out" || previous.text === "in") return current.text !== ".";
 	if (is_sign(pieces, i - 1)) return false;
-	if (current.text === ".") return !is_value_end(previous);
-	if (current.text === "(" || current.text === "[") return !is_value_end(previous) && !CALL_KEYWORDS.has(previous.text);
+	if (current.text === ".") return !is_value_end(pieces, i - 1);
+	if (current.text === "(" || current.text === "[") return !is_value_end(pieces, i - 1) && !CALL_KEYWORDS.has(previous.text);
 	if (current.kind === "comment") return current.space_before;
 	return true;
 }
@@ -44330,13 +44525,20 @@ function is_sign(pieces, i) {
 	if (PREFIX_POSITIONS.has(previous.text)) return true;
 	return previous.kind === "word" && KEYWORDS.has(previous.text);
 }
-/** Can the piece end a value, so that a following `(`, `[` or `.` binds to it? */
-function is_value_end(piece) {
+/**
+* Can the piece at `i` end a value, so that a following `(`, `[` or `.` binds
+* to it? A word after `.` is a member name, so it binds even when it spells a
+* keyword (`old_keys.move(i)`).
+*/
+function is_value_end(pieces, i) {
+	const piece = pieces[i];
 	switch (piece.kind) {
 		case "number":
 		case "string":
 		case "char": return true;
-		case "word": return !KEYWORDS.has(piece.text);
+		case "word":
+			if (i > 0 && pieces[i - 1].text === ".") return true;
+			return !KEYWORDS.has(piece.text);
 		case "symbol": return piece.text === ")" || piece.text === "]" || piece.text === ">" || piece.text === "?";
 		default: return false;
 	}
@@ -45055,12 +45257,12 @@ function is_list_open(pieces, i) {
 	const bracket = pieces[i].text;
 	if (bracket === "(") {
 		const previous = pieces[i - 1];
-		return !!previous && is_value_end(previous) && previous.text !== "=";
+		return !!previous && is_value_end(pieces, i - 1) && previous.text !== "=";
 	}
 	if (bracket === "[") {
 		const previous = pieces[i - 1];
 		if (previous?.kind === "word" && KEYWORDS.has(previous.text)) return false;
-		return !previous || !is_value_end(previous);
+		return !previous || !is_value_end(pieces, i - 1);
 	}
 	return false;
 }
@@ -45133,9 +45335,7 @@ function is_redundant(type, value) {
 	if (value.length > type.length && value[type.length].text === "(") {
 		if (match_bracket(value, type.length) === value.length - 1) {
 			const constructor = value.slice(0, type.length);
-			if (!constructor.some((piece) => piece.text === "<" || piece.text === ">")) {
-				if (type.every((piece, index) => piece.text === constructor[index].text)) return true;
-			}
+			if (type.every((piece, index) => piece.text === constructor[index].text)) return true;
 		}
 	}
 	if (value.length === 1 && type.length === 1) return literal_type(value[0]) === type[0].text && SAFE_LITERAL_TYPES.has(type[0].text);
@@ -48902,8 +49102,17 @@ function check_declaration_node(decl, status) {
 				const src_sv = /^[A-Za-z_][A-Za-z0-9_]*$/.test(src_name ?? "") ? status.values.findLast((v) => v.name === src_name) : void 0;
 				if (src_sv && !src_sv.trait_slot_conformer && src_sv.type.name === decl.type.name) add_error(status, `a class-backed trait local cannot be copied — reassign through the original binding or declare a new class instance`, decl.value.start);
 			}
-			if (!decl.type.name) decl.type = type_from_value_node(decl.value, status);
-			else if (decl.type.is_array && decl.value.node_type === "array") {
+			if (!decl.type.name) {
+				decl.type = type_from_value_node(decl.value, status);
+				if (!decl.type.name && status.type_params.length > 0 && decl.value.node_type === "func_call") {
+					const call = decl.value;
+					if (call.type_args?.length) {
+						const constructed = new Type(call.name);
+						constructed.type_args = call.type_args;
+						decl.type = constructed;
+					}
+				}
+			} else if (decl.type.is_array && decl.value.node_type === "array") {
 				const value_type = type_from_value_node(decl.value, status);
 				if (value_type.is_array && value_type.length) decl.type.length = value_type.length;
 			}
@@ -49473,20 +49682,25 @@ function infer_field_type_from_value(value, status) {
 * Resolving inferred field types upfront (right after gather_structs registers
 * every struct) makes them visible regardless of declaration order.
 *
-* Only non-generic structs are handled here, mirroring check_struct_node's own
-* field-type rewrite. The inference is structural to avoid re-running the full
-* declaration check and its side effects; check_struct_node later skips
-* already-resolved fields, so each field is resolved exactly once.
+* Only the field-type inference runs for generic structs too: a generic
+* field's initializer names the constructed type in terms of the struct's own
+* type params (`var items = Buffer<T>()` → `Buffer<T>`), which is exactly the
+* annotation it replaces, so recording it upfront is safe and keeps it visible
+* to the ownership classifier and to monomorphization. The buffer rewrite and
+* owning-param marking stay non-generic, mirroring check_struct_node. The
+* inference is structural to avoid re-running the full declaration check and
+* its side effects; check_struct_node later skips already-resolved fields, so
+* each field is resolved exactly once.
 */
 function resolve_struct_field_types(status) {
 	for (const struct of status.structs) {
-		if (struct.is_generic) continue;
 		for (const field of struct.fields) {
 			if (field.type.name) continue;
 			if (!field.value) continue;
 			const t = infer_field_type_from_value(field.value, status);
 			if (t?.name) field.type = t;
 		}
+		if (struct.is_generic) continue;
 		rewrite_generic_buffer_fields(struct, status);
 		mark_owning_auto_init_params(struct, status);
 	}
@@ -49502,8 +49716,9 @@ function resolve_struct_field_types(status) {
 *
 * A trait method with a default body need not be overridden; if it isn't,
 * the default is inherited (and, for generic traits, already synthesized
-* onto the struct by synthesize_generic_trait_defaults). `#init` and
-* `#destroy` are lifecycle hooks, not contract methods, so they're skipped.
+* onto the struct by synthesize_generic_trait_defaults). `#init`,
+* `#destroy` and `#spawn` are lifecycle hooks, not contract methods, so
+* they're skipped.
 */
 function check_trait_conformance(struct, status) {
 	for (let i = 0; i < struct.traits.length; i++) {
@@ -49514,7 +49729,7 @@ function check_trait_conformance(struct, status) {
 		const substitution = /* @__PURE__ */ new Map();
 		if (args && trait.type_params.length === args.length) for (let j = 0; j < trait.type_params.length; j++) substitution.set(trait.type_params[j], args[j].name);
 		for (const trait_func of trait.functions) {
-			if (trait_func.name === "#init" || trait_func.name === "#destroy") continue;
+			if (trait_func.name === "#init" || trait_func.name === "#destroy" || trait_func.name === "#spawn") continue;
 			const overrides = struct.functions.filter((f) => f.name === trait_func.name);
 			if (overrides.length === 0) {
 				if (!trait_func.has_body) add_error(status, `Type '${struct.name}' does not conform to trait '${trait.name}': missing required method '${trait_func.name}'`, struct.start);
@@ -50265,54 +50480,6 @@ function check_function_node(func, status) {
 	}
 }
 //#endregion
-//#region ../src/check/utils/awaitable_spawn_class.ts
-/**
-* The spawn-handle field contract an Awaitable class must declare for the
-* `X(fn(args))` construction sugar (ASYNC.md, "User-defined async
-* primitives"). The sugar packs the wrapped call eagerly and stores the
-* launch machinery in these fields — the same layout Thread/Fiber carry and
-* their own launch methods consume; a user primitive's launch methods read
-* the same contract.
-*/
-const SPAWN_FIELD_CONTRACT = [
-	"task",
-	"result_slot",
-	"cancel_flag",
-	"future"
-];
-/**
-* Resolve the Awaitable-conforming CLASS a generalized spawn-sugar call
-* (`X(fn(args))` / `X(() => work(n))`) targets. Undefined for everything
-* else: non-classes, classes not conforming to the core `Awaitable` trait,
-* and the reserved library names Thread/Fiber (whose own fast path runs
-* first and whose user-named shadows mean a plain struct).
-*
-* The class must additionally carry the spawn-handle field contract
-* (`spawn_field_contract_gaps`) and at most one type parameter before the
-* sugar fires — the callers validate those and report dedicated errors.
-*/
-function resolve_awaitable_spawn_class(name, status) {
-	if (name === "Thread" || name === "Fiber") return void 0;
-	const struct = resolve_declared_struct(name, status);
-	if (!struct || !struct.is_class) return void 0;
-	if (!struct.traits.includes("Awaitable")) return void 0;
-	return struct;
-}
-/**
-* The class's spawn-field contract gaps: one human-readable entry per
-* missing or mistyped handle field. Empty means the class can carry the
-* packed task machinery.
-*/
-function spawn_field_contract_gaps(struct) {
-	const gaps = [];
-	for (const field_name of SPAWN_FIELD_CONTRACT) {
-		const field = struct.fields.find((f) => f.name === field_name);
-		if (!field) gaps.push(`missing field '${field_name}'`);
-		else if (field.type?.name !== "uint64") gaps.push(`field '${field_name}' must be uint64, got '${field.type?.name || "<none>"}'`);
-	}
-	return gaps;
-}
-//#endregion
 //#region ../src/check/utils/enum_mono.ts
 /**
 * Monomorphize a generic enum (`enum Result<T, E>`) applied to concrete type
@@ -50496,39 +50663,37 @@ function synthesize_lambda_name(func, status) {
 //#endregion
 //#region ../src/check/utils/validate_spawn_args_sendable.ts
 /**
-* Validate a spawn's packed arguments (CLOSURE.md Phase 3d).
+* Validate a spawn's packed arguments (CLOSURE.md Phase 3d; the shrunk
+* `Sendable` — docs/ASYNC.md, "Design decisions").
+*
+* `Sendable` gates exactly the case that can race: a SHARED class/trait
+* reference crossing the task boundary (a plain argument — the packed env
+* aliases the instance). Everything else is exempt:
 *
-* Every argument must be Sendable — EXCEPT, inside a nursery
-* (`allow_borrows`), a non-Sendable CLASS or TRAIT argument that is a named
-* local or parameter: it is a BORROW capture (the env aliases the instance
-* for the task's lifetime, which the nursery's join-at-exit bounds by the
-* donors' lifetimes). Temps and field accesses are not borrowable — a temp
-* dies at the statement, and a field's owner may be shallower than the
-* task.
+* - MOVED arguments: the callee's `move T` parameter takes exclusive
+*   ownership, so no one else can touch the instance concurrently;
+* - scalars, strings, and everything `is_sendable_type` accepts (copied or
+*   safe by value — strings are deep-copied at pack);
+* - owning VALUE structs whose fields are all safe (the pack deep-copies
+*   them; `is_sendable_type`'s field recursion rejects a struct with an
+*   unsafe class field).
+*
+* The nursery-borrow exception (a non-Sendable class aliased into a task
+* inside `async { }`) is RETIRED: mark the class `Sendable`, move it in
+* (a `move` parameter), or share it through a `Sendable` primitive
+* (`Mutex`/`Channel`).
 */
-function validate_spawn_args_sendable(call, status, allow_borrows = false, reason) {
-	const result = { borrow_args: false };
-	for (const param of call.params) {
+function validate_spawn_args_sendable(call, status, reason) {
+	const callee_params = call.resolved_function?.params?.filter((p) => !p.is_self_param);
+	for (let i = 0; i < call.params.length; i++) {
+		const param = call.params[i];
 		let arg_type = type_from_value_node(param, status);
 		const stamped = param.type;
 		if (!arg_type.name && stamped?.name) arg_type = stamped;
+		if (callee_params?.[i]?.is_moved) continue;
 		if (is_sendable_type(arg_type.name, status)) continue;
-		const donor = param.node_type === "value" ? status.values.findLast((v) => v.name === param.value) : void 0;
-		const is_pointer_arg = (() => {
-			const struct = status.structs.find((s) => s.name === arg_type.name);
-			return !!struct && (struct.is_class || struct.traits.length > 0);
-		})();
-		if (allow_borrows && is_pointer_arg && donor) {
-			result.borrow_args = true;
-			continue;
-		}
-		if (allow_borrows && is_pointer_arg && !donor) {
-			add_error(status, `Spawn argument '${arg_type.name}' is not Sendable and may only be borrowed from a named local or parameter (a temporary would die before the task runs)`, param.start);
-			continue;
-		}
-		add_error(status, `Spawn argument of type ${arg_type.name || "<unknown>"} is not Sendable${is_pointer_arg && !allow_borrows ? reason ?? " — a non-Sendable class may only be passed inside a nursery (async { }), where the join bounds the borrow" : ""}`, param.start);
+		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; move it in (a `move` parameter) or share it through a Sendable primitive (Mutex/Channel)"}`, param.start);
 	}
-	return result;
 }
 //#endregion
 //#region ../src/check/check_function_call_node.ts
@@ -50548,28 +50713,17 @@ function find_free_function(status, name) {
 	return status.functions.findLast((f) => f.name === name && !is_method(f)) ?? status.functions.findLast((f) => f.name === name);
 }
 function check_function_call_node(node, status) {
-	const magic_ctor = node.name === "Thread" ? "Thread" : node.name === "Fiber" && !!resolve_declared_struct("Fiber", status)?.is_library ? "Fiber" : void 0;
-	const thread_shadow_struct = resolve_declared_struct("Thread", status);
+	const magic_ctor = resolve_declared_struct(node.name, status)?.functions.some((f) => f.name === "#spawn") ? node.name : void 0;
 	const first = node.params[0];
 	const first_decl = first?.node_type === "value" && typeof first.value === "string" ? status.values.findLast((v) => v.name === first.value) : void 0;
 	const first_fn = first?.node_type === "value" && typeof first.value === "string" ? status.functions.findLast((f) => f.name === first.value) : void 0;
 	const func_value_arg = first?.node_type === "func" || first?.node_type === "value" && typeof first.value === "string" && (first_decl?.func_params !== void 0 || !!first_fn);
 	const spawn_ctor_shape = node.params.length === 1 && (node.params[0].node_type === "func_call" || func_value_arg) && !find_free_function(status, node.name);
-	let awaitable_ctor;
-	if (!magic_ctor && spawn_ctor_shape) {
-		const candidate = resolve_awaitable_spawn_class(node.name, status);
-		if (candidate) {
-			const gaps = spawn_field_contract_gaps(candidate);
-			if (gaps.length === 0 && candidate.type_params.length <= 1) awaitable_ctor = candidate;
-			else {
-				const why = gaps.length ? `it lacks the spawn-field contract (${gaps.join("; ")})` : `it has ${candidate.type_params.length} type parameters (the sugar types the class as C<T> with T the wrapped call's return type)`;
-				add_error(status, `'${node.name}' conforms to Awaitable but cannot take the ${node.name}(fn(args)) construction sugar: ${why}`, node.start);
-				return false;
-			}
-		}
+	if (magic_ctor && !spawn_ctor_shape && !find_free_function(status, node.name)) {
+		add_error(status, "`#spawn` expects a call or a zero-argument function value (bind arguments in the lambda's captures)", first?.start ?? node.start);
+		return false;
 	}
-	if (magic_ctor && spawn_ctor_shape && !(magic_ctor === "Thread" && thread_shadow_struct && !thread_shadow_struct.is_library)) return check_magic_ctor(node, status, magic_ctor);
-	if (awaitable_ctor) return check_magic_ctor(node, status, awaitable_ctor.name);
+	if (magic_ctor && spawn_ctor_shape) return check_magic_ctor(node, status, magic_ctor);
 	let func = find_free_function(status, node.name);
 	if (func?.is_closure && func.captures?.length) func = void 0;
 	if (!func) {
@@ -50734,7 +50888,18 @@ function monomorphize(generic_struct, type_args, status) {
 	const mono_fields = generic_struct.fields.map((field) => {
 		const resolved_type = substitute_type(field.type, substitution);
 		const mono_field = new DeclarationNode(field.start, field.visibility, field.declaration, field.name, resolved_type, field.value ? clone_node(field.value) : void 0);
-		if (mono_field.value) substitute_raw_in_node(mono_field.value, substitution, status.structs, void 0, status.traits, status.enums);
+		if (mono_field.value) {
+			if (!mono_field.type.name && mono_field.value.node_type === "func_call") {
+				const call = mono_field.value;
+				const target = status.structs.find((s) => s.name === call.name);
+				if (target?.type_params.length && call.type_args?.length === target.type_params.length) {
+					const constructed = new Type(call.name);
+					constructed.type_args = call.type_args.map((arg) => substitute_type(arg, substitution));
+					mono_field.type = constructed;
+				}
+			}
+			substitute_raw_in_node(mono_field.value, substitution, status.structs, void 0, status.traits, status.enums);
+		}
 		mono_field.is_library = field.is_library;
 		mono_field.is_readonly = field.is_readonly;
 		mono_field.is_view_keyword = field.is_view_keyword;
@@ -50761,6 +50926,7 @@ function monomorphize(generic_struct, type_args, status) {
 	mono_struct.source_type_args = flat_args;
 	mono_struct.is_class = generic_struct.is_class;
 	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 = [];
@@ -51215,14 +51381,7 @@ function resolve_free_calls_in_node(node, status) {
 	const any_node = node;
 	if (node.node_type === "func_call" && !any_node.resolved_function) {
 		const name = node.name;
-		if (name === "Thread" || name === "Fiber") {
-			const fiber_struct = resolve_declared_struct("Fiber", status);
-			const magic = name === "Thread" ? "Thread" : fiber_struct?.is_library === true ? "Fiber" : void 0;
-			if (magic) rederive_magic_ctor_annotations(node, status, magic);
-		} else {
-			const candidate = resolve_awaitable_spawn_class(name, status);
-			if (candidate && spawn_field_contract_gaps(candidate).length === 0 && candidate.type_params.length <= 1) rederive_magic_ctor_annotations(node, status, candidate.name);
-		}
+		if (resolve_declared_struct(name, status)?.functions.some((f) => f.name === "#spawn")) rederive_magic_ctor_annotations(node, status, name);
 		const func = find_free_function(status, name);
 		if (func) set_resolved_function(node, func);
 	}
@@ -51281,18 +51440,6 @@ function derive_annotations_for_access_func(access_node, fc, status) {
 		rederive_nursery_spawn_annotations(fc, status);
 		return;
 	}
-	if (receiver_type === "Thread" && fc.name === "start") {
-		rederive_spawn_start_annotations(access_node, fc, status, "Thread", false);
-		return;
-	}
-	if (receiver_type === "Thread" && fc.name === "detach") {
-		rederive_spawn_detach_annotations(access_node, fc, status);
-		return;
-	}
-	if (receiver_type === "Fiber" && (fc.name === "start" || fc.name === "start_on")) {
-		rederive_spawn_start_annotations(access_node, fc, status, "Fiber", fc.name === "start_on");
-		return;
-	}
 	const struct = status.structs.find((s) => s.name === receiver_type);
 	if (!struct) return;
 	const func = struct.functions.find((f) => f.name === fc.name);
@@ -51377,7 +51524,7 @@ function check_magic_ctor(node, status, name) {
 		add_error(status, `Spawned call '${call.name}' did not resolve`, node.start);
 		return false;
 	}
-	validate_spawn_args_sendable(call, status, (status.nursery_depth ?? 0) > 0);
+	validate_spawn_args_sendable(call, status);
 	stamp_spawn_ctor(node, name);
 	const return_type = call.type;
 	const result_type_arg = return_type && return_type.name && return_type.name !== "void" && return_type.name !== "?" ? new Type(return_type.name) : new Type("uint64");
@@ -51402,7 +51549,8 @@ function stamp_spawn_ctor(node, name) {
 *  nothing) — carries T on the type args, which the `.start()` /
 *  nursery paths read. Also materializes Task<T>: the launch seam a user
 *  primitive drives is Task's runtime (Task.pool_submit / future_* —
-*  ASYNC.md, "User-defined async primitives"), and statics on the bare
+*  docs/ASYNC.md, "Extension: a class with its own `#spawn`"), and
+*  statics on the bare
 *  generic only link once a mono instantiation exists (the same
 *  materialization a `.start()` launch performs). */
 function stamp_spawn_type_args(node, status, name, result_type_arg) {
@@ -51554,61 +51702,6 @@ function rederive_nursery_spawn_annotations(fc, status) {
 	if (task_struct && task_struct.type_params.length > 0) monomorphize(task_struct, [result_type_arg], status);
 }
 /**
-* Re-derive the annotations for a `Thread(fn(args)).start()` /
-* `Fiber(fn(args)).start[_on](...)` call inside a monomorphised body —
-* mirroring check_spawn_start (check_access_node). The build gates its
-* spawn/fiber-trampoline emission on is_thread_start / is_fiber_start
-* (without them the call falls through to method resolution, which finds no
-* `start`) and the declaration-ownership analysis on owned_return (the Task
-* a spawn yields is a fresh heap allocation, not a borrow).
-*/
-function rederive_spawn_start_annotations(access_node, fc, status, name, _start_on) {
-	const ctor = access_node?.target;
-	const ctor_flagged = ctor?.node_type === "func_call" && (name === "Thread" ? ctor.is_thread_ctor : ctor.is_fiber_ctor);
-	if (name === "Thread") fc.is_thread_start = true;
-	else fc.is_fiber_start = true;
-	fc.owned_return = true;
-	let return_type;
-	if (ctor_flagged) {
-		const call = ctor.params[0];
-		return_type = ctor.function_return_type ?? call.type;
-		if (!return_type?.name) {
-			const func = find_free_function(status, call.name);
-			if (func) return_type = func.return_type;
-		}
-	} else return_type = (access_node?.target?.type)?.type_args?.[0];
-	if (!return_type?.name) return_type = new Type("uint64");
-	const is_void = !return_type.name || return_type.name === "void" || return_type.name === "?";
-	fc.function_return_type = is_void ? new Type("uint64") : return_type;
-	const result_type_arg = is_void ? new Type("uint64") : return_type;
-	if (!fc.type?.name) {
-		const task_type = new Type("Task");
-		task_type.type_args = [result_type_arg];
-		fc.type = task_type;
-	}
-	const task_struct = status.structs.find((s) => s.name === "Task");
-	if (task_struct && task_struct.type_params.length > 0) monomorphize(task_struct, [result_type_arg], status);
-}
-/**
-* Re-derive the annotations for a `Thread(fn(args)).detach()` call inside a
-* monomorphised body — mirroring check_spawn_detach (check_access_node).
-* The build gates its detached-pthread emission on is_thread_detach.
-*/
-function rederive_spawn_detach_annotations(access_node, fc, status) {
-	fc.is_thread_detach = true;
-	const ctor = access_node?.target;
-	if (ctor?.node_type === "func_call" && ctor.is_thread_ctor && ctor.params[0]) {
-		const call = ctor.params[0];
-		let return_type = ctor.function_return_type ?? call.type;
-		if (!return_type?.name) {
-			const func = find_free_function(status, call.name);
-			if (func) return_type = func.return_type;
-		}
-		fc.function_return_type = return_type;
-	} else fc.function_return_type = (access_node?.target?.type)?.type_args?.[0] ?? new Type("uint64");
-	if (!fc.type?.name) fc.type = new Type("void");
-}
-/**
 * Substitute type-param names through a function-typed parameter's nested
 * signature (`func (T, out T)` on a generic struct method or generic free
 * function). The signature hangs off the ParameterNode itself (`func_params`
@@ -51918,6 +52011,15 @@ function substitute_raw_in_node(node, substitution, structs, deref_params = /* @
 		any_node.name = mono_type_name(route_reference_elem(any_node.name.endsWith(old_suffix) ? any_node.name.slice(0, any_node.name.length - old_suffix.length) : any_node.name, any_node.type_args), any_node.type_args);
 	} else if (node.node_type === "access_func" && any_node.type_args?.length) any_node.type_args = any_node.type_args.map((t) => substitute_type(t, substitution));
 	if (node.node_type === "access" && any_node.access?.type_args?.length) any_node.access.type_args = any_node.access.type_args.map((t) => substitute_type(t, substitution));
+	if (node.node_type === "declare" && !any_node.type?.name && any_node.value?.node_type === "func_call") {
+		const call = any_node.value;
+		const target = structs.find((s) => s.name === call.name);
+		if (target?.type_params.length && call.type_args?.length === target.type_params.length) {
+			const constructed = new Type(call.name);
+			constructed.type_args = call.type_args;
+			any_node.type = constructed;
+		}
+	}
 	if (node.node_type === "declare" && any_node.type?.name) {
 		any_node.type = substitute_type(any_node.type, substitution);
 		if (any_node.type.name === "Buffer" && any_node.type.type_args?.length === 1 && is_reference_type_arg(any_node.type.type_args[0], structs, traits)) any_node.type.name = "ClassBuffer";
@@ -53284,6 +53386,11 @@ function check_access_node(node, status) {
 		status.allocations.push(decl);
 		node.target = new ValueNode(node.target.start, decl.name, target_type);
 	}
+	if (node.target.node_type === "access" && node.target.access.node_type === "access_func" && node.target.access.owned_return && !!status.structs.find((s) => (s.name === target_type.name || target_type.type_args?.length && s.name === mono_type_name(target_type)) && s.is_class)) {
+		const decl = new DeclarationNode(node.target.start, "private", "var", `_recv_${status.var_name_counter.value++}`, target_type, node.target);
+		status.allocations.push(decl);
+		node.target = new ValueNode(node.target.start, decl.name, target_type);
+	}
 	if (node.access.node_type === "access_field") {
 		const af = node.access;
 		if (af.is_destructure) {
@@ -53513,9 +53620,11 @@ function check_access_field_node(target_type, target, node, status) {
 }
 function check_access_function_node(target_type, target, node, status) {
 	if (target_type.name === "Nursery" && node.name === "start") return check_nursery_spawn(node, status);
-	if (target_type.name === "Thread" && node.name === "start") return check_spawn_start(target, target_type, node, status, "Thread", false);
-	if (target_type.name === "Thread" && node.name === "detach") return check_spawn_detach(target, target_type, node, status);
-	if (target_type.name === "Fiber" && (node.name === "start" || node.name === "start_on")) return check_spawn_start(target, target_type, node, status, "Fiber", node.name === "start_on");
+	if (target_type.name === "Fiber" && node.name === "start_on") {
+		if (!check_spawn_start_on(target, target_type, node, status)) return false;
+		node.name = "start";
+		node.params = [];
+	}
 	if (target_type.is_view) {
 		const elem_name = target_type.name === "string" ? "char" : target_type.name;
 		if (node.name === "at" && node.params.length === 1) {
@@ -53788,77 +53897,32 @@ function check_nursery_spawn(node, status) {
 	return true;
 }
 /**
-* Check a `Thread(fn(args)).start()` / `Fiber(fn(args)).start[_on](buf)`
-* call — the surface forms of a direct spawn (see ASYNC.md,
-* CLOSURE.md Phase 3b). The receiver is the magic constructor
-* (already checked — its args were packed eagerly) or any expression of
-* the spawn class's type; this types the expression as `Task<T>`. For
-* `start_on`, also validates the stack buffer: a fixed-size array of at
-* least 16 KB. The build launches the receiver's packed task closure
-* (submitting it to the pool or fiber scheduler) and yields Task<T>.
-*/
-function check_spawn_start(target, target_type, node, status, kind, start_on) {
-	const ctor = target;
-	const wrapped_call = target.node_type === "func_call" && (kind === "Thread" ? ctor.is_thread_ctor : ctor.is_fiber_ctor) ? ctor.params[0] : void 0;
-	let return_type = target_type.type_args?.[0];
-	if (!return_type?.name && wrapped_call) return_type = wrapped_call.type;
-	if (!return_type?.name) {
-		add_error(status, `${kind}(fn(args)).start expects a spawned call, e.g. ${kind}(work(n)).start()`, node.start);
+* Validate a `Fiber(fn(args)).start_on(buf)` call's stack buffer (see
+* ASYNC.md): a fixed-size array of at least 16 KB. The caller rewrites the
+* access to the ordinary Fiber.start afterwards — this function is
+* validation only.
+*/
+function check_spawn_start_on(target, target_type, node, status) {
+	if (node.params.length !== 1) {
+		add_error(status, `start_on expects a stack buffer argument, e.g. Fiber(work(n)).start_on(buf)`, node.start);
 		return false;
 	}
-	const call = wrapped_call;
-	if (start_on) {
-		if (node.params.length !== 1) {
-			add_error(status, `start_on expects a stack buffer argument, e.g. ${kind}(work(n)).start_on(buf)`, node.start);
-			return false;
-		}
-		const buf_type = type_from_value_node(node.params[0], status);
-		if (!buf_type.is_array) {
-			add_error(status, `start_on expects a fixed-size array stack buffer (T[N]), got ${buf_type.name || "<unknown>"}`, node.params[0].start);
-			return false;
-		}
-		const elem_size = buf_type.name === "string" ? 16 : 8;
-		const len_node = buf_type.length;
-		const len = len_node && len_node.node_type === "value" ? parseInt(len_node.value, 10) : NaN;
-		if (Number.isNaN(len)) {
-			add_error(status, "start_on expects a fixed-size array (T[N]); the length must be known at compile time", node.params[0].start);
-			return false;
-		}
-		if (len * elem_size < 16384) {
-			add_error(status, `Fiber stack too small: ${len * elem_size} bytes, minimum is 16384`, node.params[0].start);
-			return false;
-		}
+	const buf_type = type_from_value_node(node.params[0], status);
+	if (!buf_type.is_array) {
+		add_error(status, `start_on expects a fixed-size array stack buffer (T[N]), got ${buf_type.name || "<unknown>"}`, node.params[0].start);
+		return false;
+	}
+	const elem_size = buf_type.name === "string" ? 16 : 8;
+	const len_node = buf_type.length;
+	const len = len_node && len_node.node_type === "value" ? parseInt(len_node.value, 10) : NaN;
+	if (Number.isNaN(len)) {
+		add_error(status, "start_on expects a fixed-size array (T[N]); the length must be known at compile time", node.params[0].start);
+		return false;
+	}
+	if (len * elem_size < 16384) {
+		add_error(status, `Fiber stack too small: ${len * elem_size} bytes, minimum is 16384`, node.params[0].start);
+		return false;
 	}
-	const result_type_arg = return_type.name && return_type.name !== "void" && return_type.name !== "?" ? return_type : new Type("uint64");
-	const task_type = new Type("Task");
-	task_type.type_args = [result_type_arg];
-	node.function_return_type = return_type;
-	node.type = task_type;
-	if (call) call.type = task_type;
-	if (kind === "Thread") node.is_thread_start = true;
-	else node.is_fiber_start = true;
-	node.owned_return = true;
-	const task_struct = status.structs.find((s) => s.name === "Task");
-	if (task_struct && task_struct.type_params.length > 0) monomorphize(task_struct, [result_type_arg], status);
-	return true;
-}
-/**
-* Check a `Thread(fn(args)).detach()` call — the daemon form (see
-* ASYNC.md, "Daemon tasks"). The wrapped call runs on a dedicated detached
-* pthread (never a pool worker); nobody joins it, and process exit kills it
-* mid-execution BY DESIGN — the std::thread::spawn contract. The daemon
-* owns its own shutdown (a stop channel or flag), not process exit. There
-* is no handle, no future, and no cancellation: statement form only, the
-* expression types as void. The receiver is the magic constructor or any
-* Thread-typed expression (a stored daemon handle).
-*/
-function check_spawn_detach(target, target_type, node, status) {
-	const ctor = target;
-	const wrapped_call = target.node_type === "func_call" && ctor.is_thread_ctor ? ctor.params[0] : void 0;
-	if (wrapped_call) validate_spawn_args_sendable(wrapped_call, status, false, " — a detached task must own its arguments (it outlives every scope; only a nursery's join bounds a borrow)");
-	node.function_return_type = wrapped_call?.type ?? target_type.type_args?.[0] ?? new Type("uint64");
-	node.type = new Type("void");
-	node.is_thread_detach = true;
 	return true;
 }
 //#endregion
@@ -57545,7 +57609,7 @@ function parse_function(visibility, status, name_override, is_inline, is_extern,
 	if (op_internal[name]) name = op_internal[name];
 	const parent_for_type = status.stack.at(-1);
 	let return_type = new Type("");
-	if (name === "#init" && (parent_for_type?.node_type === "struct" || parent_for_type?.node_type === "extend")) return_type = new Type(parent_for_type.name);
+	if ((name === "#init" || name === "#spawn") && (parent_for_type?.node_type === "struct" || parent_for_type?.node_type === "extend")) return_type = new Type(parent_for_type.name);
 	const func = new FunctionNode(start, visibility, name, return_type);
 	if (is_inline) func.is_inline = true;
 	if (is_unsafe) {
@@ -57565,7 +57629,7 @@ function parse_function(visibility, status, name_override, is_inline, is_extern,
 	if (expect("=", status) && expect("(", status)) {
 		const parent = status.stack.at(-1);
 		if (peek_current(status) !== ")") parse_function_parameter(parent, func, status);
-		if (name === "#destroy" && parent.node_type === "struct" && !func.params.some((p) => p.is_self_param)) {
+		if ((name === "#destroy" || name === "#spawn") && parent.node_type === "struct" && !func.params.some((p) => p.is_self_param)) {
 			const self_param = new ParameterNode(start, "self", new Type(parent.name));
 			self_param.is_self_param = true;
 			self_param.declaration = "var";
@@ -57597,7 +57661,7 @@ function parse_function(visibility, status, name_override, is_inline, is_extern,
 				parse_statement(status);
 				expect("}", status);
 				status.stack.pop();
-				if (name !== "#init" && name !== "#destroy") check_missing_return(func, status);
+				if (name !== "#init" && name !== "#destroy" && name !== "#spawn") check_missing_return(func, status);
 			}
 			switch (parent.node_type) {
 				case "root":
@@ -57782,7 +57846,7 @@ function parse_struct(visibility, status, is_class = false) {
 		parse_statement(status);
 		expect("}", status);
 		status.stack.pop();
-		if (!struct.functions.some((f) => f.name === "#init")) {
+		if (!struct.functions.some((f) => f.name === "#init" || f.name === "#spawn")) {
 			const func = new FunctionNode(-1, visibility, "#init", new Type(struct.name));
 			func.params = struct.fields.filter((f) => f.visibility !== "private" && !f.value).map((f) => {
 				const param = new ParameterNode(-1, f.name, f.func_params ? new Type("func") : f.type);
@@ -58071,8 +58135,13 @@ function parse_visibility(visibility, status) {
 				consume(status);
 				consume(status);
 				parse_function(visibility, status, "#destroy");
+			} else if (next2 === "spawn") {
+				consume(status);
+				consume(status);
+				consume(status);
+				parse_function(visibility, status, "#spawn");
 			} else {
-				add_error(status, `Expected #init or #destroy after pub`, get_index(status));
+				add_error(status, `Expected #init, #destroy or #spawn after pub`, get_index(status));
 				consume(status);
 			}
 			break;
@@ -58199,8 +58268,12 @@ function parse_statement(status) {
 					consume(status);
 					consume(status);
 					parse_destroy(default_visibility(status), status, "#destroy");
+				} else if (next === "spawn") {
+					consume(status);
+					consume(status);
+					parse_destroy(default_visibility(status), status, "#spawn");
 				} else {
-					add_error(status, `Expected #init or #destroy`, get_index(status));
+					add_error(status, `Expected #init, #destroy or #spawn`, get_index(status));
 					consume(status);
 				}
 				break;
@@ -58447,10 +58520,6 @@ function resolve_linked_types(source, library, file_path) {
 		if (library.types.has(token.value) && !BASE_TYPES.includes(token.value)) needed.add(token.value);
 		else if (library.functions.has(token.value) && !user_declared_funcs.has(token.value)) needed.add(token.value);
 	}
-	if (tokens.some((t) => t.value === "Thread" || t.value === "Fiber" || t.value === "async")) {
-		needed.add("Task");
-		needed.add("Sendable");
-	}
 	if (tokens.some((t) => t.value === "async")) needed.add("Nursery");
 	const resolved = resolve_types_with_deps(needed, library, is_library_file ? file_path : void 0);
 	if (!resolved) return source;