nomen-lang 0.4.0 → 0.6.0

package/core/System/Arena.nm

@@ -36,17 +36,17 @@ pub struct Arena<T> {
 	// Slot payloads. T = value struct/primitive routes to Buffer<T>; T =
 	// class/trait routes to ClassBuffer<T> (monomorphize rewrites the field),
 	// so slot ownership follows the usual element rules.
-	var Buffer<T> values = Buffer<T>()
+	var values = Buffer<T>()
 	// Per-slot generation, bumped on every free. Slots are calloc'd, so a
 	// fresh slot's generation is 0.
-	var Buffer<int> generations = Buffer<int>()
+	var generations = Buffer<int>()
 	// Freed slot indices available for reuse (LIFO free list). A raw Buffer
 	// plus an explicit count: a `List<int>` field would need its own
 	// monomorphization from inside a generic struct body.
-	var Buffer<int> free_indices = Buffer<int>()
-	var int free_count = 0
+	var free_indices = Buffer<int>()
+	var free_count = 0
 	// High-water mark: every index < count has a slot (live or free).
-	var int count = 0
+	var count = 0
 
 	/**
 	 * A fresh arena with no slots.
@@ -78,7 +78,7 @@ pub struct Arena<T> {
 		}
 		self.values.grow(index + 1)
 		self.values.store(index, value)
-		var ArenaRef<T> handle = ArenaRef<T>()
+		var handle = ArenaRef<T>()
 		handle.index = index
 		handle.generation = self.generations.load_int(index)
 		return handle

package/core/System/Awaitable.nm

@@ -0,0 +1,21 @@
+// Awaitable — the consumption side of the async model (ASYNC.md,
+// "Awaitable trait"). Park-flavored by design: `wait` MAY park the current
+// execution context (inside a fiber it parks the fiber and frees its
+// worker; on a raw thread it blocks). A Rust-style poll/Waker trait is
+// deliberately rejected — it would smuggle the state-machine transform back
+// in through the trait definition.
+//
+// `Task<T>` is the conformer: `Thread(...).start()` and `Fiber(...).start()`
+// both yield one, so a generic helper taking `Awaitable` waits on either.
+// The trait is deliberately NOT the place for must-start semantics —
+// start-optional lifecycles are legitimate for user primitives; must-start
+// is a per-struct `#destroy` contract (see Thread.nm / Fiber.nm and
+// ASYNC.md).
+
+/**
+ * Something whose completion can be waited on (may park the current context)
+ **/
+pub trait Awaitable {
+	func wait = (ref self) {
+	}
+}

package/core/System/Buffer.nm

@@ -37,7 +37,7 @@ pub struct Buffer<T> {
 		if new_cap == 0 {
 			new_cap = 8
 		}
-		while new_cap < needed; new_cap *= 2 {}
+		while new_cap < needed; new_cap *= 2 { }
 		self.data = realloc(self.data, new_cap * 4)
 		memset(self.data + self.cap * 4, 0, (new_cap - self.cap) * 4)
 		self.cap = new_cap
@@ -107,7 +107,7 @@ pub struct Buffer<T> {
 		if new_cap == 0 {
 			new_cap = 4
 		}
-		while new_cap < needed; new_cap *= 2 {}
+		while new_cap < needed; new_cap *= 2 { }
 		self.data = realloc(self.data, new_cap * 8)
 		memset(self.data + self.cap * 8, 0, (new_cap - self.cap) * 8)
 		self.cap = new_cap
@@ -204,7 +204,7 @@ pub struct Buffer<T> {
 		if new_cap == 0 {
 			new_cap = 4
 		}
-		while new_cap < needed; new_cap *= 2 {}
+		while new_cap < needed; new_cap *= 2 { }
 		self.data = realloc(self.data, new_cap * T_SIZE)
 		memset(self.data + self.cap * T_SIZE, 0, (new_cap - self.cap) * T_SIZE)
 		self.cap = new_cap
@@ -382,24 +382,29 @@ pub struct Buffer<T> {
 	// this raw form is correct for trivially-copyable elements only. NOT
 	// `inline`: the body calls through the fn pointer, so splicing the raw
 	// block into a caller would bypass the per-element specializations.
-	func modify = (ref self, int i: i >= 0 && i < self.cap, func (T, out T) f) {
+	func modify = (ref self, int i: i >= 0 && i < self.cap, func(T, out T) f) {
 		```
 		#arch: c
-		((T*)(unsigned long long)self->data)[i] = f(((T*)(unsigned long long)self->data)[i]);
+		((T*)(unsigned long long)self->data)[i] = ((T (*)(void *, T))f->code)(f->env, ((T*)(unsigned long long)self->data)[i]);
 		```
 		```
 		#arch: aarch64
-		// x19 = self, x1 = i, x2 = f. Scalar elements round-trip through x0
+		// x19 = self, x1 = i, x2 = f (a closure descriptor: { code, env,
+		// owned } — the call loads both words and passes env first, shifting
+		// the value argument to x1). Scalar elements round-trip through x1
 		// (width-matched); larger trivially-copyable structs pass the slot
 		// address and an sret pointer (x8) — the fn writes the replacement
 		// straight into the slot from a stack-stage copy of the old value.
 		stp x20, x21, [sp, #-16]!
 		stp x22, x23, [sp, #-16]!
+		stp x24, x25, [sp, #-16]!
 		mov x22, x2
 		ldr x9, [x19, #8]
 		mov x3, #T_SIZE
 		madd x20, x1, x3, xzr
 		add x20, x20, x9
+		ldr x24, [x22]
+		ldr x0, [x22, #8]
 		cmp x3, #8
 		b.gt .Lbuffer_modify_T_big
 		cmp x3, #1
@@ -408,18 +413,18 @@ pub struct Buffer<T> {
 		b.eq .Lbuffer_modify_T_ld2
 		cmp x3, #4
 		b.eq .Lbuffer_modify_T_ld4
-		ldr x0, [x20]
+		ldr x1, [x20]
 		b .Lbuffer_modify_T_call
 		.Lbuffer_modify_T_ld1:
-		ldrb w0, [x20]
+		ldrb w1, [x20]
 		b .Lbuffer_modify_T_call
 		.Lbuffer_modify_T_ld2:
-		ldrh w0, [x20]
+		ldrh w1, [x20]
 		b .Lbuffer_modify_T_call
 		.Lbuffer_modify_T_ld4:
-		ldr w0, [x20]
+		ldr w1, [x20]
 		.Lbuffer_modify_T_call:
-		blr x22
+		blr x24
 		cmp x3, #1
 		b.eq .Lbuffer_modify_T_st1
 		cmp x3, #2
@@ -445,11 +450,13 @@ pub struct Buffer<T> {
 		mov x1, x20
 		mov x2, x3
 		bl _memcpy
-		mov x0, sp
+		ldr x0, [x22, #8]
+		mov x1, sp
 		mov x8, x20
-		blr x22
+		blr x24
 		add sp, sp, x23
 		.Lbuffer_modify_T_end:
+		ldp x24, x25, [sp], #16
 		ldp x22, x23, [sp], #16
 		ldp x20, x21, [sp], #16
 		```
@@ -513,7 +520,11 @@ pub struct Buffer<T> {
 	// version that also reclaims dst's previous value first (see
 	// owning_buffer_specialize.ts); this raw form is correct for
 	// trivially-destructible elements only.
-	inline func shift = (ref self, int dst: dst >= 0 && dst < self.cap, int src: src >= 0 && src < self.cap) {
+	inline func shift = (
+		ref self,
+		int dst: dst >= 0 && dst < self.cap,
+		int src: src >= 0 && src < self.cap
+	) {
 		```
 		#arch: c
 		T* _slots = (T*)(unsigned long long)self->data;
@@ -580,7 +591,12 @@ pub struct Buffer<T> {
 	// self's scope and is invalidated if self is reassigned. This is the single
 	// primitive every other slice (Array<T>, List<T>, user containers) builds
 	// on — higher layers just `return self.items.slice(start, end)`.
-	func slice = (self, int start: start >= 0, int end: end >= start && end <= self.cap, out view T) {
+	func slice = (
+		self,
+		int start: start >= 0,
+		int end: end >= start && end <= self.cap,
+		out view T
+	) {
 		```
 		#arch: c
 		nomen_view _r;

package/core/System/Channel.nm

@@ -1,11 +1,13 @@
 // Channel — thread-safe single-direction queue for passing values between
 // tasks. Unbounded, FIFO, blocking receive.
 //
-// The queue node's payload is two words wide: every message carries a
-// (value, len) pair. `send`/`receive` move uint64 values (len stays 0);
-// `send_string`/`receive_string` move fat strings without truncating the len
-// half. A typed Channel<T> wrapper can come later — the storage story is
-// identical, only the call-site types change.
+// The queue node's payload is three words wide: every message carries a
+// (value, len, kind) triple. `send`/`receive` move uint64 values (len and
+// kind stay 0); `send_string`/`receive_string` move fat strings (kind = 1)
+// without truncating the len half. `#destroy` frees only string payloads —
+// a raw uint64 payload is a value, not a pointer. A typed Channel<T>
+// wrapper can come later — the storage story is identical, only the
+// call-site types change.
 //
 // String payloads are copied in and moved out: `send_string` duplicates the
 // value into the node (the sender keeps its own string), and
@@ -25,17 +27,20 @@ pub class Channel: Sendable {
 	pub var uint64 not_empty_cv = 0
 	pub var uint64 head = 0
 	pub var uint64 tail = 0
+	// Head of the parked-fiber wait list (guarded by mu). Send wakes it.
+	pub var uint64 waiters = 0
 
 	pub func #init = (self) {
 		```
 		#arch: c
 		#scope: file
 		#include <pthread.h>
-		struct nomen_channel_node {
-			unsigned long long value;
-			unsigned long long len;
-			struct nomen_channel_node *next;
-		};
+	struct nomen_channel_node {
+		unsigned long long value;
+		unsigned long long len;
+		unsigned long long kind; // 0 = uint64 payload, 1 = owned string
+		struct nomen_channel_node *next;
+	};
 		```
 		```
 		#arch: c
@@ -45,6 +50,7 @@ pub class Channel: Sendable {
 		pthread_cond_init((pthread_cond_t *)self->not_empty_cv, NULL);
 		self->head = 0;
 		self->tail = 0;
+		self->waiters = 0;
 		```
 		```
 		#arch: aarch64
@@ -60,6 +66,7 @@ pub class Channel: Sendable {
 		bl _pthread_cond_init
 		str xzr, [x19, #24]
 		str xzr, [x19, #32]
+		str xzr, [x19, #40]
 		```
 	}
 
@@ -69,6 +76,7 @@ pub class Channel: Sendable {
 		struct nomen_channel_node *n = (struct nomen_channel_node *)malloc(sizeof(struct nomen_channel_node));
 		n->value = value;
 		n->len = 0;
+		n->kind = 0;
 		n->next = NULL;
 		pthread_mutex_lock((pthread_mutex_t *)self->mu);
 		if (self->tail) {
@@ -78,25 +86,27 @@ pub class Channel: Sendable {
 		}
 		self->tail = (unsigned long long)n;
 		pthread_cond_signal((pthread_cond_t *)self->not_empty_cv);
+		__nomen_fiber_waitq_wake((struct nomen_fiber **)&self->waiters);
 		pthread_mutex_unlock((pthread_mutex_t *)self->mu);
 		```
 		```
 		#arch: aarch64
 		// x19 = self (set by prologue), x1 = value
 		str x1, [sp, #-16]!       // save value on stack
-		mov x0, #24               // node = { value, len, next }
+		mov x0, #32               // node = { value, len, kind, next }
 		bl _malloc                // x0 = node
 		ldr x1, [sp], #16         // restore value
 		str x1, [x0, #0]          // node->value = value
 		str xzr, [x0, #8]         // node->len = 0
-		str xzr, [x0, #16]        // node->next = NULL
+		str xzr, [x0, #16]        // node->kind = 0 (uint64 payload)
+		str xzr, [x0, #24]        // node->next = NULL
 		str x0, [sp, #-16]!       // save node on stack
 		ldr x0, [x19, #8]         // self->mu
 		bl _pthread_mutex_lock
 		ldr x2, [sp], #16         // restore node
 		ldr x1, [x19, #32]        // tail
 		cbz x1, .Lchannel_send_empty
-		str x2, [x1, #16]         // tail->next = node
+		str x2, [x1, #24]         // tail->next = node
 		b .Lchannel_send_enqueued
 		.Lchannel_send_empty:
 		str x2, [x19, #24]        // head = node
@@ -104,6 +114,8 @@ pub class Channel: Sendable {
 		str x2, [x19, #32]        // tail = node
 		ldr x0, [x19, #16]        // not_empty_cv
 		bl _pthread_cond_signal
+		add x0, x19, #40          // &self->waiters
+		bl ___nomen_fiber_waitq_wake
 		ldr x0, [x19, #8]         // self->mu
 		bl _pthread_mutex_unlock
 		```
@@ -120,6 +132,7 @@ pub class Channel: Sendable {
 		nomen_string _v = value.ptr ? nomen_str_dup(value) : (nomen_string){0, 0};
 		n->value = (unsigned long long)_v.ptr;
 		n->len = (unsigned long long)_v.len;
+		n->kind = 1;
 		n->next = NULL;
 		pthread_mutex_lock((pthread_mutex_t *)self->mu);
 		if (self->tail) {
@@ -129,13 +142,14 @@ pub class Channel: Sendable {
 		}
 		self->tail = (unsigned long long)n;
 		pthread_cond_signal((pthread_cond_t *)self->not_empty_cv);
+		__nomen_fiber_waitq_wake((struct nomen_fiber **)&self->waiters);
 		pthread_mutex_unlock((pthread_mutex_t *)self->mu);
 		```
 		```
 		#arch: aarch64
 		// x19 = self (set by prologue), x1 = value.ptr, x2 = value.len
 		stp x1, x2, [sp, #-32]!   // [sp]=ptr [sp+8]=len [sp+16]=node scratch
-		mov x0, #24               // node = { value, len, next }
+		mov x0, #32               // node = { value, len, kind, next }
 		bl _malloc                // x0 = node
 		str x0, [sp, #16]         // save node across the strdup call
 		ldr x1, [sp, #0]          // value.ptr
@@ -150,13 +164,15 @@ pub class Channel: Sendable {
 		str x0, [x2, #0]          // node->value = copied ptr
 		ldr x1, [sp, #8]          // value.len
 		str x1, [x2, #8]          // node->len = len
-		str xzr, [x2, #16]        // node->next = NULL
+		mov x1, #1
+		str x1, [x2, #16]         // node->kind = 1 (owned string payload)
+		str xzr, [x2, #24]        // node->next = NULL
 		ldr x0, [x19, #8]         // self->mu
 		bl _pthread_mutex_lock
 		ldr x2, [sp, #16]         // restore node
 		ldr x1, [x19, #32]        // tail
 		cbz x1, .Lchannel_send_str_empty
-		str x2, [x1, #16]         // tail->next = node
+		str x2, [x1, #24]         // tail->next = node
 		b .Lchannel_send_str_enqueued
 		.Lchannel_send_str_empty:
 		str x2, [x19, #24]        // head = node
@@ -164,6 +180,8 @@ pub class Channel: Sendable {
 		str x2, [x19, #32]        // tail = node
 		ldr x0, [x19, #16]        // not_empty_cv
 		bl _pthread_cond_signal
+		add x0, x19, #40          // &self->waiters — wake parked fibers
+		bl ___nomen_fiber_waitq_wake
 		ldr x0, [x19, #8]         // self->mu
 		bl _pthread_mutex_unlock
 		add sp, sp, #32
@@ -175,7 +193,13 @@ pub class Channel: Sendable {
 		#arch: c
 		pthread_mutex_lock((pthread_mutex_t *)self->mu);
 		while (!self->head) {
-			pthread_cond_wait((pthread_cond_t *)self->not_empty_cv, (pthread_mutex_t *)self->mu);
+			// Fibers park instead of blocking; a cancelled fiber returns the
+			// zero value rather than waiting forever (cooperative cancel).
+			if (!__nomen_fiber_waitq_park(
+					(struct nomen_fiber **)&self->waiters, (void *)self->mu, (void *)self->not_empty_cv)) {
+				pthread_mutex_unlock((pthread_mutex_t *)self->mu);
+				return 0;
+			}
 		}
 		struct nomen_channel_node *n = (struct nomen_channel_node *)self->head;
 		self->head = (unsigned long long)n->next;
@@ -193,13 +217,21 @@ pub class Channel: Sendable {
 		.Lchannel_receive_wait:
 		ldr x1, [x19, #24]        // head
 		cbnz x1, .Lchannel_receive_got
-		ldr x0, [x19, #16]        // not_empty_cv
+		add x0, x19, #40          // &self->waiters
 		ldr x1, [x19, #8]         // mu
-		bl _pthread_cond_wait
+		ldr x2, [x19, #16]        // not_empty_cv
+		bl ___nomen_fiber_waitq_park
+		cbz x0, .Lchannel_receive_cancelled
 		b .Lchannel_receive_wait
+		.Lchannel_receive_cancelled:
+		// Cancelled while waiting: return the zero value.
+		ldr x0, [x19, #8]         // self->mu
+		bl _pthread_mutex_unlock
+		mov x0, #0
+		b .Lchannel_receive_end
 		.Lchannel_receive_got:
 		// x1 = node
-		ldr x2, [x1, #16]         // node->next
+		ldr x2, [x1, #24]         // node->next
 		str x2, [x19, #24]        // head = node->next
 		cbnz x2, .Lchannel_receive_not_empty
 		str xzr, [x19, #32]       // tail = 0
@@ -211,6 +243,7 @@ pub class Channel: Sendable {
 		ldr x0, [x19, #8]         // self->mu
 		bl _pthread_mutex_unlock
 		ldr x0, [sp], #16         // pop value → x0 (return)
+		.Lchannel_receive_end:
 		```
 	}
 
@@ -223,7 +256,11 @@ pub class Channel: Sendable {
 		#arch: c
 		pthread_mutex_lock((pthread_mutex_t *)self->mu);
 		while (!self->head) {
-			pthread_cond_wait((pthread_cond_t *)self->not_empty_cv, (pthread_mutex_t *)self->mu);
+			if (!__nomen_fiber_waitq_park(
+					(struct nomen_fiber **)&self->waiters, (void *)self->mu, (void *)self->not_empty_cv)) {
+				pthread_mutex_unlock((pthread_mutex_t *)self->mu);
+				return (nomen_string){ 0, 0 };
+			}
 		}
 		struct nomen_channel_node *n = (struct nomen_channel_node *)self->head;
 		self->head = (unsigned long long)n->next;
@@ -243,13 +280,23 @@ pub class Channel: Sendable {
 		.Lchannel_receive_str_wait:
 		ldr x1, [x19, #24]        // head
 		cbnz x1, .Lchannel_receive_str_got
-		ldr x0, [x19, #16]        // not_empty_cv
+		add x0, x19, #40          // &self->waiters
 		ldr x1, [x19, #8]         // mu
-		bl _pthread_cond_wait
+		ldr x2, [x19, #16]        // not_empty_cv
+		bl ___nomen_fiber_waitq_park
+		cbz x0, .Lchannel_receive_str_cancelled
 		b .Lchannel_receive_str_wait
+		.Lchannel_receive_str_cancelled:
+		// Cancelled while waiting: return the empty fat string (x0 = ptr,
+		// x1 = len).
+		ldr x0, [x19, #8]         // self->mu
+		bl _pthread_mutex_unlock
+		mov x0, #0
+		mov x1, #0
+		b .Lchannel_receive_str_end
 		.Lchannel_receive_str_got:
 		// x1 = node
-		ldr x2, [x1, #16]         // node->next
+		ldr x2, [x1, #24]         // node->next
 		str x2, [x19, #24]        // head = node->next
 		cbnz x2, .Lchannel_receive_str_not_empty
 		str xzr, [x19, #32]       // tail = 0
@@ -264,6 +311,7 @@ pub class Channel: Sendable {
 		ldr x0, [x19, #8]         // self->mu
 		bl _pthread_mutex_unlock
 		ldp x0, x1, [sp], #16     // pop pair → x0/x1 (return)
+		.Lchannel_receive_str_end:
 		```
 	}
 
@@ -271,12 +319,13 @@ pub class Channel: Sendable {
 		```
 		#arch: c
 		if (self->mu) {
-			// Drain any pending nodes. A string payload that was never
-			// received still owns its buffer — free it with the node.
+			// Drain any pending nodes. A string payload (kind = 1) that was
+			// never received still owns its buffer — free it with the node.
+			// A uint64 payload (kind = 0) is a raw value, never a pointer.
 			struct nomen_channel_node *n = (struct nomen_channel_node *)self->head;
 			while (n) {
 				struct nomen_channel_node *next = n->next;
-				if (n->value) free((void *)n->value);
+				if (n->kind == 1 && n->value) free((void *)n->value);
 				free(n);
 				n = next;
 			}
@@ -295,14 +344,18 @@ pub class Channel: Sendable {
 		// x19 = self (set by prologue)
 		ldr x0, [x19, #8]         // self->mu
 		cbz x0, .Lchannel_destroy_done
-		// Drain nodes (freeing any unconsumed string payload)
+		// Drain nodes (freeing only owned-string payloads; a uint64
+		// payload is a raw value, never a pointer)
 		ldr x1, [x19, #24]        // head
 		.Lchannel_destroy_drain:
 		cbz x1, .Lchannel_destroy_drained
-		ldr x2, [x1, #16]         // next (before calls clobber x1)
+		ldr x2, [x1, #24]         // next (before calls clobber x1)
 		stp x1, x2, [sp, #-16]!   // save node + next
+		ldr x3, [x1, #16]         // payload kind (1 = owned string)
 		ldr x0, [x1, #0]          // payload ptr
 		cbz x0, .Lchannel_destroy_no_payload
+		cmp x3, #1
+		b.ne .Lchannel_destroy_no_payload
 		bl _free
 		.Lchannel_destroy_no_payload:
 		ldr x0, [sp, #0]          // node

package/core/System/ClassBuffer.nm

@@ -37,7 +37,7 @@ pub struct ClassBuffer<T> {
 		if new_cap == 0 {
 			new_cap = 4
 		}
-		while new_cap < needed; new_cap *= 2 {}
+		while new_cap < needed; new_cap *= 2 { }
 		self.data = realloc(self.data, new_cap * 8)
 		memset(self.data + self.cap * 8, 0, (new_cap - self.cap) * 8)
 		self.cap = new_cap
@@ -73,7 +73,7 @@ pub struct ClassBuffer<T> {
 		if new_cap == 0 {
 			new_cap = 4
 		}
-		while new_cap < needed; new_cap *= 2 {}
+		while new_cap < needed; new_cap *= 2 { }
 		self.data = realloc(self.data, new_cap * 8)
 		memset(self.data + self.cap * 8, 0, (new_cap - self.cap) * 8)
 		self.cap = new_cap
@@ -150,12 +150,12 @@ pub struct ClassBuffer<T> {
 	// unless `f` returned it. Storing the returned instance raw is sound:
 	// the slot takes sole ownership and `f`'s return is not retained
 	// elsewhere. NOT `inline`: the body calls through the fn pointer.
-	func modify = (ref self, int i: i >= 0 && i < self.cap, func (T, out T) f) {
+	func modify = (ref self, int i: i >= 0 && i < self.cap, func(T, out T) f) {
 		```
 		#arch: c
 		long *slots = (long*)(unsigned long long)self->data;
 		void *old = (void*)slots[i];
-		void *new_value = (void*)f(old);
+		void *new_value = (void*)((void *(*)(void *, void *))f->code)(f->env, old);
 		slots[i] = (long)new_value;
 		if (old != new_value) {
 			T_destroy(old);
@@ -164,15 +164,19 @@ pub struct ClassBuffer<T> {
 		```
 		```
 		#arch: aarch64
-		// x19 = self, x1 = i, x2 = f. Class slots are one pointer wide.
+		// x19 = self, x1 = i, x2 = f (a closure descriptor — env goes in x0,
+		// the old slot value shifts to x1). Class slots are one pointer wide.
 		stp x20, x21, [sp, #-16]!
 		stp x22, x23, [sp, #-16]!
+		stp x24, x25, [sp, #-16]!
 		mov x22, x2
 		ldr x9, [x19, #8]
 		lsl x3, x1, #3
 		add x20, x9, x3
-		ldr x0, [x20]
-		blr x22
+		ldr x24, [x22]
+		ldr x0, [x22, #8]
+		ldr x1, [x20]
+		blr x24
 		mov x23, x0
 		ldr x9, [x20]
 		str x23, [x20]
@@ -183,6 +187,7 @@ pub struct ClassBuffer<T> {
 		mov x0, x9
 		bl _free
 		.Lcb_modify_T_done:
+		ldp x24, x25, [sp], #16
 		ldp x22, x23, [sp], #16
 		ldp x20, x21, [sp], #16
 		```
@@ -294,7 +299,11 @@ pub struct ClassBuffer<T> {
 	// instance afterwards. The class-buffer counterpart of Buffer.shift,
 	// used by Map/Set.remove's backward-shift so shifting entries neither
 	// duplicates nor orphans owned instances.
-	func shift = (ref self, int dst: dst >= 0 && dst < self.cap, int src: src >= 0 && src < self.cap) {
+	func shift = (
+		ref self,
+		int dst: dst >= 0 && dst < self.cap,
+		int src: src >= 0 && src < self.cap
+	) {
 		```
 		#arch: c
 		long *slots = (long*)(unsigned long long)self->data;
@@ -338,7 +347,12 @@ pub struct ClassBuffer<T> {
 	// pointers, returned as a `view T` (T is a class, so each element is an
 	// 8-byte pointer). Borrows from self — invalidated on reassignment. Mirrors
 	// Buffer.slice; ClassBuffer stores 8-byte slots, so the element width is 8.
-	func slice = (self, int start: start >= 0, int end: end >= start && end <= self.cap, out view T) {
+	func slice = (
+		self,
+		int start: start >= 0,
+		int end: end >= start && end <= self.cap,
+		out view T
+	) {
 		```
 		#arch: c
 		nomen_view _r;

package/core/System/Controls/Button.nm

@@ -1,7 +1,7 @@
 /**
  * A push-button control that triggers an action when clicked
  **/
-pub class Button : Control {
+pub class Button: Control {
 	var uint64 handle = 0
 
 	pub func #init = (self, Window window, string title) {
@@ -162,7 +162,7 @@ pub class Button : Control {
 
 	pub func intrinsic_size = (self, out Size) {
 		var [w, h] = native_intrinsic(self.handle)
-		var Size s = Size()
+		var s = Size()
 		s.width = w
 		s.height = h
 		return s

package/core/System/Controls/CheckBox.nm

@@ -1,7 +1,7 @@
 /**
  * A toggle control with a title and checked/hidden state
  **/
-pub class CheckBox : Control {
+pub class CheckBox: Control {
 	var uint64 handle = 0
 
 	pub func #init = (self, Window window) {
@@ -199,7 +199,7 @@ pub class CheckBox : Control {
 	// ── Control trait conformance ──
 	pub func intrinsic_size = (self, out Size) {
 		var [w, h] = native_intrinsic(self.handle)
-		var Size s = Size()
+		var s = Size()
 		s.width = w
 		s.height = h
 		return s

package/core/System/Controls/Container.nm

@@ -248,7 +248,7 @@ pub func native_intrinsic = (uint64 handle, out [int, int]) {
  * so a `Container` can also be driven polymorphically as a `Control` (passed to
  * a `Control`-taking function, stored in a `ClassBuffer<Control>`, etc.).
  **/
-pub class Container : Control {
+pub class Container: Control {
 	var kinds = Buffer<int>()
 	// Per-leaf requested size, stored as a (kind, value) pair per axis. The
 	// kind is one of LEN_* (auto/fixed/percent/fill); the value is the pixel
@@ -1358,7 +1358,7 @@ pub class Container : Control {
 			constraints.max_height,
 		)
 		var int h = self.rh.load_int(self.root)
-		var Size s = Size()
+		var s = Size()
 		s.width = w
 		s.height = h
 		return s
@@ -1371,7 +1371,7 @@ pub class Container : Control {
 	pub func intrinsic_size = (self, out Size) {
 		var int w = self.measure_node(self.root, 0, INF, 0, INF)
 		var int h = self.rh.load_int(self.root)
-		var Size s = Size()
+		var s = Size()
 		s.width = w
 		s.height = h
 		return s

package/core/System/Controls/TextBox.nm

@@ -1,7 +1,7 @@
 /**
  * An editable single-line text input control
  **/
-pub class TextBox : Control {
+pub class TextBox: Control {
 	var uint64 handle = 0
 
 	pub func #init = (self, Window window) {
@@ -203,7 +203,7 @@ pub class TextBox : Control {
 	// ── Control trait conformance ──
 	pub func intrinsic_size = (self, out Size) {
 		var [w, h] = native_intrinsic(self.handle)
-		var Size s = Size()
+		var s = Size()
 		s.width = w
 		s.height = h
 		return s