nomen-lang 0.7.1 → 0.8.0

package/core/System/Controls/Container.nm

@@ -94,32 +94,47 @@ func length_val = (LayoutLength len, out int) {
 // methods below reference them (free functions aren't forward-inferred).
 
 func is_visible = (uint64 handle, out bool) {
-	if handle == 0 { return true }
+	// The handle-0 guard lives INSIDE every arch block: a Nomen statement
+	// around `aarch64_use_c` blocks is rejected (the aarch64 backend replaces
+	// the whole body with the raw blocks and would silently drop it).
 	```
 	#arch: c
 	#platform: macos
+	if (handle == 0) return true;
 	BOOL hidden = ((BOOL(*)(id, SEL))objc_msgSend)((id)handle, sel_registerName("isHidden"));
 	return !hidden;
 	```
 	```
 	#arch: aarch64_use_c
 	#platform: macos
+	if (handle == 0) return true;
 	BOOL hidden = ((BOOL(*)(id, SEL))objc_msgSend)((id)handle, sel_registerName("isHidden"));
 	return !hidden;
 	```
 	```
 	#arch: c
 	#platform: ios
+	if (handle == 0) return true;
 	return true;
 	```
 	```
 	#arch: aarch64_use_c
 	#platform: ios
+	if (handle == 0) return true;
 	return true;
 	```
 }
 
-func apply_frame = (uint64 handle, int x, int y, int w, int h, int content_w, int content_h) {
+func apply_frame = (
+	uint64 handle,
+	int x,
+	int y,
+	int w,
+	int h,
+	int content_w,
+	int content_h,
+	int flex
+) {
 	```
 	#arch: c
 	#platform: macos
@@ -129,12 +144,18 @@ func apply_frame = (uint64 handle, int x, int y, int w, int h, int content_w, in
 	// vertical edge (top=NSViewMinYMargin 8 / bottom=NSViewMaxYMargin 32) to
 	// respect the top-left-origin layout instead of AppKit's default
 	// bottom-left pin, and let wide controls grow with the content width
-	// (NSViewWidthSizable 2). Never set NSViewHeightSizable (16): control
-	// heights come from the layout pass, not the window. AppKit's result
+	// (NSViewWidthSizable 2). A GROW-driven leaf is the exception: it is the
+	// layout's flexible region, so it gets the matching sizable bit (see the
+	// `flex` argument) and resizes live with the window; every other control's
+	// height comes from the layout pass, not the window. AppKit's result
 	// matches what layout() computes, so the post-drag relayout only fixes up
 	// cells AppKit can't (column reflow for sub-full-width children).
 	unsigned long mask = (y * 2 < content_h) ? 8UL : 32UL;
 	if (w * 10 >= content_w * 8) mask |= 2UL;
+	// flex: 1 = width-flexible (HStack grow), 2 = height-flexible (VStack
+	// grow) — the region AppKit resizes live during a window drag.
+	if (flex == 1) mask |= 2UL;
+	if (flex == 2) mask |= 16UL;
 	((void(*)(id, SEL, unsigned long))objc_msgSend)((id)handle, sel_registerName("setAutoresizingMask:"), mask);
 	((void(*)(id, SEL, CGRect))objc_msgSend)(
 		(id)handle, sel_registerName("setFrame:"),
@@ -150,12 +171,18 @@ func apply_frame = (uint64 handle, int x, int y, int w, int h, int content_w, in
 	// vertical edge (top=NSViewMinYMargin 8 / bottom=NSViewMaxYMargin 32) to
 	// respect the top-left-origin layout instead of AppKit's default
 	// bottom-left pin, and let wide controls grow with the content width
-	// (NSViewWidthSizable 2). Never set NSViewHeightSizable (16): control
-	// heights come from the layout pass, not the window. AppKit's result
+	// (NSViewWidthSizable 2). A GROW-driven leaf is the exception: it is the
+	// layout's flexible region, so it gets the matching sizable bit (see the
+	// `flex` argument) and resizes live with the window; every other control's
+	// height comes from the layout pass, not the window. AppKit's result
 	// matches what layout() computes, so the post-drag relayout only fixes up
 	// cells AppKit can't (column reflow for sub-full-width children).
 	unsigned long mask = (y * 2 < content_h) ? 8UL : 32UL;
 	if (w * 10 >= content_w * 8) mask |= 2UL;
+	// flex: 1 = width-flexible (HStack grow), 2 = height-flexible (VStack
+	// grow) — the region AppKit resizes live during a window drag.
+	if (flex == 1) mask |= 2UL;
+	if (flex == 2) mask |= 16UL;
 	((void(*)(id, SEL, unsigned long))objc_msgSend)((id)handle, sel_registerName("setAutoresizingMask:"), mask);
 	((void(*)(id, SEL, CGRect))objc_msgSend)(
 		(id)handle, sel_registerName("setFrame:"),
@@ -191,10 +218,18 @@ func apply_frame = (uint64 handle, int x, int y, int w, int h, int content_w, in
 // conformance (`Button`/`CheckBox`/`TextBox`), so each leaf's `intrinsic_size`
 // doesn't need its own raw-block FFI.
 pub func native_intrinsic = (uint64 handle, out [int, int]) {
-	if handle == 0 { return [0, 0] }
+	// The handle-0 guard lives INSIDE every arch block: a Nomen statement
+	// around `aarch64_use_c` blocks is rejected (the aarch64 backend replaces
+	// the whole body with the raw blocks and would silently drop it).
 	```
 	#arch: c
 	#platform: macos
+	if (handle == 0) {
+		struct _Tuple_int_int r;
+		r._0 = 0;
+		r._1 = 0;
+		return r;
+	}
 	CGSize sz = ((CGSize(*)(id, SEL))objc_msgSend)((id)handle, sel_registerName("intrinsicContentSize"));
 	int w = (sz.width < 0 || sz.width > 100000) ? 0 : (int)sz.width;
 	int h = (sz.height < 0 || sz.height > 100000) ? 0 : (int)sz.height;
@@ -206,6 +241,12 @@ pub func native_intrinsic = (uint64 handle, out [int, int]) {
 	```
 	#arch: aarch64_use_c
 	#platform: macos
+	if (handle == 0) {
+		struct _Tuple_int_int r;
+		r._0 = 0;
+		r._1 = 0;
+		return r;
+	}
 	CGSize sz = ((CGSize(*)(id, SEL))objc_msgSend)((id)handle, sel_registerName("intrinsicContentSize"));
 	int w = (sz.width < 0 || sz.width > 100000) ? 0 : (int)sz.width;
 	int h = (sz.height < 0 || sz.height > 100000) ? 0 : (int)sz.height;
@@ -217,6 +258,12 @@ pub func native_intrinsic = (uint64 handle, out [int, int]) {
 	```
 	#arch: c
 	#platform: ios
+	if (handle == 0) {
+		struct _Tuple_int_int r;
+		r._0 = 0;
+		r._1 = 0;
+		return r;
+	}
 	CGSize sz = ((CGSize(*)(id, SEL))objc_msgSend)((id)handle, sel_registerName("intrinsicContentSize"));
 	int w = (sz.width < 0 || sz.width > 100000) ? 0 : (int)sz.width;
 	int h = (sz.height < 0 || sz.height > 100000) ? 0 : (int)sz.height;
@@ -228,6 +275,12 @@ pub func native_intrinsic = (uint64 handle, out [int, int]) {
 	```
 	#arch: aarch64_use_c
 	#platform: ios
+	if (handle == 0) {
+		struct _Tuple_int_int r;
+		r._0 = 0;
+		r._1 = 0;
+		return r;
+	}
 	CGSize sz = ((CGSize(*)(id, SEL))objc_msgSend)((id)handle, sel_registerName("intrinsicContentSize"));
 	int w = (sz.width < 0 || sz.width > 100000) ? 0 : (int)sz.width;
 	int h = (sz.height < 0 || sz.height > 100000) ? 0 : (int)sz.height;
@@ -238,6 +291,60 @@ pub func native_intrinsic = (uint64 handle, out [int, int]) {
 	```
 }
 
+// The NATIVE frame of a control handle as "x,y,w,h" (AppKit's answer, not the
+// layout engine's intent — compare against `Container.fmt_frame` to verify the
+// two agree). Returns "0,0,0,0" for handle 0.
+pub func native_frame = (uint64 handle, out string) {
+	// The handle-0 guard lives INSIDE every arch block: a Nomen statement
+	// around `aarch64_use_c` blocks is rejected (the aarch64 backend replaces
+	// the whole body with the raw blocks and would silently drop it). The
+	// string RETURN builds the fat pair itself — the literal's length is 7.
+	```
+	#arch: c
+	#platform: macos
+	if (handle == 0) return (nomen_string){ (char*)"0,0,0,0", 7 };
+	CGRect r = ((CGRect(*)(id, SEL))objc_msgSend)((id)handle, sel_registerName("frame"));
+	char buf[96];
+	snprintf(buf, sizeof(buf), "%ld,%ld,%ld,%ld",
+		(long)r.origin.x, (long)r.origin.y, (long)r.size.width, (long)r.size.height);
+	char *dup = strdup(buf);
+	return (nomen_string){ dup, (long)strlen(dup) };
+	```
+	```
+	#arch: aarch64_use_c
+	#platform: macos
+	if (handle == 0) return (nomen_string){ (char*)"0,0,0,0", 7 };
+	CGRect r = ((CGRect(*)(id, SEL))objc_msgSend)((id)handle, sel_registerName("frame"));
+	char buf[96];
+	snprintf(buf, sizeof(buf), "%ld,%ld,%ld,%ld",
+		(long)r.origin.x, (long)r.origin.y, (long)r.size.width, (long)r.size.height);
+	char *dup = strdup(buf);
+	return (nomen_string){ dup, (long)strlen(dup) };
+	```
+	```
+	#arch: c
+	#platform: ios
+	if (handle == 0) return (nomen_string){ (char*)"0,0,0,0", 7 };
+	CGRect r = ((CGRect(*)(id, SEL))objc_msgSend)((id)handle, sel_registerName("frame"));
+	char buf[96];
+	snprintf(buf, sizeof(buf), "%ld,%ld,%ld,%ld",
+		(long)r.origin.x, (long)r.origin.y, (long)r.size.width, (long)r.size.height);
+	char *dup = strdup(buf);
+	return (nomen_string){ dup, (long)strlen(dup) };
+	```
+	```
+	#arch: aarch64_use_c
+	#platform: ios
+	if (handle == 0) return (nomen_string){ (char*)"0,0,0,0", 7 };
+	CGRect r = ((CGRect(*)(id, SEL))objc_msgSend)((id)handle, sel_registerName("frame"));
+	char buf[96];
+	snprintf(buf, sizeof(buf), "%ld,%ld,%ld,%ld",
+		(long)r.origin.x, (long)r.origin.y, (long)r.size.width, (long)r.size.height);
+	char *dup = strdup(buf);
+	return (nomen_string){ dup, (long)strlen(dup) };
+	```
+}
+
 /**
  * A flexbox-style container that measures and arranges its child controls.
  *
@@ -251,7 +358,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 mv struct Container : Control {
+pub mv struct 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
@@ -292,6 +399,13 @@ pub mv struct Container : Control {
 	var pry = Buffer<int>()
 	var prw = Buffer<int>()
 	var prh = Buffer<int>()
+	// The constraints each node's cached size was measured under (the
+	// measure_node cache gate). A clean node re-uses its cached size only
+	// when the constraints are unchanged — otherwise a standalone
+	// `measure(bc)` after an external resize answered with the PREVIOUS
+	// constraint's width (the page-scroll shrink-per-resize bug).
+	var mw = Buffer<int>()
+	var mh = Buffer<int>()
 	// Dirty-rect list: the node indices (leaves) whose frame changed in the
 	// most recent `compute`/`layout`, in the order discovered. `dirty_count`
 	// / `dirty_rect` expose it; `apply` repaints only these.
@@ -331,6 +445,8 @@ pub mv struct Container : Control {
 		self.pry.grow_int(cap)
 		self.prw.grow_int(cap)
 		self.prh.grow_int(cap)
+		self.mw.grow_int(cap)
+		self.mh.grow_int(cap)
 		self.dirty_idx.grow_int(cap)
 	}
 
@@ -355,6 +471,8 @@ pub mv struct Container : Control {
 		self.pry.store_int(0, -1)
 		self.prw.store_int(0, -1)
 		self.prh.store_int(0, -1)
+		self.mw.store_int(0, -1)
+		self.mh.store_int(0, -1)
 		self.root = 0
 		self.count = 1
 	}
@@ -432,6 +550,8 @@ pub mv struct Container : Control {
 		self.pry.store_int(idx, -1)
 		self.prw.store_int(idx, -1)
 		self.prh.store_int(idx, -1)
+		self.mw.store_int(idx, -1)
+		self.mh.store_int(idx, -1)
 		self.count = self.count + 1
 		return idx
 	}
@@ -676,6 +796,84 @@ pub mv struct Container : Control {
 		self.set_leaf_kind(idx, LEN_INTRINSIC, 0, LEN_INTRINSIC, 0)
 	}
 
+	// Remove the leaf whose native handle matches, deleting its node from the
+	// tree: every per-node array is backward-shifted over the slot and parent
+	// indices above it are fixed up, so the node vanishes from measure,
+	// arrange, hit-test, and apply entirely. Call this BEFORE freeing the
+	// control itself (its #destroy, whenever the owner's scope ends) — a
+	// freed handle left in the tree would still be measured, hit-tested, and
+	// re-framed. The whole tree is marked dirty afterwards so the next
+	// layout reflows the rows the removed child leaves behind. Returns true
+	// if a matching leaf was found and removed.
+	pub func remove_leaf = (ref self, uint64 handle, out bool) {
+		var int needle = handle as int
+		var removed = false
+		var idx = 1
+		while idx < self.count; idx += 1 {
+			if self.kinds.load_int(idx) == KIND_LEAF {
+				if self.handles.load_int(idx) == needle {
+					removed = true
+					break
+				}
+			}
+		}
+		if !removed {
+			return false
+		}
+		// Backward-shift every per-node array over the removed slot. The
+		// cached frames (rx..prh) shift along with their nodes, so the tree
+		// stays internally consistent — only the structure changed. `idx`
+		// holds the removed slot here; remember it for the parent fix-up,
+		// then walk the shift destinations with it.
+		var int hole = idx
+		var int last = self.count - 1
+		while idx < last; idx += 1 {
+			self.kinds.store_int(idx, self.kinds.load_int(idx + 1))
+			self.w_kinds.store_int(idx, self.w_kinds.load_int(idx + 1))
+			self.w_vals.store_int(idx, self.w_vals.load_int(idx + 1))
+			self.h_kinds.store_int(idx, self.h_kinds.load_int(idx + 1))
+			self.h_vals.store_int(idx, self.h_vals.load_int(idx + 1))
+			self.gaps.store_int(idx, self.gaps.load_int(idx + 1))
+			self.pars.store_int(idx, self.pars.load_int(idx + 1))
+			self.spans.store_int(idx, self.spans.load_int(idx + 1))
+			self.cols.store_int(idx, self.cols.load_int(idx + 1))
+			self.handles.store_int(idx, self.handles.load_int(idx + 1))
+			self.pads.store_int(idx, self.pads.load_int(idx + 1))
+			self.grows.store_int(idx, self.grows.load_int(idx + 1))
+			self.shrinks.store_int(idx, self.shrinks.load_int(idx + 1))
+			self.aligns.store_int(idx, self.aligns.load_int(idx + 1))
+			self.dirty.store_int(idx, self.dirty.load_int(idx + 1))
+			self.measured_count.store_int(idx, self.measured_count.load_int(idx + 1))
+			self.rx.store_int(idx, self.rx.load_int(idx + 1))
+			self.ry.store_int(idx, self.ry.load_int(idx + 1))
+			self.rw.store_int(idx, self.rw.load_int(idx + 1))
+			self.rh.store_int(idx, self.rh.load_int(idx + 1))
+			self.prx.store_int(idx, self.prx.load_int(idx + 1))
+			self.pry.store_int(idx, self.pry.load_int(idx + 1))
+			self.prw.store_int(idx, self.prw.load_int(idx + 1))
+			self.prh.store_int(idx, self.prh.load_int(idx + 1))
+			self.mw.store_int(idx, self.mw.load_int(idx + 1))
+			self.mh.store_int(idx, self.mh.load_int(idx + 1))
+		}
+		self.count = last
+		// Fix parent indices that pointed above the removed slot. (A node
+		// parented AT the removed slot is impossible — leaves have no
+		// children.)
+		var k = 1
+		while k < self.count; k += 1 {
+			if self.pars.load_int(k) > hole + 1 {
+				self.pars.store_int(k, self.pars.load_int(k) - 1)
+			}
+		}
+		// The dirty-rect list holds node indices; the next layout's
+		// collect_dirty rebuilds it from scratch, so drop the stale entries.
+		self.dirty_n = 0
+		// The row structure changed: re-measure everything on the next
+		// compute/layout.
+		self.mark_dirty(self.root)
+		return true
+	}
+
 	// Translate the legacy int (w, h) into a (kind, value) pair: 0 → auto
 	// (no intrinsic; fills a bounded axis, stays 0 on an unbounded axis so
 	// `grow` decides), non-zero → fixed.
@@ -824,7 +1022,7 @@ pub mv struct Container : Control {
 		// reuse its cached size instead of re-measuring the subtree. The cached
 		// height is already in rh[idx] from the previous pass, so the caller's
 		// `self.rh.load_int(ci)` picks it up without a re-measure.
-		if self.dirty.load_int(idx) == 0 {
+		if self.dirty.load_int(idx) == 0 && self.mw.load_int(idx) == max_w && self.mh.load_int(idx) == max_h {
 			var int cached = self.rw.load_int(idx)
 			return cached
 		}
@@ -879,6 +1077,8 @@ pub mv struct Container : Control {
 			if h < min_h { h = min_h }
 			self.rw.store_int(idx, w)
 			self.rh.store_int(idx, h)
+			self.mw.store_int(idx, max_w)
+			self.mh.store_int(idx, max_h)
 			self.dirty.store_int(idx, 0)
 			return w
 		}
@@ -905,6 +1105,8 @@ pub mv struct Container : Control {
 			if max_child_w > max_w { max_child_w = max_w }
 			self.rw.store_int(idx, max_child_w)
 			self.rh.store_int(idx, total_h)
+			self.mw.store_int(idx, max_w)
+			self.mh.store_int(idx, max_h)
 			self.dirty.store_int(idx, 0)
 			return max_child_w
 		}
@@ -931,6 +1133,8 @@ pub mv struct Container : Control {
 			if max_child_h > max_h { max_child_h = max_h }
 			self.rw.store_int(idx, total_w)
 			self.rh.store_int(idx, max_child_h)
+			self.mw.store_int(idx, max_w)
+			self.mh.store_int(idx, max_h)
 			self.dirty.store_int(idx, 0)
 			return total_w
 		}
@@ -955,6 +1159,8 @@ pub mv struct Container : Control {
 			if best_h > max_h { best_h = max_h }
 			self.rw.store_int(idx, best_w)
 			self.rh.store_int(idx, best_h)
+			self.mw.store_int(idx, max_w)
+			self.mh.store_int(idx, max_h)
 			self.dirty.store_int(idx, 0)
 			return best_w
 		}
@@ -988,6 +1194,8 @@ pub mv struct Container : Control {
 			if total_h > max_h { total_h = max_h }
 			self.rw.store_int(idx, total_w)
 			self.rh.store_int(idx, total_h)
+			self.mw.store_int(idx, max_w)
+			self.mh.store_int(idx, max_h)
 			self.dirty.store_int(idx, 0)
 			return total_w
 		}
@@ -1027,6 +1235,8 @@ pub mv struct Container : Control {
 		if total_h > max_h { total_h = max_h }
 		self.rw.store_int(idx, cols * col_w)
 		self.rh.store_int(idx, total_h)
+		self.mw.store_int(idx, max_w)
+		self.mh.store_int(idx, max_h)
 		self.dirty.store_int(idx, 0)
 		return cols * col_w
 	}
@@ -1330,6 +1540,26 @@ pub mv struct Container : Control {
 			var int i = self.dirty_idx.load_int(k)
 			var uint64 handle = self.handles.load_int(i) as uint64
 			if handle != 0 {
+				// A grow-driven leaf IS the layout's flexible region: in a
+				// VStack it absorbs a vertical window resize, in an HStack a
+				// horizontal one. Expose that as the matching autoresizing
+				// mask so AppKit resizes it LIVE during the drag (the engine's
+				// relayout can't run mid-drag — heights otherwise only change
+				// when the delegate fires or the drag ends, leaving the
+				// flexible region sitting still under the pointer).
+				var flex = 0
+				if self.grows.load_int(i) > 0 {
+					var int parent = self.pars.load_int(i) - 1
+					if parent != -1 {
+						var int pkind = self.kinds.load_int(parent)
+						if pkind == KIND_VSTACK {
+							flex = 2
+						}
+						if pkind == KIND_HSTACK {
+							flex = 1
+						}
+					}
+				}
 				apply_frame(
 					handle,
 					self.rx.load_int(i),
@@ -1338,6 +1568,7 @@ pub mv struct Container : Control {
 					self.rh.load_int(i),
 					content_w,
 					content_h,
+					flex,
 				)
 			}
 		}
@@ -1469,6 +1700,20 @@ pub mv struct Container : Control {
 			g_resize_grid = grid;
 			g_resize_win = win;
 		}
+		// Close interception (Window.run consults the app's
+		// close_requested): the delegate REFUSES the native close and sets
+		// the pending flag; the Nomen loop consumes it next frame — the app
+		// declines (flag cleared, window stays) or accepts (close() forces
+		// past this via nomen_close_forced). External linkage: Window's
+		// close() and close_pending() extern both flags.
+		int nomen_close_pending = 0;
+		int nomen_close_forced = 0;
+		BOOL nomen_window_should_close_imp(id self, SEL cmd, id notification) {
+			(void)self; (void)cmd; (void)notification;
+			if (nomen_close_forced) return YES;
+			nomen_close_pending = 1;
+			return NO;
+		}
 		void nomen_window_did_resize(id self, SEL cmd, id notification) {
 			(void)self; (void)cmd; (void)notification;
 			if (g_resize_grid && g_resize_win) {
@@ -1497,6 +1742,20 @@ pub mv struct Container : Control {
 			g_resize_grid = grid;
 			g_resize_win = win;
 		}
+		// Close interception (Window.run consults the app's
+		// close_requested): the delegate REFUSES the native close and sets
+		// the pending flag; the Nomen loop consumes it next frame — the app
+		// declines (flag cleared, window stays) or accepts (close() forces
+		// past this via nomen_close_forced). External linkage: Window's
+		// close() and close_pending() extern both flags.
+		int nomen_close_pending = 0;
+		int nomen_close_forced = 0;
+		BOOL nomen_window_should_close_imp(id self, SEL cmd, id notification) {
+			(void)self; (void)cmd; (void)notification;
+			if (nomen_close_forced) return YES;
+			nomen_close_pending = 1;
+			return NO;
+		}
 		void nomen_window_did_resize(id self, SEL cmd, id notification) {
 			(void)self; (void)cmd; (void)notification;
 			if (g_resize_grid && g_resize_win) {
@@ -1513,6 +1772,9 @@ pub mv struct Container : Control {
 			Dc = objc_allocateClassPair(objc_getClass("NSObject"), "NomenResizeDelegate", 0);
 			if (Dc) {
 				class_addMethod(Dc, sel_registerName("windowDidResize:"), (IMP)nomen_window_did_resize, "v@:@");
+				// Close interception: refuse the native close, set the
+				// pending flag, let Window.run consult the app.
+				class_addMethod(Dc, sel_registerName("windowShouldClose:"), (IMP)nomen_window_should_close_imp, "c@:@");
 				objc_registerClassPair(Dc);
 			}
 		}
@@ -1531,6 +1793,57 @@ pub mv struct Container : Control {
 			Dc = objc_allocateClassPair(objc_getClass("NSObject"), "NomenResizeDelegate", 0);
 			if (Dc) {
 				class_addMethod(Dc, sel_registerName("windowDidResize:"), (IMP)nomen_window_did_resize, "v@:@");
+				// Close interception: refuse the native close, set the
+				// pending flag, let Window.run consult the app.
+				class_addMethod(Dc, sel_registerName("windowShouldClose:"), (IMP)nomen_window_should_close_imp, "c@:@");
+				objc_registerClassPair(Dc);
+			}
+		}
+		if (Dc) {
+			id delegate = ((id(*)(id, SEL))objc_msgSend)((id)Dc, sel_registerName("alloc"));
+			delegate = ((id(*)(id, SEL))objc_msgSend)(delegate, sel_registerName("init"));
+			((void(*)(id, SEL, id))objc_msgSend)((id)win->handle, sel_registerName("setDelegate:"), delegate);
+		}
+		```
+	}
+
+	// Install the windowDidResize: delegate WITHOUT setting the target pair
+	// (nomen_set_resize_target — call that first, e.g. from Window's
+	// set_content). Window.run arms the delegate so the ROOT layout re-runs
+	// live during AppKit's blocking resize drag; set_resize_callback is the
+	// combined form for manual-loop apps.
+	pub func arm_resize_delegate = (Window win) {
+		```
+		#arch: c
+		#platform: macos
+		Class Dc = objc_getClass("NomenResizeDelegate");
+		if (!Dc) {
+			Dc = objc_allocateClassPair(objc_getClass("NSObject"), "NomenResizeDelegate", 0);
+			if (Dc) {
+				class_addMethod(Dc, sel_registerName("windowDidResize:"), (IMP)nomen_window_did_resize, "v@:@");
+				// Close interception: refuse the native close, set the
+				// pending flag, let Window.run consult the app.
+				class_addMethod(Dc, sel_registerName("windowShouldClose:"), (IMP)nomen_window_should_close_imp, "c@:@");
+				objc_registerClassPair(Dc);
+			}
+		}
+		if (Dc) {
+			id delegate = ((id(*)(id, SEL))objc_msgSend)((id)Dc, sel_registerName("alloc"));
+			delegate = ((id(*)(id, SEL))objc_msgSend)(delegate, sel_registerName("init"));
+			((void(*)(id, SEL, id))objc_msgSend)((id)win->handle, sel_registerName("setDelegate:"), delegate);
+		}
+		```
+		```
+		#arch: aarch64_use_c
+		#platform: macos
+		Class Dc = objc_getClass("NomenResizeDelegate");
+		if (!Dc) {
+			Dc = objc_allocateClassPair(objc_getClass("NSObject"), "NomenResizeDelegate", 0);
+			if (Dc) {
+				class_addMethod(Dc, sel_registerName("windowDidResize:"), (IMP)nomen_window_did_resize, "v@:@");
+				// Close interception: refuse the native close, set the
+				// pending flag, let Window.run consult the app.
+				class_addMethod(Dc, sel_registerName("windowShouldClose:"), (IMP)nomen_window_should_close_imp, "c@:@");
 				objc_registerClassPair(Dc);
 			}
 		}
@@ -1542,6 +1855,428 @@ pub mv struct Container : Control {
 		```
 	}
 
+	// Register this grid as the document of a Scrollable, for Window.run's
+	// relayout: on every content-rect change the framework re-runs the
+	// document dance (measure unbounded → set_content_size → layout, plus a
+	// one-time scroll_to_top) for every registered pair. `sv`/`doc` are the
+	// scroll view's `handle`/`doc_handle()` — scalars, because a second
+	// `ref` borrow of the same owner (self.page_grid AND self.page) would
+	// trip the aliasing rule; see GUI.md ("The App run loop"). The grid (and
+	// the Scrollable) must outlive the run — app fields. Call once, from
+	// App.start.
+	// Call once, from App.start. The file-scope registry lives HERE (in the
+	// same file as this method and the thunk below): split builds emit only
+	// referenced structs' methods, and every TU that emits set_document /
+	// Window_relayout must also emit the registry + thunk they call —
+	// putting them in Scrollable.nm broke aarch64 split links (undefined
+	// symbols).
+	pub func set_document = (ref self, uint64 sv, uint64 doc) {
+		```
+		#arch: c
+		#platform: macos
+		#scope: file
+		// The registered (scroll view, document, content grid) triples —
+		// walked by nomen_scroll_relayout_all on every window resize. Raw
+		// addresses: the grid and the scroll live in the app struct, whose
+		// storage is stable for the whole run (the app is moved into
+		// Window.run once).
+		static unsigned long long nomen_scroll_reg_sv[8];
+		static unsigned long long nomen_scroll_reg_doc[8];
+		static void *nomen_scroll_reg_grid[8];
+		static int nomen_scroll_reg_n = 0;
+		void nomen_scroll_register(unsigned long long sv, unsigned long long doc, void *grid) {
+			if (nomen_scroll_reg_n >= 8) return;
+			nomen_scroll_reg_sv[nomen_scroll_reg_n] = sv;
+			nomen_scroll_reg_doc[nomen_scroll_reg_n] = doc;
+			nomen_scroll_reg_grid[nomen_scroll_reg_n] = grid;
+			nomen_scroll_reg_n++;
+		}
+		// The dance trampoline — a free function defined at the bottom of
+		// this file; prototyped so the walker can call it regardless of
+		// emission order (file-scope blocks hoist above function bodies).
+		extern void nomen_scroll_thunk(struct Container *, unsigned long long, unsigned long long, struct Window *, long);
+		void nomen_scroll_relayout_all(void *win, long first) {
+			for (int i = 0; i < nomen_scroll_reg_n; i++) {
+				nomen_scroll_thunk(
+					(struct Container *)nomen_scroll_reg_grid[i],
+					nomen_scroll_reg_sv[i], nomen_scroll_reg_doc[i],
+					(struct Window *)win, first);
+			}
+		}
+		```
+		```
+		#arch: aarch64_use_c
+		#platform: macos
+		#scope: file
+		static unsigned long long nomen_scroll_reg_sv[8];
+		static unsigned long long nomen_scroll_reg_doc[8];
+		static void *nomen_scroll_reg_grid[8];
+		static int nomen_scroll_reg_n = 0;
+		void nomen_scroll_register(unsigned long long sv, unsigned long long doc, void *grid) {
+			if (nomen_scroll_reg_n >= 8) return;
+			nomen_scroll_reg_sv[nomen_scroll_reg_n] = sv;
+			nomen_scroll_reg_doc[nomen_scroll_reg_n] = doc;
+			nomen_scroll_reg_grid[nomen_scroll_reg_n] = grid;
+			nomen_scroll_reg_n++;
+		}
+		// The companion-emitted thunk (a free function, defined at the
+		// bottom of this file) carries the asm label that maps its symbol
+		// for the asm side; the label goes on this FIRST declaration too —
+		// clang rejects an asm label applied after first use.
+		extern void nomen_scroll_thunk(nm_Container *, unsigned long long, unsigned long long, nm_Window *, long) __asm__("nomen_scroll_thunk");
+		void nomen_scroll_relayout_all(void *win, long first) {
+			for (int i = 0; i < nomen_scroll_reg_n; i++) {
+				nomen_scroll_thunk(
+					(nm_Container *)nomen_scroll_reg_grid[i],
+					nomen_scroll_reg_sv[i], nomen_scroll_reg_doc[i],
+					(nm_Window *)win, first);
+			}
+		}
+		```
+		```
+		#arch: c
+		#platform: macos
+		nomen_scroll_register(sv, doc, (void *)self);
+		```
+		```
+		#arch: aarch64_use_c
+		#platform: macos
+		nomen_scroll_register(sv, doc, (void *)self);
+		```
+		```
+		#arch: c
+		#platform: ios
+		/* TODO: iOS (see #init) */
+		```
+		```
+		#arch: aarch64_use_c
+		#platform: ios
+		/* TODO: iOS (see #init) */
+		```
+	}
+
+	// Register this grid as a PANE root: after every framework relayout pass
+	// (first post-show + every resize — Window.relayout), the grid is re-laid
+	// into its companion window (`pane_handle`). Pane hosts re-frame on their
+	// own schedule — a Tabs page after the tab view is framed, a SplitView
+	// pane after the split is re-framed — so the app cannot know the right
+	// moment; registration hands the timing to the run loop (the same trade
+	// set_document makes for Scrollable documents). `pane_handle` is the
+	// companion window's `handle` — a scalar, because a second `ref` borrow
+	// of the same owner (self.pane_grid AND self.pane_window) would trip the
+	// aliasing rule (see set_document). The grid (and the pane window) must
+	// outlive the run — app fields. Call once, from App.start. The file-scope
+	// registry lives HERE (same file as the layout thunk the walker calls),
+	// for the same split-link reason set_document records.
+	pub func set_pane = (ref self, uint64 pane_handle) {
+		```
+		#arch: c
+		#platform: macos
+		#scope: file
+		// The registered (pane grid, pane window handle) pairs — walked by
+		// nomen_pane_relayout_all after every relayout pass. Raw grid
+		// addresses: the grid lives in the app struct, whose storage is
+		// stable for the whole run. The window is stored as its handle and
+		// re-wrapped per walk (the same stack Window the scroll thunk builds
+		// over the doc handle) — a by-value Window param would point at
+		// set_pane's own frame once the call returns.
+		static void *nomen_pane_reg_grid[8];
+		static unsigned long long nomen_pane_reg_win[8];
+		static int nomen_pane_reg_n = 0;
+		void nomen_pane_register(void *grid, unsigned long long handle) {
+			if (nomen_pane_reg_n >= 8) return;
+			nomen_pane_reg_grid[nomen_pane_reg_n] = grid;
+			nomen_pane_reg_win[nomen_pane_reg_n] = handle;
+			nomen_pane_reg_n++;
+		}
+		void nomen_pane_relayout_all(void) {
+			for (int i = 0; i < nomen_pane_reg_n; i++) {
+				extern void *_Window_traits[];
+				extern void nomen_layout_thunk(struct Container *, struct Window *);
+				struct Window pane_win;
+				pane_win._vt = (void *)&_Window_traits;
+				pane_win.handle = nomen_pane_reg_win[i];
+				nomen_layout_thunk((struct Container *)nomen_pane_reg_grid[i], &pane_win);
+			}
+		}
+		```
+		```
+		#arch: aarch64_use_c
+		#platform: macos
+		#scope: file
+		static void *nomen_pane_reg_grid[8];
+		static unsigned long long nomen_pane_reg_win[8];
+		static int nomen_pane_reg_n = 0;
+		void nomen_pane_register(void *grid, unsigned long long handle) {
+			if (nomen_pane_reg_n >= 8) return;
+			nomen_pane_reg_grid[nomen_pane_reg_n] = grid;
+			nomen_pane_reg_win[nomen_pane_reg_n] = handle;
+			nomen_pane_reg_n++;
+		}
+		void nomen_pane_relayout_all(void) {
+			for (int i = 0; i < nomen_pane_reg_n; i++) {
+				extern void *Window_traits;
+				extern void nomen_layout_thunk(struct Container *, struct Window *);
+				nm_Window pane_win;
+				pane_win._vt = (void *)&Window_traits;
+				pane_win.handle = nomen_pane_reg_win[i];
+				nomen_layout_thunk((struct Container *)nomen_pane_reg_grid[i], (struct Window *)&pane_win);
+			}
+		}
+		```
+		```
+		#arch: c
+		#platform: macos
+		nomen_pane_register((void *)self, pane_handle);
+		```
+		```
+		#arch: aarch64_use_c
+		#platform: macos
+		nomen_pane_register((void *)self, pane_handle);
+		```
+		```
+		#arch: c
+		#platform: ios
+		/* TODO: iOS (see #init) */
+		```
+		```
+		#arch: aarch64_use_c
+		#platform: ios
+		/* TODO: iOS (see #init) */
+		```
+	}
+
+	// The on_right_click desugar's drain (docs/HANDLERS.md): the synthesized
+	// pump arm polls this per frame. The record is WINDOW-level — the same
+	// edge FrameEvents.click reports as 2, stamped by every process_events
+	// pump and stale the moment the next pump runs — so registration reads
+	// "tell me when a right-click happens": every registered arm sees the
+	// edge (broadcast — no consumption, so arms never starve each other),
+	// and the HANDLER disambiguates: read the click through the dispatch
+	// window (win.click_x()/click_y()), translate for scrollables
+	// (content_click), hit-test children (contains). `self` is the routing
+	// receiver only — the event is not container-scoped.
+	pub func take_right_click = (self, out bool) {
+		```
+		#arch: c
+		#platform: macos
+		extern unsigned char nomen_window_had_right_click(void);
+		return nomen_window_had_right_click();
+		```
+		```
+		#arch: aarch64_use_c
+		#platform: macos
+		extern unsigned char nomen_window_had_right_click(void) __asm__("nomen_window_had_right_click");
+		return nomen_window_had_right_click();
+		```
+		```
+		#arch: c
+		#platform: ios
+		return 0;
+		```
+		```
+		#arch: aarch64_use_c
+		#platform: ios
+		return 0;
+		```
+	}
+
+	// The on_mouse_down desugar's drain (docs/HANDLERS.md): the synthesized
+	// pump arm polls this per frame. The exhaustive window-level edge —
+	// EVERY mouse-down (left, right, middle, mouse 4+), not just the two
+	// named buttons. Like take_right_click, the record is window-level and
+	// broadcast (one edge per pump, every registered arm sees it); the
+	// HANDLER filters and disambiguates: `win.mouse_button()` (1-based —
+	// 1 left, 2 right, 3 middle, 4+ extras), `mouse_click_count()`
+	// (double/triple), `mouse_modifiers()` (cmd/option/ctrl/shift bits),
+	// `click_x()`/`click_y()` for the position. `on_right_click` is the
+	// sugar for button 2.
+	pub func take_mouse_down = (self, out bool) {
+		```
+		#arch: c
+		#platform: macos
+		extern int nomen_last_click_button;
+		return nomen_last_click_button != 0;
+		```
+		```
+		#arch: aarch64_use_c
+		#platform: macos
+		extern int nomen_last_click_button;
+		return nomen_last_click_button != 0;
+		```
+		```
+		#arch: c
+		#platform: ios
+		return 0;
+		```
+		```
+		#arch: aarch64_use_c
+		#platform: ios
+		return 0;
+		```
+	}
+
+	// The on_double_click desugar's drain (docs/HANDLERS.md tier 2): the
+	// sugar over the mouse-down record — left button (1) with a click count
+	// of 2, the list-row "open" gesture. Window-level and broadcast, like
+	// the rest of the family: every registered arm sees the edge, and the
+	// HANDLER disambiguates — position via win.click_x()/click_y() for
+	// hit-testing (a row-targeted refinement can come later through the
+	// table family's native doubleAction). `on_mouse_down` remains the raw
+	// tier (it sees the same double-click with the full record).
+	pub func take_double_click = (self, out bool) {
+		```
+		#arch: c
+		#platform: macos
+		extern int nomen_last_click_button;
+		extern int nomen_last_click_count;
+		return nomen_last_click_button == 1 && nomen_last_click_count == 2;
+		```
+		```
+		#arch: aarch64_use_c
+		#platform: macos
+		extern int nomen_last_click_button;
+		extern int nomen_last_click_count;
+		return nomen_last_click_button == 1 && nomen_last_click_count == 2;
+		```
+		```
+		#arch: c
+		#platform: ios
+		return 0;
+		```
+		```
+		#arch: aarch64_use_c
+		#platform: ios
+		return 0;
+		```
+	}
+
+	// The on_key_down / on_key_up desugars' drains (docs/HANDLERS.md): the
+	// synthesized pump arm polls these per frame. The keyboard record is
+	// window-level and broadcast (like the mouse records): every registered
+	// arm sees every key, and the HANDLER filters — `win.key_code()`
+	// (hardware keycode: Space = 49, Return = 36, arrows = 123–126, letters
+	// a…z = 0–25), `win.key_modifiers()` (Command = 1048576, Option =
+	// 524288, Control = 262144, Shift = 131072), `win.key_repeat()` (a held
+	// key auto-repeating — filter for first-press-only shortcuts),
+	// `win.key_up_code()`. These are SHORTCUT and raw-key events: text
+	// entry does not flow here — a TextBox's typing arrives through
+	// `on_input` (the field editor), which is the right event for editors.
+	pub func take_key_down = (self, out bool) {
+		```
+		#arch: c
+		#platform: macos
+		extern int nomen_last_key_code;
+		return nomen_last_key_code != -1;
+		```
+		```
+		#arch: aarch64_use_c
+		#platform: macos
+		extern int nomen_last_key_code;
+		return nomen_last_key_code != -1;
+		```
+		```
+		#arch: c
+		#platform: ios
+		return 0;
+		```
+		```
+		#arch: aarch64_use_c
+		#platform: ios
+		return 0;
+		```
+	}
+
+	pub func take_key_up = (self, out bool) {
+		```
+		#arch: c
+		#platform: macos
+		extern int nomen_last_key_up_code;
+		return nomen_last_key_up_code != -1;
+		```
+		```
+		#arch: aarch64_use_c
+		#platform: macos
+		extern int nomen_last_key_up_code;
+		return nomen_last_key_up_code != -1;
+		```
+		```
+		#arch: c
+		#platform: ios
+		return 0;
+		```
+		```
+		#arch: aarch64_use_c
+		#platform: ios
+		return 0;
+		```
+	}
+
+	// The on_mouse_move desugar's drain (docs/HANDLERS.md): the synthesized
+	// pump arm polls this per frame. True on any frame whose pump saw a
+	// pointer move or drag; the position rides the dispatch window —
+	// `win.mouse_x()` / `win.mouse_y()` (-1 on a frame with no movement).
+	// Window-level and broadcast, like every record in the family. Hover,
+	// cursors, and tooltips hit-test this against contains(); per-control
+	// entered/exited is sugar over the same record.
+	pub func take_mouse_move = (self, out bool) {
+		```
+		#arch: c
+		#platform: macos
+		extern int nomen_last_mouse_move_x;
+		return nomen_last_mouse_move_x != -1;
+		```
+		```
+		#arch: aarch64_use_c
+		#platform: macos
+		extern int nomen_last_mouse_move_x;
+		return nomen_last_mouse_move_x != -1;
+		```
+		```
+		#arch: c
+		#platform: ios
+		return 0;
+		```
+		```
+		#arch: aarch64_use_c
+		#platform: ios
+		return 0;
+		```
+	}
+
+	// The on_resize desugar's drain (docs/HANDLERS.md): fires on the frame
+	// whose content rect changed. The framework has ALREADY re-laid-out the
+	// registered roots — the handler re-lays-out app-owned panes (tab
+	// pages, split panes). The new size rides the dispatch window via
+	// `win.resize_width()` / `win.resize_height()`; FrameEvents.resized /
+	// width / height carry the same record for `frame`. The record is
+	// stamped by Window.run's resize detection (same edge the frame form
+	// reports) — window-level, broadcast like the rest of the family.
+	pub func take_resize = (self, out bool) {
+		```
+		#arch: c
+		#platform: macos
+		extern int nomen_last_resized;
+		return nomen_last_resized != 0;
+		```
+		```
+		#arch: aarch64_use_c
+		#platform: macos
+		extern int nomen_last_resized;
+		return nomen_last_resized != 0;
+		```
+		```
+		#arch: c
+		#platform: ios
+		return 0;
+		```
+		```
+		#arch: aarch64_use_c
+		#platform: ios
+		return 0;
+		```
+	}
+
 	// Hit test: is point (cx, cy) (top-left origin, as returned by click_x/
 	// click_y) inside the leaf with the given handle?
 	pub func contains = (self, uint64 handle, int cx, int cy, out bool) {
@@ -1638,6 +2373,99 @@ pub func nomen_layout_thunk = (ref Container grid, Window win) {
 	grid.layout(win)
 }
 
+// The grid-side measure for the document dance, as a C-linkage free
+// function (pure Nomen — asm-emitted on aarch64) so the thunk's raw bodies
+// can call it: constraints are the window's content width minus the grid's
+// own padding (the `layout_page` formula), height unbounded.
+pub func nomen_scroll_measure = (ref Container grid, int max_w, out [int, int]) {
+	var bc = BoxConstraints()
+	bc.max_width = max_w
+	const Size cs = grid.measure(bc)
+	return [cs.width, cs.height]
+}
+
+// The per-pair document dance, called from nomen_scroll_relayout_all (the
+// registration's C walker — see set_document above): measure the grid
+// unbounded-height at the window's content width, size the document view,
+// lay the grid out into the document, and — once, on the framework's first
+// post-show pass — scroll to the top. Pointer/handle params: free functions
+// are exported for C linkage on both backends, and the walker holds raw
+// addresses + the scroll's handles (scalars). FULLY RAW bodies: an
+// aarch64_use_c function routes to the C companion using only its raw
+// blocks, so any Nomen statement here would be silently dropped
+// (FOLLOWUP.md) — the measure goes through nomen_scroll_measure instead.
+pub func nomen_scroll_thunk = (ref Container grid, uint64 sv, uint64 doc, ref Window win, int first) {
+	```
+	#arch: c
+	#platform: macos
+	extern struct _Tuple_int_int nomen_scroll_measure(struct Container *, long);
+	id ssv = (id)sv;
+	id sdoc = (id)doc;
+	id win_cv = ((id(*)(id, SEL))objc_msgSend)((id)win->handle, sel_registerName("contentView"));
+	CGRect win_frame = ((CGRect(*)(id, SEL))objc_msgSend)(win_cv, sel_registerName("frame"));
+	struct _Tuple_int_int cs = nomen_scroll_measure(grid, (long)win_frame.size.width - grid->padding * 2);
+	id clip = ((id(*)(id, SEL))objc_msgSend)(ssv, sel_registerName("contentView"));
+	CGRect clip_bounds = ((CGRect(*)(id, SEL))objc_msgSend)(clip, sel_registerName("bounds"));
+	double frame_h = (double)cs._1;
+	if (frame_h < clip_bounds.size.height) frame_h = clip_bounds.size.height;
+	((void(*)(id, SEL, CGSize))objc_msgSend)(sdoc, sel_registerName("setFrameSize:"),
+		((CGSize(*)(double, double))CGSizeMake)((double)cs._0, frame_h));
+	if (first == 1) {
+		// The document view is unflipped and starts showing its bottom-left
+		// corner — the one-time scroll_to_top (the clip's bounds origin sits
+		// `doc_h - clip_h` up from the bottom).
+		CGPoint origin = ((CGPoint(*)(double, double))CGPointMake)(0, frame_h - clip_bounds.size.height);
+		((void(*)(id, SEL, CGPoint))objc_msgSend)(clip, sel_registerName("setBoundsOrigin:"), origin);
+		((void(*)(id, SEL, id))objc_msgSend)(ssv, sel_registerName("reflectScrolledClipView:"), clip);
+	}
+	// Lay the grid out into the document view: a stack Window value over the
+	// doc handle (layout only reads it — no retain needed).
+	extern void *_Window_traits[];
+	extern void nomen_layout_thunk(struct Container *, struct Window *);
+	struct Window doc_win;
+	doc_win._vt = (void *)&_Window_traits;
+	doc_win.handle = doc;
+	nomen_layout_thunk((struct Container *)grid, &doc_win);
+	```
+	```
+	#arch: aarch64_use_c
+	#platform: macos
+	extern nm__Tuple_int_int nomen_scroll_measure(struct Container *, long);
+	id ssv = (id)sv;
+	id sdoc = (id)doc;
+	id win_cv = ((id(*)(id, SEL))objc_msgSend)((id)win->handle, sel_registerName("contentView"));
+	CGRect win_frame = ((CGRect(*)(id, SEL))objc_msgSend)(win_cv, sel_registerName("frame"));
+	nm__Tuple_int_int cs = nomen_scroll_measure(grid, (long)win_frame.size.width - grid->padding * 2);
+	id clip = ((id(*)(id, SEL))objc_msgSend)(ssv, sel_registerName("contentView"));
+	CGRect clip_bounds = ((CGRect(*)(id, SEL))objc_msgSend)(clip, sel_registerName("bounds"));
+	double frame_h = (double)cs._1;
+	if (frame_h < clip_bounds.size.height) frame_h = clip_bounds.size.height;
+	((void(*)(id, SEL, CGSize))objc_msgSend)(sdoc, sel_registerName("setFrameSize:"),
+		((CGSize(*)(double, double))CGSizeMake)((double)cs._0, frame_h));
+	if (first == 1) {
+		CGPoint origin = ((CGPoint(*)(double, double))CGPointMake)(0, frame_h - clip_bounds.size.height);
+		((void(*)(id, SEL, CGPoint))objc_msgSend)(clip, sel_registerName("setBoundsOrigin:"), origin);
+		((void(*)(id, SEL, id))objc_msgSend)(ssv, sel_registerName("reflectScrolledClipView:"), clip);
+	}
+	extern void *Window_traits;
+	extern void nomen_layout_thunk(struct Container *, struct Window *);
+	nm_Window doc_win;
+	doc_win._vt = (void *)&Window_traits;
+	doc_win.handle = doc;
+	nomen_layout_thunk((struct Container *)grid, (struct Window *)&doc_win);
+	```
+	```
+	#arch: c
+	#platform: ios
+	/* TODO: iOS (see #init) */
+	```
+	```
+	#arch: aarch64_use_c
+	#platform: ios
+	/* TODO: iOS (see #init) */
+	```
+}
+
 /**
  * Creates a vertical stack container with the given spacing
  **/