nomen-lang 0.8.0 → 0.10.0

package/core/System/Text/JsonTree.nm

@@ -1,156 +1,184 @@
-// JsonTree: a flat pool of JSON tree nodes backed by a Buffer<JsonNode> slab.
-// Each node is a value struct stored at index N in the buffer; grow_T/store_T/
-// load_T handle the slab arithmetic. The caller creates a JsonTree once and
-// calls reset() per document to reuse the slab without reallocation.
+// JsonTree: a flat pool of JSON tree nodes backed by a StableList<JsonNode>.
+// Each node is a value struct appended to the list; node indices are list
+// indices, and list slots never move. The caller creates a JsonTree once and
+// calls reset() per document. The pool owns its node texts end to end —
+// set_text/take_text's interior field write frees the displaced text and the
+// list's own destroy reclaims every node — so there is no manual text
+// lifecycle. (The pre-StableList version kept a raw Buffer slab with a
+// hand-encoded element layout and a strdup/free dance; see the stable grow-only
+// arrays".)
 //
-// set_text is the one exception to the load/store pattern: it calls strdup
-// directly into the slab via raw code, because routing the strdup'd pointer
-// through an Nomen local would subject it to auto-free at scope exit, leaving
-// the slab's text pointer dangling.
+// Accessors read and write through the slot alias (`ref JsonNode n =
+// self.nodes.at(idx)`), the checked interior-mutation form: the alias binds
+// the slot itself, so field writes land in the list and reads copy nothing.
 
 // A node in a parsed JSON tree, stored by value in the pool.
 //   kind: 0=null, 1=true, 2=number, 3=string, 4=array, 5=object, 6=false
 //   child/next/val are node indices, -1 = none.
