nomen-lang 0.4.0 → 0.5.0

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

@@ -385,21 +385,26 @@ pub struct Buffer<T> {
 	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
 		```

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
@@ -175,7 +191,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 +215,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 +241,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 +254,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 +278,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 +309,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 +317,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 +342,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

@@ -155,7 +155,7 @@ pub struct ClassBuffer<T> {
 		#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
 		```

package/core/System/Fiber.nm

@@ -0,0 +1,121 @@
+// Fiber — a stackful coroutine (ASYNC.md Phase 1). Fibers multiplex
+// over the worker pool's threads: a parked fiber frees its worker instead of
+// blocking it, so thousands of waiting tasks cost stacks (~64 KB each), not
+// threads (~MB each).
+//
+// `Fiber(fn(args)).start()` mirrors `Thread(fn(args)).start()` — same eager
+// arg packing into a task closure, same future, same Task<T> handle — but
+// the wrapped call runs on a fiber stack under the fiber scheduler. While
+// it waits (Task.result/wait, Channel.receive), the fiber parks and the
+// worker moves on; `Fiber.yield()` cooperatively hands the worker to the
+// next runnable fiber.
+//
+// Like Thread, a Fiber construction is a real value: it can be stored and
+// started later (`var f = Fiber(work(n))`, then `f.start()` or
+// `f.start_on(buf)`), and destroying an unstarted Fiber is a programming
+// error that #destroy reports and aborts on (must-start — the library
+// pattern from ASYNC.md).
+//
+// `Fiber(fn(args)).start_on(buf)` runs the fiber on a caller-provided
+// fixed-size array stack (>= 16 KB) — the embedded/no-heap path.
+//
+// `Fiber.set_cooperative(true)` (before the first spawn) runs fibers on the
+// calling thread and never starts worker threads — a cooperative,
+// single-threaded runtime for bare-metal targets.
+//
+// The constructor, `.start`, and `.start_on` are compiler-special-cased
+// (they need the per-site spawn/trampoline machinery), so they are NOT
+// regular methods declared here. The runtime (scheduler, context switch)
+// lives in the build's emitted companion C — see build_fiber_spawn.
+
+/**
+ * A stackful coroutine: lightweight, cooperatively scheduled, parks instead of blocking
+ **/
+pub class Fiber<T> : Sendable {
+	// The packed task closure (a `struct nomen_closure *`); owned by this
+	// value until start/start_on/nursery.start transfers it to the runtime.
+	pub var uint64 task = 0
+	// Result-slot / cancel-flag / future handles for the (single) launch.
+	pub var uint64 result_slot = 0
+	pub var uint64 cancel_flag = 0
+	pub var uint64 future = 0
+	// Must-start flag: set by .start() / .start_on(buf) / nursery.start.
+	pub var started = false
+
+	// Destroying an unstarted Fiber is a programming error (the wrapped
+	// call would silently never run) — report it and abort. A started
+	// Fiber owns nothing: the launch transferred the task closure, result
+	// slot, cancel flag, and future to the runtime, and cleared the fields.
+	pub func #destroy = () {
+		```
+		#arch: c
+		if (!self->started) {
+			__nomen_spawn_must_start_abort();
+		}
+		if (self->future) {
+			__nomen_future_release((struct nomen_future *)self->future);
+			self->future = 0;
+			self->result_slot = 0;
+			self->cancel_flag = 0;
+		}
+		```
+		```
+		#arch: aarch64
+		// if (!self->started) __nomen_spawn_must_start_abort()
+		ldrb w0, [x19, #40]
+		cbnz w0, .Lfb_started
+		bl ___nomen_spawn_must_start_abort
+		.Lfb_started:
+		// if (self->future) { release it (an unstarted task's future is
+		// unshared — refs == 1 — so this tears down slot + flag + future);
+		// zero the fields }
+		ldr x0, [x19, #32]
+		cbz x0, .Lfb_done
+		bl ___nomen_future_release
+		str xzr, [x19, #32]
+		str xzr, [x19, #16]
+		str xzr, [x19, #24]
+		.Lfb_done:
+		```
+	}
+
+	// Hand the worker to the next runnable fiber. No-op outside a fiber.
+	pub func yield = () {
+		```
+		#arch: c
+		__nomen_fiber_yield();
+		```
+		```
+		#arch: aarch64
+		bl ___nomen_fiber_yield
+		```
+	}
+
+	// Is the calling code running inside a fiber? True when Fiber.yield or
+	// fiber parking would take effect.
+	pub func is_fiber = (out bool) {
+		```
+		#arch: c
+		return __nomen_fiber_is_active();
+		```
+		```
+		#arch: aarch64
+		bl ___nomen_fiber_is_active
+		```
+	}
+
+	// Run fibers on the calling thread and never start worker threads. Must
+	// be called before the first fiber spawn; intended for single-threaded
+	// (bare-metal) targets. In cooperative mode a fiber that parks on an
+	// event only another thread could fire will never resume.
+	pub func set_cooperative = (bool on) {
+		```
+		#arch: c
+		__nomen_fiber_set_cooperative(on ? 1 : 0);
+		```
+		```
+		#arch: aarch64
+		bl ___nomen_fiber_set_cooperative
+		```
+	}
+}

package/core/System/Mutex.nm

@@ -3,6 +3,12 @@
 // Default stance in Nomen is "no shared mutable state" — communicate by moving
 // Sendable values (or via Channel<T>). Mutex exists for when you genuinely
 // need shared mutability. See ASYNC.md.
+//
+// A fiber that would block on a contended lock parks instead of blocking its
+// worker (both models), and unlock wakes the parked fibers. Cancellation
+// while waiting never returns without the lock — a waiter keeps waiting and
+// observes the cancel flag at its next checkpoint after acquiring — so a
+// matching unlock is always sound.
 
 /**
  * A pthread-backed mutual-exclusion lock for protecting shared mutable state
@@ -10,69 +16,59 @@
 pub class Mutex: Sendable {
 	pub var uint64 handle = 0
 
-	pub func #init = (self) {
-		```
-		#arch: c
-		#scope: file
-		#include <pthread.h>
-		```
-		```
-		#arch: c
-		self->handle = (unsigned long long)malloc(sizeof(pthread_mutex_t));
-		pthread_mutex_init((pthread_mutex_t *)self->handle, NULL);
-		```
-		```
-		#arch: aarch64
-		mov x0, #64
-		bl _malloc
-		str x0, [x19, #8]
-		mov x1, #0
-		bl _pthread_mutex_init
-		```
-	}
+pub func #init = (self) {
+	```
+	#arch: c
+	self->handle = (unsigned long long)__nomen_mutex_create();
+	```
+	```
+	#arch: aarch64
+	bl ___nomen_mutex_create
+	str x0, [x19, #8]
+	```
+}
 
-	pub func lock = (self) {
-		```
-		#arch: c
-		pthread_mutex_lock((pthread_mutex_t *)self->handle);
-		```
-		```
-		#arch: aarch64
-		ldr x0, [x19, #8]
-		bl _pthread_mutex_lock
-		```
-	}
+pub func lock = (self) {
+	```
+	#arch: c
+	// Fibers park instead of blocking the worker (both models); other
+	// contexts take the pthread lock directly.
+	__nomen_mutex_lock((void *)self->handle);
+	```
+	```
+	#arch: aarch64
+	ldr x0, [x19, #8]
+	bl ___nomen_mutex_lock
+	```
+}
 
-	pub func unlock = (self) {
-		```
-		#arch: c
-		pthread_mutex_unlock((pthread_mutex_t *)self->handle);
-		```
-		```
-		#arch: aarch64
-		ldr x0, [x19, #8]
-		bl _pthread_mutex_unlock
-		```
-	}
+pub func unlock = (self) {
+	```
+	#arch: c
+	__nomen_mutex_unlock_wake((void *)self->handle);
+	```
+	```
+	#arch: aarch64
+	ldr x0, [x19, #8]
+	bl ___nomen_mutex_unlock_wake
+	```
+}
 
-	pub func #destroy = () {
-		```
-		#arch: c
-		if (self->handle) {
-			pthread_mutex_destroy((pthread_mutex_t *)self->handle);
-			free((void *)self->handle);
-			self->handle = 0;
-		}
-		```
-		```
-		#arch: aarch64
-		ldr x0, [x19, #8]
-		cbz x0, .Lmutex_destroy_end
-		bl _pthread_mutex_destroy
-		ldr x0, [x19, #8]
-		bl _free
-		str xzr, [x19, #8]
-		.Lmutex_destroy_end:
-		```
+pub func #destroy = () {
+	```
+	#arch: c
+	if (self->handle) {
+		__nomen_mutex_dispose((void *)self->handle);
+		self->handle = 0;
 	}
+	```
+	```
+	#arch: aarch64
+	ldr x0, [x19, #8]
+	cbz x0, .Lmutex_destroy_end
+	bl ___nomen_mutex_dispose
+	str xzr, [x19, #8]
+	.Lmutex_destroy_end:
+	```
+}
 }