+//
+// `text` is nullable and seeds as `null` (the in-band zero pair): the auto
+// constructor stores no pointer for it, so a fresh node costs NO allocation
+// — every parsed node used to pay a strdup-of-"" seed plus the free when
+// take_text displaced it (or at destroy for kinds that never carry text).
+// set_text/take_text install the owned value; until then the field holds
+// null and every read (get_text/get_text_view) answers the empty string.
 mv struct JsonNode {
 	var kind = 0
-	var text = ""
+	var string? text = null
 	var int child = -1
 	var int next = -1
 	var int val = -1
 }
 
 /**
- * A flat, buffer-backed pool of JSON tree nodes — the parsed representation `Json.parse` produces
+ * A flat, pool-backed set of JSON tree nodes — the parsed representation `Json.parse` produces
  **/
 pub mv struct JsonTree {
-	var nodes = Buffer<JsonNode>()
-	var count = 0
-
-	func alloc_node = (ref self, out int) {
-		var int idx = self.count
-		self.nodes.grow(idx + 1)
-		self.count = idx + 1
-		var default = JsonNode()
-		self.nodes.store(idx, default)
-		// store_T deep-copies the mv `text` field (strdup of the shared
-		// empty-string literal) into the slot. JsonTree manages node texts
-		// manually (set_text strdup's into the slab; free_text/release frees
-		// them; NULL means "no text"), so the slot must start NULL — free the
-		// strdup'd default and NULL it, or reset() would leak it. The slab
-		// slot layout: 56-byte JsonNode elements — 7 words — with the text
-		// pair at words 2 and 3 of each element.
-		unsafe {
-			var ptr uint64 slots = self.nodes.data as ptr uint64
-			var int t = idx * 7 + 2
-			var uint64 old = slots[t]
-			if old != 0 {
-				free(old)
-			}
-			slots[t] = 0
-			slots[t + 1] = 0
-		}
-		return idx
-	}
+	var nodes = StableList<JsonNode>()
 
-	// Free a node's strdup'd text pointer (set_text writes a heap pointer via
-	// raw strdup; this mirrors it). idx is x1, following set_text's layout.
-	func free_text = (ref self, int idx) {
-		unsafe {
-			var ptr uint64 slots = self.nodes.data as ptr uint64
-			var int t = idx * 7 + 2
-			var uint64 p = slots[t]
-			if p != 0 {
-				free(p)
-				slots[t] = 0
-				slots[t + 1] = 0
-			}
-		}
+	// Append a fresh node and return its index.
+	func alloc_node = (ref self { nodes }, out int) {
+		self.nodes.push(JsonNode())
+		return self.nodes.length - 1
 	}
 
-	// Free every strdup'd text pointer before reusing the slab, otherwise
-	// re-parsing a document leaks the previous document's string/number texts.
-	func reset = (ref self) {
-		var i = 0
-		while i < self.count; i += 1 {
-			self.free_text(i)
-		}
-		self.count = 0
+	// Drop the current document: the fresh StableList displaces the old one,
+	// whose destroy frees every node (texts included) and its slabs. The
+	// next parse starts from a clean pool.
+	func reset = (ref self { nodes }) {
+		self.nodes = StableList<JsonNode>()
 	}
 
-	// Runs when the tree instance is destroyed (before its `nodes` buffer field
-	// is freed): release the current document's strdup'd node texts, which live
-	// raw in the slab and are otherwise invisible to the auto-destroy pass.
-	func #destroy = () {
-		var i = 0
-		while i < self.count; i += 1 {
-			self.free_text(i)
+	// Install node `idx`'s text, TAKING ownership of the argument (the D3
+	// mv convention): `set_text(n, mv s)` transfers the caller's buffer
+	// into the pool with no copy anywhere — the field store moves the pair
+	// raw and the caller's variable is invalidated. (Pass `.copy()` for the
+	// keep-the-original spelling: `set_text(n, s.copy())`.) The pool owns
+	// its node texts end to end, so the transferred buffer is freed exactly
+	// once, by the list's destroy or the next text store. For strings
+	// produced by a StringBuilder, `take_text` installs the builder's
+	// buffer with no copy at all.
+	func set_text = (ref self {}, int idx, mv string text) {
+		if idx < 0 || idx >= self.nodes.length {
+			panic("index out of range")
 		}
-		self.count = 0
+		ref JsonNode n = self.nodes.at(idx)
+		n.text = mv text
 	}
 
-	// strdup directly into the slab — see file header for why this can't
-	// go through load_T/store_T. (Under the fat-string ABI the C body is
-	// emitted behind the _raw_ adapter, so `text` arrives as a thin char*;
-	// aarch64 receives the pair x2 = ptr, x3 = len.)
-	func set_text = (ref self, int idx, string text) {
-		unsafe {
-			var int len = text.length
-			var uint64 buf = malloc(len + 1)
-			memcpy(buf, (text as ptr char) as uint64, len)
-			memset(buf + len, 0, 1)
-			var ptr uint64 slots = self.nodes.data as ptr uint64
-			var int t = idx * 7 + 2
-			slots[t] = buf
-			slots[t + 1] = len
+	// Install node `idx`'s text by TAKING the builder's buffer — the parse
+	// path's zero-copy store. `to_string` is a take (the builder hands its
+	// heap buffer over and resets), and a fresh-call RHS stores into the
+	// field directly, so per parsed string/key the only allocation in the
+	// whole node lifecycle is the builder's own buffer — the node's null
+	// seed costs nothing and there is no copy malloc, no seed free, no
+	// temp free. (A `mv string` parameter cannot do this: the string-arg
+	// ownership convention makes mv string arguments caller-owned
+	// borrows, forcing the callee-side copy this method exists to skip.)
+	func take_text = (ref self {}, int idx, ref StringBuilder sb {}) {
+		if idx < 0 || idx >= self.nodes.length {
+			panic("index out of range")
 		}
+		ref JsonNode n = self.nodes.at(idx)
+		n.text = sb.to_string()
 	}
 
-	func set_kind = (ref self, int idx, int val) {
-		var JsonNode n = self.nodes.load(idx)
+	func set_kind = (ref self {}, int idx, int val) {
+		if idx < 0 || idx >= self.nodes.length {
+			panic("index out of range")
+		}
+		ref JsonNode n = self.nodes.at(idx)
 		n.kind = val
-		self.nodes.store(idx, n)
 	}
 
-	func set_child = (ref self, int idx, int val) {
-		var JsonNode n = self.nodes.load(idx)
+	func set_child = (ref self {}, int idx, int val) {
+		if idx < 0 || idx >= self.nodes.length {
+			panic("index out of range")
+		}
+		ref JsonNode n = self.nodes.at(idx)
 		n.child = val
-		self.nodes.store(idx, n)
 	}
 
-	func set_next = (ref self, int idx, int val) {
-		var JsonNode n = self.nodes.load(idx)
+	func set_next = (ref self {}, int idx, int val) {
+		if idx < 0 || idx >= self.nodes.length {
+			panic("index out of range")
+		}
+		ref JsonNode n = self.nodes.at(idx)
 		n.next = val
-		self.nodes.store(idx, n)
 	}
 
-	func set_val = (ref self, int idx, int val) {
-		var JsonNode n = self.nodes.load(idx)
+	func set_val = (ref self {}, int idx, int val) {
+		if idx < 0 || idx >= self.nodes.length {
+			panic("index out of range")
+		}
+		ref JsonNode n = self.nodes.at(idx)
 		n.val = val
-		self.nodes.store(idx, n)
 	}
 
 	func get_kind = (self, int idx, out int) {
-		var JsonNode n = self.nodes.load(idx)
+		if idx < 0 || idx >= self.nodes.length {
+			panic("index out of range")
+		}
+		ref JsonNode n = self.nodes.at(idx)
 		return n.kind
 	}
 
 	func get_text = (self, int idx, out string) {
-		var JsonNode n = self.nodes.load(idx)
+		if idx < 0 || idx >= self.nodes.length {
+			panic("index out of range")
+		}
+		ref JsonNode n = self.nodes.at(idx)
+		// The aarch64 `??` yields the left pair AS-IS (no dup), so the
+		// coalesce spelling would return a borrow of the node's text — the
+		// caller's free would take the pool's buffer. Spell the owned copy:
+		// a null text answers a fresh "" and a non-null one takes
+		// `.copy()` (the return contract — the caller owns the result —
+		// is the `.copy()` shape the method always had).
+		if n.text == null {
+			return ""
+		}
 		return n.text.copy()
 	}
 
+	// A non-mv (ptr, len) view over node `idx`'s text — the zero-copy read.
+	// The borrow roots at `self` and re-roots at the call-site receiver
+	// (the `slice` convention), so it is invalidated by `reset()`/re-parse
+	// like any pool borrow. Callers that immediately append, hash, or
+	// inspect the text take this instead of paying `get_text`'s per-read
+	// copy allocation. A node that never had text installed views the
+	// empty string (a rodata-rooted empty borrow).
+	func get_text_view = (self, int idx, out view string) {
+		if idx < 0 || idx >= self.nodes.length {
+			panic("index out of range")
+		}
+		ref JsonNode n = self.nodes.at(idx)
+		if n.text == null {
+			return "".slice(0, 0)
+		}
+		return n.text.slice(0, n.text.length)
+	}
+
 	func get_child = (self, int idx, out int) {
-		var JsonNode n = self.nodes.load(idx)
+		if idx < 0 || idx >= self.nodes.length {
+			panic("index out of range")
+		}
+		ref JsonNode n = self.nodes.at(idx)
 		return n.child
 	}
 
 	func get_next = (self, int idx, out int) {
-		var JsonNode n = self.nodes.load(idx)
+		if idx < 0 || idx >= self.nodes.length {
+			panic("index out of range")
+		}
+		ref JsonNode n = self.nodes.at(idx)
 		return n.next
 	}
 
 	func get_val = (self, int idx, out int) {
-		var JsonNode n = self.nodes.load(idx)
+		if idx < 0 || idx >= self.nodes.length {
+			panic("index out of range")
+		}
+		ref JsonNode n = self.nodes.at(idx)
 		return n.val
 	}
 }

package/core/System/Text/Regex.nm

@@ -33,10 +33,9 @@ pub struct Regex {
 	}
 
 	// Return the first substring of input matching pattern, or "" if none.
-	// `mv out string`: the built match (or the copied empty literal) is
-	// handed to the caller as an owned value.
+	// `mv out string`: the matched span (or the empty literal) is handed to
+	// the caller as an owned value.
 	pub func match = (string pattern, string input, mv out string) {
-		var match_result = ""
 		var int pat_len = pattern.length
 		var int len = input.length
 		var string charset = first_byte_set(pattern, pat_len)
@@ -52,14 +51,14 @@ pub struct Regex {
 			var caps = List<int>()
 			var int end = match_here(pattern, 0, pat_len, input, i, len, ref caps)
 			if end >= 0 {
-				var int j = i
-				while j < end; j += 1 {
-					match_result = match_result + "\{input.at(j)}"
-				}
-				break
+				// One owned substring copy. The old accumulator
+				// (`match_result = match_result + "\{input.at(j)}"` per
+				// matched byte) paid an interpolation malloc PLUS a
+				// whole-accumulator re-copy per byte — O(n²) in the span.
+				return input.substring(i, end)
 			}
 		}
-		return match_result
+		return ""
 	}
 
 	// Try to match pattern anywhere in input. On a match, append the whole
@@ -70,7 +69,7 @@ pub struct Regex {
 	pub func captures = (
 		string pattern,
 		string input,
-		ref List<string> dst,
+		ref List<string> dst { items },
 		out bool
 	) { var int pat_len = pattern.length
 		var int len = input.length
@@ -118,7 +117,7 @@ pub struct Regex {
 	// first, so a reused RegexMatch carries nothing over. Scans every
 	// position: the first-byte prefilter would skip nullable patterns'
 	// empty matches at skipped positions, reporting a wrong .start.
-	pub func find = (string pattern, string input, ref RegexMatch dst) {
+	pub func find = (string pattern, string input, ref RegexMatch dst { text }) {
 		dst.found = false
 		dst.start = 0
 		dst.end = 0
@@ -173,25 +172,27 @@ pub struct Regex {
 	}
 
 	// Replace all non-overlapping occurrences of pattern in input with replacement.
+	// Literal bytes between matches are copied in bulk runs (one
+	// `append_string_view` per run) — the old loop appended per byte.
 	pub func replace_all = (
 		string pattern,
 		string input,
 		string replacement,
 		out string
-	) { var sb = StringBuilder()
+	) {
+		var sb = StringBuilder()
 		var int pat_len = pattern.length
 		var int len = input.length
 		var string charset = first_byte_set(pattern, pat_len)
 		var int clen = charset.length
 		var pos = 0
+		var run_start = 0
 		while pos < len {
 			if clen > 0 {
-				var int next = find_next_byte(input, pos, len, charset)
-				// Copy the bytes we're skipping over.
-				while pos < next {
-					sb.append_char(input.at(pos))
-					pos += 1
-				}
+				// Prefilter: jump to the next candidate byte. The skipped
+				// run stays pending — it is copied in bulk at the next
+				// match, or by the tail copy below.
+				pos = find_next_byte(input, pos, len, charset)
 				if pos >= len {
 					break
 				}
@@ -199,18 +200,22 @@ pub struct Regex {
 			var caps = List<int>()
 			var int end = match_here(pattern, 0, pat_len, input, pos, len, ref caps)
 			if end >= 0 {
+				sb.append_string_view(input.slice(run_start, pos))
 				sb.append_string(replacement)
 				if end == pos {
-					sb.append_char(input.at(pos))
+					// Empty match: the byte at pos is not consumed — it
+					// starts the next literal run.
+					run_start = pos
 					pos += 1
 				} else {
 					pos = end
+					run_start = pos
 				}
 			} else {
-				sb.append_char(input.at(pos))
 				pos += 1
 			}
 		}
+		sb.append_string_view(input.slice(run_start, len))
 		return sb.to_string()
 	}
 
@@ -227,13 +232,13 @@ pub struct Regex {
 	}
 
 	// find, ignoring ASCII case.
-	pub func find_ci = (string pattern, string input, ref RegexMatch dst) {
+	pub func find_ci = (string pattern, string input, ref RegexMatch dst { text }) {
 		var string folded = fold_pattern(pattern)
 		Regex.find(folded, input, ref dst)
 	}
 
 	// captures, ignoring ASCII case.
-	pub func captures_ci = (string pattern, string input, ref List<string> dst, out bool) {
+	pub func captures_ci = (string pattern, string input, ref List<string> dst { items }, out bool) {
 		var string folded = fold_pattern(pattern)
 		return Regex.captures(folded, input, ref dst)
 	}
@@ -303,7 +308,7 @@ func fold_pattern = (string pattern, mv out string) {
 
 // fold a character class [cs..ce): copy its contents, adding the case
 // counterpart of every letter member and mirroring letter ranges.
-func fold_class = (string pattern, int cs, int ce, ref StringBuilder dst) {
+func fold_class = (string pattern, int cs, int ce, ref StringBuilder dst {}) {
 	dst.append_char('[')
 	var int i = cs + 1
 	if i < ce - 1 {
@@ -430,7 +435,7 @@ func collect_first_bytes = (
 	string pattern,
 	int pat_pos,
 	int pat_end,
-	ref StringBuilder sb,
+	ref StringBuilder sb {},
 	out int
 ) {
 	var depth = 0
@@ -477,7 +482,7 @@ func collect_first_bytes = (
 // atom — literal, escaped, class, or group — quantified with '?'/'*' is
 // nullable: what FOLLOWS it can also be first, so the scan continues past it.
 // A wildcard '.' or an empty alternative makes the set indeterminable.
-func alt_first_bytes = (string pattern, int start, int end, ref StringBuilder sb, out int) {
+func alt_first_bytes = (string pattern, int start, int end, ref StringBuilder sb {}, out int) {
 	var int i = start
 	while i < end {
 		var char c = pattern.at(i)
@@ -717,7 +722,7 @@ func add_class_chars = (
 	string pattern,
 	int start,
 	int end,
-	ref StringBuilder sb
+	ref StringBuilder sb {}
 ) { var int cs = start
 	if cs < end {
 		if pattern.at(cs) == '^' {
@@ -772,7 +777,7 @@ func match_here = (
 	string input,
 	int in_pos,
 	int in_len,
-	ref List<int> caps,
+	ref List<int> caps { items },
 	out int: out <= in_len
 ) {
 	// Handle top-level alternation: a '|' at bracket/paren depth 0 splits the
@@ -1031,7 +1036,7 @@ func match_group_then_rest = (
 	string input,
 	int in_pos,
 	int in_len,
-	ref List<int> caps,
+	ref List<int> caps { items },
 	out int
 ) {
 	var int g = group_index_at(pattern, atom_start)
@@ -1122,7 +1127,7 @@ func match_single_atom = (
 	string input,
 	int in_pos,
 	int in_len,
-	ref List<int> caps,
+	ref List<int> caps { items },
 	out int
 ) {
 	var char pc = pattern.at(atom_start)
@@ -1304,7 +1309,7 @@ func match_counted = (
 	int lazy,
 	int count,
 	int in_len,
-	ref List<int> caps,
+	ref List<int> caps { items },
 	out int
 ) {
 	var can_stop = count >= min_count
@@ -1402,7 +1407,7 @@ func match_star = (
 	int min_count,
 	int lazy,
 	int in_len,
-	ref List<int> caps,
+	ref List<int> caps { items },
 	out int
 ) {
 	var char pc = pattern.at(atom_start)
@@ -1485,7 +1490,7 @@ func match_star_group = (
 	int min_count,
 	int lazy,
 	int in_len,
-	ref List<int> caps,
+	ref List<int> caps { items },
 	out int
 ) {
 	if lazy > 0 {
@@ -1554,7 +1559,7 @@ func match_group_iteration = (
 	int min_count,
 	int lazy,
 	int in_len,
-	ref List<int> caps,
+	ref List<int> caps { items },
 	out int
 ) {
 	var int g = group_index_at(pattern, atom_start)
@@ -1621,7 +1626,7 @@ func match_optional = (
 	int in_pos,
 	int lazy,
 	int in_len,
-	ref List<int> caps,
+	ref List<int> caps { items },
 	out int
 ) {
 	if lazy > 0 {
@@ -1894,7 +1899,7 @@ func group_index_at = (string pattern, int open_pos, out int) {
 // group_pos. A later span for the same group supersedes the earlier one, so
 // a repeated group reports its last iteration; a failed group records
 // (-1, -1) so stale spans from an abandoned attempt never surface.
-func record_capture = (ref List<int> caps, int group, int start, int end) {
+func record_capture = (ref List<int> caps { items }, int group, int start, int end) {
 	if group <= 0 {
 		return
 	}
@@ -1953,7 +1958,7 @@ func match_backref = (
 	int group,
 	int in_pos,
 	int in_len,
-	ref List<int> caps,
+	ref List<int> caps {},
 	out int
 ) {
 	var int at = last_capture_index(caps, group)
@@ -1989,7 +1994,7 @@ func match_star_backref = (
 	int min_count,
 	int lazy,
 	int in_len,
-	ref List<int> caps,
+	ref List<int> caps { items },
 	out int
 ) {
 	var int group = backref_group(pattern.at(atom_start + 1))
@@ -2111,7 +2116,7 @@ func matches_shorthand = (char c, char b, out bool) {
 // first-byte charset. Complement shorthands (S/D/W) match "anything else" —
 // not expressible as an inclusion set — so they return -1, which disables
 // the caller's prefilter.
-func shorthand_members = (char c, ref StringBuilder sb, out int) {
+func shorthand_members = (char c, ref StringBuilder sb {}, out int) {
 	var int kind = c as int
 	if kind == 83 || kind == 68 || kind == 87 {
 		return -1

package/core/System/Text/Utf8.nm

@@ -126,11 +126,11 @@ pub struct Utf8 {
 				sb.append_char(((0x80 | (code & 0x3F)) as char))
 			}
 		} else {
-				sb.append_char(((0xF0 | (code >> 18)) as char))
-				sb.append_char(((0x80 | ((code >> 12) & 0x3F)) as char))
-				sb.append_char(((0x80 | ((code >> 6) & 0x3F)) as char))
-				sb.append_char(((0x80 | (code & 0x3F)) as char))
-			}
+			sb.append_char(((0xF0 | (code >> 18)) as char))
+			sb.append_char(((0x80 | ((code >> 12) & 0x3F)) as char))
+			sb.append_char(((0x80 | ((code >> 6) & 0x3F)) as char))
+			sb.append_char(((0x80 | (code & 0x3F)) as char))
+		}
 		return sb.to_string()
 	}
 

package/core/System/Thread.nm

@@ -82,9 +82,13 @@ pub mv struct Thread<T> : Spawnable<T> {
 	// fields, so #destroy becomes a no-op afterwards. The future's refs
 	// account for the trampoline, the returned handle, and the nursery (when
 	// captured).
-	pub func start = (ref self, mv out Task<T>) {
+	pub func start = (ref self {}, mv out Task<T>) {
 		```
 		#arch: c
+		// Single-launch contract: a consumed construction (started) owns
+		// nothing — the handles below are zeroed, and writing the ref count
+		// through the null future would fault. Abort with the reason.
+		if (self->started) __nomen_spawn_double_start_abort();
 		struct nomen_future *_f = (struct nomen_future *)self->future;
 		_f->refs = self->nursery_futures ? 3 : 2;
 		__nomen_pool_submit((struct nomen_closure *)self->task);
@@ -94,7 +98,12 @@ pub mv struct Thread<T> : Spawnable<T> {
 		```
 		```
 		#arch: aarch64
-		// x19 = self. f = self->future (#32); nursery_futures at #48.
+		// x19 = self. started at #40; f = self->future (#32); nursery_futures
+		// at #48. Single-launch contract first: a consumed construction has
+		// zeroed handles, and the ref-store below would write through null.
+		ldrb w9, [x19, #40]
+		cbnz w9, .Lnomen_start_double
+		// f = self->future (#32); nursery_futures at #48.
 		ldr x0, [x19, #32]
 		ldr x1, [x19, #48]
 		mov w2, #2
@@ -113,6 +122,10 @@ pub mv struct Thread<T> : Spawnable<T> {
 		ldr x3, [x19, #32]
 		bl ___nomen_nursery_track
 		.Lnomen_start_notrack:
+		b .Lnomen_start_done
+		.Lnomen_start_double:
+		bl ___nomen_spawn_double_start_abort
+		.Lnomen_start_done:
 		```
 		// The handle is a fresh heap Task built through the internal #init;
 		// the caller owns it (a discarded statement form is reclaimed at
@@ -136,9 +149,12 @@ pub mv struct Thread<T> : Spawnable<T> {
 	// mid-execution BY DESIGN. The unused future (a Thread always carries
 	// the full machinery) is released — first detaching the closure from it,
 	// so the daemon runner owns the closure now.
-	pub func detach = (ref self) {
+	pub func detach = (ref self {}) {
 		```
 		#arch: c
+		// Single-launch contract (see .start): a consumed construction has
+		// zeroed handles, and detaching the null closure would crash a worker.
+		if (self->started) __nomen_spawn_double_start_abort();
 		struct nomen_future *_uf = (struct nomen_future *)self->future;
 		if (_uf) {
 			_uf->owner_args = NULL;
@@ -148,6 +164,9 @@ pub mv struct Thread<T> : Spawnable<T> {
 		```
 		```
 		#arch: aarch64
+		// Single-launch contract first (see .start): started at #40.
+		ldrb w9, [x19, #40]
+		cbnz w9, .Lnomen_detach_double
 		// if (self->future) { owner_args = NULL; release it }
 		ldr x0, [x19, #32]
 		cbz x0, .Lnomen_detach_nofut
@@ -157,6 +176,10 @@ pub mv struct Thread<T> : Spawnable<T> {
 		// __nomen_task_detach(self->task)
 		ldr x0, [x19, #8]
 		bl ___nomen_task_detach
+		b .Lnomen_detach_done
+		.Lnomen_detach_double:
+		bl ___nomen_spawn_double_start_abort
+		.Lnomen_detach_done:
 		```
 		self.task = 0
 		self.future = 0