nomen-lang 0.7.1 → 0.9.0

package/core/System/ClassBuffer.nm

@@ -58,6 +58,30 @@ pub struct ClassBuffer<T> {
 		```
 	}
 
+	// Address of slot `i` (library-only): the ELEMENT BORROW primitive for
+	// trait/class elements — `ref T x = list.at(i)` (docs/HANDLERS.md Stage
+	// 4) reaches here through the List wrapper when the element is a trait
+	// (the items buffer is a ClassBuffer). ClassBuffer slots are 8-byte
+	// handles, so the slot's CONTENT is the instance pointer: return the
+	// stored word, not the slot's address. Library-internal: bounds are the
+	// caller's obligation (the List wrapper constrains them).
+	internal func slot_ptr = (ref self, int i, out ptr T) {
+		```
+		#arch: c
+		// The slot's address: through the alias, reads and writes hit the
+		// stored handle word. void* converts to the caller's `T*` spelling.
+		return (void *)&((unsigned long long *)self->data)[i];
+		```
+		```
+		#arch: aarch64
+		// 8-byte slots: the address of slot i — loading through it yields
+		// the stored handle.
+		ldr x8, [x19, #8]
+		lsl x9, x1, #3
+		add x0, x9, x8
+		```
+	}
+
 	// Generic (T-typed) counterparts of the _int primitives. ClassBuffer only
 	// ever holds 8-byte class pointers (T_SIZE is 8), so these are
 	// behaviorally identical to their _int counterparts — they exist so
@@ -94,6 +118,15 @@ pub struct ClassBuffer<T> {
 		```
 	}
 
+	// Labeled delegation point for raw-body callers in other containers
+	// (StableList's chunked storage calls this): `load` is `inline` — spliced
+	// at Nomen call sites, so no label exists for a raw C call or `bl` to
+	// target. Mirror of Buffer.load_from (class slots are pointer words —
+	// the pointer load IS the borrow form).
+	internal func load_from = (self, int i: i >= 0 && i < self.cap, out T) {
+		return self.load(i)
+	}
+
 	// Store the owned class pointer `val` into slot `i`, which MUST be fresh
 	// (calloc'd, or zeroed by mv/move_int). Takes OWNERSHIP of `val`
 	// (`mv`): the slot's #destroy reclaims the instance, so the caller must
@@ -117,6 +150,42 @@ pub struct ClassBuffer<T> {
 		```
 	}
 
+	// Initialize this buffer as a VIEW over a foreign slab (INTERNAL — the
+	// chunked-container primitive): `data` becomes `slab` and `cap` becomes
+	// `fill`, and the buffer owns NOTHING — the slab keeps its real owner
+	// (never grown, never freed by the view). Mirror of Buffer.init_view;
+	// class slots are pointer words.
+	internal func init_view = (ref self, uint64 slab, int fill: fill >= 0) {
+		self.data = slab
+		self.cap = fill
+	}
+
+	// Clear a view initialized by init_view (see Buffer.clear_view): the
+	// holder's own field destroy then reclaims nothing.
+	internal func clear_view = (ref self) {
+		self.data = 0
+		self.cap = 0
+	}
+
+	// Store the owned class pointer `val` into slot `slot` of a foreign slab
+	// at `slab` (fill `fill`) through this buffer as a transient view —
+	// INTERNAL (StableList's directory chunks, class elements): init the
+	// view, run the typed `store` (the ownership-transferring slot store),
+	// then clear the view so the holder's teardown reclaims nothing. The
+	// holder passes a ClassBuffer FIELD, never a local (a local owning buffer
+	// is auto-destroyed at scope exit and would free the borrowed slab).
+	internal func store_in_slab = (
+		ref self,
+		uint64 slab,
+		int fill: fill >= 0,
+		int slot: slot >= 0,
+		mv T val
+	) {
+		self.init_view(slab, fill)
+		self.store(slot, val)
+		self.clear_view()
+	}
+
 	// Move a class pointer out of a slot: return it and zero the slot so the
 	// buffer no longer references it. Declared `mv out T` so the borrow
 	// checker treats the result as OWNED — the slot is relinquished, so the
@@ -254,6 +323,40 @@ pub struct ClassBuffer<T> {
 		```
 	}
 
+	// Reclaim slot i's owned class pointer (destroy + free) WITHOUT writing
+	// the slot — the destroy half of replace_int, without the store, zeroing
+	// the handle so a re-destroy is a no-op. The caller (Map.set_slot_ptr's
+	// replace path — the value-side sibling of `values.replace`) overwrites
+	// the slot immediately afterwards. Contract: the slot must be
+	// overwritten before it is read or destroyed again.
+	internal func destroy_at = (ref self, int i: i >= 0 && i < self.cap) {
+		```
+		#arch: c
+		long *slots = (long*)(unsigned long long)self->data;
+		if (slots[i]) {
+			T_destroy((void*)slots[i]);
+			free((void*)slots[i]);
+			slots[i] = 0;
+		}
+		```
+		```
+		#arch: aarch64
+		stp x20, x21, [sp, #-16]!
+		ldr x20, [x19, #8]
+		lsl x3, x1, #3
+		add x20, x20, x3
+		ldr x0, [x20]
+		cbz x0, .Lcb_destroy_at_done
+		mov x21, x0
+		bl T_destroy
+		mov x0, x21
+		bl _free
+		str xzr, [x20]
+		.Lcb_destroy_at_done:
+		ldp x20, x21, [sp], #16
+		```
+	}
+
 	// T-typed alias of replace_int: free the outgoing class pointer (destroy +
 	// free) then store the new one. Used by List.set so the uniform API
 	// preserves ownership for class elements.
@@ -339,6 +442,59 @@ pub struct ClassBuffer<T> {
 		```
 	}
 
+	// Bulk transfer for backward-shift deletion — the ClassBuffer
+	// counterpart of Buffer.move_range (same contract: every slot in
+	// [dst, dst + count) must be DEAD — zeroed by a move-out or otherwise
+	// unowned — because the block move overwrites without reclaiming; the
+	// deletion algorithms zero and relocate in lockstep). Slots are 8-byte
+	// instance pointers, so the block is one memmove + one memset of the
+	// source slots the destination never covers — List.remove_at_or_panic's
+	// whole-tail shift instead of per-element `shift` calls.
+	internal inline func move_range = (
+		ref self,
+		int dst: dst >= 0,
+		int src: src >= dst,
+		int count: count >= 0 && src + count <= self.cap
+	) {
+		```
+		#arch: c
+		if (count > 0) {
+			long *slots = (long*)(unsigned long long)self->data;
+			memmove((void*)&slots[dst], (void*)&slots[src],
+				(unsigned long long)count * sizeof(long));
+			memset((void*)&slots[dst + count], 0,
+				(unsigned long long)(src - dst) * sizeof(long));
+		}
+		```
+		```
+		#arch: aarch64
+		// x19 = self, x1 = dst, x2 = src, x3 = count. x0-x18 die across the
+		// bl calls, so the block math parks on the stack around _memmove.
+		cbz x3, .Lcb_move_range_T_end
+		ldr x4, [x19, #8]
+		lsl x5, x1, #3
+		add x6, x4, x5
+		lsl x5, x2, #3
+		add x7, x4, x5
+		lsl x9, x3, #3
+		sub x10, x2, x1
+		lsl x10, x10, #3
+		stp x6, x9, [sp, #-16]!
+		str x10, [sp, #-16]!
+		mov x0, x6
+		mov x1, x7
+		mov x2, x9
+		bl _memmove
+		ldr x10, [sp], #16
+		ldp x6, x9, [sp], #16
+		add x0, x6, x9
+		mov x1, #0
+		mov x2, x10
+		bl _memset
+		.Lcb_move_range_T_end:
+		```
+	}
+
 	// A non-mv (ptr, len) slice [start, end) over this buffer's class
 	// 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

package/core/System/Controls/Alert.nm

@@ -0,0 +1,326 @@
+/**
+ * A system alert dialog (NSAlert)
+ *
+ * An OWNING STRUCT (STRUCT_PLAN_3 Phase R, tranche 4 — the shape menu): the
+ * single field is a platform handle, so the value is movable and its
+ * `#destroy` releases what the handle names. The constructor's `self` is
+ * the inline instance (the `.` accessor); methods keep the pointer form.
+ *
+ * Window-coordinated: `run` enters NSAlert's own modal loop (it blocks the
+ * caller and pumps its own events, so it works with the manual loop), and
+ * returns the clicked button's index (first button = 0). iOS defers —
+ * UIAlertController needs a presenting view controller (TODO stubs; see
+ * GUI_PLAN Tier 1 #19).
+ **/
+pub mv struct Alert: Control {
+	var uint64 handle = 0
+
+	// The `#handle` hook synthesizes `NameHandle` — a copyable, non-owning
+	// twin (same public bare-self methods, no destroy) so closures can
+	// capture this control without moving it. See GUI.md, "Handles".
+	#handle = () { }
+
+	pub func #init = (self) {
+		```
+		#arch: c
+		#platform: macos
+		id alert = ((id(*)(id, SEL))objc_msgSend)(
+			((id(*)(id, SEL))objc_msgSend)((id)objc_getClass("NSAlert"), sel_registerName("alloc")),
+			sel_registerName("init"));
+		self.handle = (uint64_t)alert;
+		```
+		```
+		#arch: aarch64_use_c
+		#platform: macos
+		id alert = ((id(*)(id, SEL))objc_msgSend)(
+			((id(*)(id, SEL))objc_msgSend)((id)objc_getClass("NSAlert"), sel_registerName("alloc")),
+			sel_registerName("init"));
+		self->handle = (uint64_t)alert;
+		```
+		```
+		#arch: c
+		#platform: ios
+		/* TODO: iOS — UIAlertController needs a presenting view controller
+		 * (see GUI_PLAN Tier 1 #19; defer the iOS block). */
+		```
+		```
+		#arch: aarch64_use_c
+		#platform: ios
+		/* TODO: iOS — UIAlertController needs a presenting view controller
+		 * (see GUI_PLAN Tier 1 #19; defer the iOS block). */
+		```
+	}
+
+	// The alert's headline (bold first line).
+	pub func set_title = (self, string title) {
+		```
+		#arch: c
+		#platform: macos
+		((void(*)(id, SEL, id))objc_msgSend)(
+			(id)self->handle, sel_registerName("setMessageText:"),
+			((id(*)(id, SEL, const char*))objc_msgSend)(
+				(id)objc_getClass("NSString"), sel_registerName("stringWithUTF8String:"), title.ptr));
+		```
+		```
+		#arch: aarch64_use_c
+		#platform: macos
+		((void(*)(id, SEL, id))objc_msgSend)(
+			(id)self->handle, sel_registerName("setMessageText:"),
+			((id(*)(id, SEL, const char*))objc_msgSend)(
+				(id)objc_getClass("NSString"), sel_registerName("stringWithUTF8String:"), title.ptr));
+		```
+		```
+		#arch: c
+		#platform: ios
+		/* TODO: iOS (see #init) */
+		```
+		```
+		#arch: aarch64_use_c
+		#platform: ios
+		/* TODO: iOS (see #init) */
+		```
+	}
+
+	pub func title = (self, out string) {
+		```
+		#arch: c
+		#platform: macos
+		id str = ((id(*)(id, SEL))objc_msgSend)(
+			(id)self->handle, sel_registerName("messageText"));
+		if (!str) return (nomen_string){ strdup(""), 0 };
+		const char *cstr = ((const char*(*)(id, SEL))objc_msgSend)(
+			str, sel_registerName("UTF8String"));
+		return (nomen_string){ strdup(cstr), (long)strlen(cstr) };
+		```
+		```
+		#arch: aarch64_use_c
+		#platform: macos
+		id str = ((id(*)(id, SEL))objc_msgSend)(
+			(id)self->handle, sel_registerName("messageText"));
+		if (!str) return (nomen_string){ strdup(""), 0 };
+		const char *cstr = ((const char*(*)(id, SEL))objc_msgSend)(
+			str, sel_registerName("UTF8String"));
+		return (nomen_string){ strdup(cstr), (long)strlen(cstr) };
+		```
+		```
+		#arch: c
+		#platform: ios
+		/* TODO: iOS (see #init) */
+		return (nomen_string){ strdup(""), 0 };
+		```
+		```
+		#arch: aarch64_use_c
+		#platform: ios
+		/* TODO: iOS (see #init) */
+		return (nomen_string){ strdup(""), 0 };
+		```
+	}
+
+	// The explanatory second line.
+	pub func set_message = (self, string message) {
+		```
+		#arch: c
+		#platform: macos
+		((void(*)(id, SEL, id))objc_msgSend)(
+			(id)self->handle, sel_registerName("setInformativeText:"),
+			((id(*)(id, SEL, const char*))objc_msgSend)(
+				(id)objc_getClass("NSString"), sel_registerName("stringWithUTF8String:"), message.ptr));
+		```
+		```
+		#arch: aarch64_use_c
+		#platform: macos
+		((void(*)(id, SEL, id))objc_msgSend)(
+			(id)self->handle, sel_registerName("setInformativeText:"),
+			((id(*)(id, SEL, const char*))objc_msgSend)(
+				(id)objc_getClass("NSString"), sel_registerName("stringWithUTF8String:"), message.ptr));
+		```
+		```
+		#arch: c
+		#platform: ios
+		/* TODO: iOS (see #init) */
+		```
+		```
+		#arch: aarch64_use_c
+		#platform: ios
+		/* TODO: iOS (see #init) */
+		```
+	}
+
+	pub func message = (self, out string) {
+		```
+		#arch: c
+		#platform: macos
+		id str = ((id(*)(id, SEL))objc_msgSend)(
+			(id)self->handle, sel_registerName("informativeText"));
+		if (!str) return (nomen_string){ strdup(""), 0 };
+		const char *cstr = ((const char*(*)(id, SEL))objc_msgSend)(
+			str, sel_registerName("UTF8String"));
+		return (nomen_string){ strdup(cstr), (long)strlen(cstr) };
+		```
+		```
+		#arch: aarch64_use_c
+		#platform: macos
+		id str = ((id(*)(id, SEL))objc_msgSend)(
+			(id)self->handle, sel_registerName("informativeText"));
+		if (!str) return (nomen_string){ strdup(""), 0 };
+		const char *cstr = ((const char*(*)(id, SEL))objc_msgSend)(
+			str, sel_registerName("UTF8String"));
+		return (nomen_string){ strdup(cstr), (long)strlen(cstr) };
+		```
+		```
+		#arch: c
+		#platform: ios
+		/* TODO: iOS (see #init) */
+		return (nomen_string){ strdup(""), 0 };
+		```
+		```
+		#arch: aarch64_use_c
+		#platform: ios
+		/* TODO: iOS (see #init) */
+		return (nomen_string){ strdup(""), 0 };
+		```
+	}
+
+	// Append a button (left to right). The FIRST button is the default
+	// (Return); the clicked one's index is what `run` returns. A fresh
+	// NSAlert carries one default button ("OK") — the first
+	// `add_button` REPLACES it, so the count stays what the app adds.
+	pub func add_button = (self, string title) {
+		```
+		#arch: c
+		#platform: macos
+		((void(*)(id, SEL, id))objc_msgSend)(
+			(id)self->handle, sel_registerName("addButtonWithTitle:"),
+			((id(*)(id, SEL, const char*))objc_msgSend)(
+				(id)objc_getClass("NSString"), sel_registerName("stringWithUTF8String:"), title.ptr));
+		```
+		```
+		#arch: aarch64_use_c
+		#platform: macos
+		((void(*)(id, SEL, id))objc_msgSend)(
+			(id)self->handle, sel_registerName("addButtonWithTitle:"),
+			((id(*)(id, SEL, const char*))objc_msgSend)(
+				(id)objc_getClass("NSString"), sel_registerName("stringWithUTF8String:"), title.ptr));
+		```
+		```
+		#arch: c
+		#platform: ios
+		/* TODO: iOS (see #init) */
+		```
+		```
+		#arch: aarch64_use_c
+		#platform: ios
+		/* TODO: iOS (see #init) */
+		```
+	}
+
+	// How many buttons the alert carries.
+	pub func button_count = (self, out int) {
+		```
+		#arch: c
+		#platform: macos
+		id buttons = ((id(*)(id, SEL))objc_msgSend)(
+			(id)self->handle, sel_registerName("buttons"));
+		return (int)((long(*)(id, SEL))objc_msgSend)(buttons, sel_registerName("count"));
+		```
+		```
+		#arch: aarch64_use_c
+		#platform: macos
+		id buttons = ((id(*)(id, SEL))objc_msgSend)(
+			(id)self->handle, sel_registerName("buttons"));
+		return (int)((long(*)(id, SEL))objc_msgSend)(buttons, sel_registerName("count"));
+		```
+		```
+		#arch: c
+		#platform: ios
+		/* TODO: iOS (see #init) */
+		return 0;
+		```
+		```
+		#arch: aarch64_use_c
+		#platform: ios
+		/* TODO: iOS (see #init) */
+		return 0;
+		```
+	}
+
+	// Show the alert modally and return the clicked button's index (0 =
+	// first button). BLOCKS in NSAlert's own modal loop until dismissed —
+	// call it from the event thread when the manual loop can afford to
+	// pause (NSAlert pumps its own events, so the UI stays live).
+	pub func run = (self, out int) {
+		```
+		#arch: c
+		#platform: macos
+		long code = ((long(*)(id, SEL))objc_msgSend)(
+			(id)self->handle, sel_registerName("runModal"));
+		return (int)(code - 1000); // NSModalResponseOK = 1000 + button index
+		```
+		```
+		#arch: aarch64_use_c
+		#platform: macos
+		long code = ((long(*)(id, SEL))objc_msgSend)(
+			(id)self->handle, sel_registerName("runModal"));
+		return (int)(code - 1000); // NSModalResponseOK = 1000 + button index
+		```
+		```
+		#arch: c
+		#platform: ios
+		/* TODO: iOS (see #init) */
+		return 0;
+		```
+		```
+		#arch: aarch64_use_c
+		#platform: ios
+		/* TODO: iOS (see #init) */
+		return 0;
+		```
+	}
+
+	// ── Control trait conformance ──
+	// An alert is a modal, not an in-window view: it measures to nothing and
+	// the layout engine never frames it. The conformance exists so an Alert
+	// can sit in a Control-typed slot without special-casing.
+	pub func set_frame = (ref self, int x, int y, int width, int height) {
+		// No-op: modals are positioned by the window server.
+	}
+
+	pub func intrinsic_size = (self, out Size) {
+		var s = Size()
+		return s
+	}
+
+	pub func measure = (self, BoxConstraints constraints, out Size) {
+		var s = Size()
+		return s
+	}
+
+	func #destroy = () {
+		```
+		#arch: c
+		#platform: macos
+		if (self->handle) {
+			((void(*)(id, SEL))objc_msgSend)((id)self->handle, sel_registerName("release"));
+			self->handle = 0;
+		}
+		```
+		```
+		#arch: aarch64_use_c
+		#platform: macos
+		if (self->handle) {
+			((void(*)(id, SEL))objc_msgSend)((id)self->handle, sel_registerName("release"));
+			self->handle = 0;
+		}
+		```
+		```
+		#arch: c
+		#platform: ios
+		/* TODO: iOS (see #init) */
+		```
+		```
+		#arch: aarch64_use_c
+		#platform: ios
+		/* TODO: iOS (see #init) */
+		```
+	}
+}

package/core/System/Controls/App.nm

@@ -0,0 +1,147 @@
+/**
+ * The App contract: the object Window.run drives
+ *
+ * The WinForms/Swift shape for a manual-loop toolkit: instead of pumping
+ * `Window.process_events` and re-checking sizes in a `while` loop, the app
+ * declares a struct conforming to `App`, moves it into `win.run(mv app)`,
+ * and the WINDOW owns everything else — the event pump, the autorelease
+ * pool, resize detection, and the relayout of the hosted content (the root
+ * `Container` from `win.set_content` plus every `Scrollable.set_content`
+ * document). The app implements four hooks:
+ *
+ * - `start` — called once, after the app has been moved into its final
+ *   storage but before the window is shown. Register the layout roots here
+ *   (`win.set_content(ref grid)`, `scroll.set_content(ref grid)`) and do
+ *   any wiring that needs stable addresses — including click handlers
+ *   (`self.btn.on_click(func () { ... })`).
+ * - `frame` — called every iteration of the run loop with a `FrameEvents`
+ *   value: the full input record for this frame (click kind/coordinates,
+ *   `mouse_button`/`mouse_click_count`/`mouse_modifiers` — every button,
+ *   `scroll_dx`/`scroll_dy`, the keyboard record
+ *   `key_code`/`key_modifiers`/`key_repeat`/`key_up_code`, the pointer
+ *   position `mouse_x`/`mouse_y`, and frame time `dt`), and `resized`
+ *   + the new size when the window's content rect changed. Per-frame value
+ *   polling (slider → progress mirrors), coordinate-driven input that no
+ *   event names, and app-owned pane relayouts live here — registered
+ *   click, right-click, mouse-down, scroll, key, move, and resize handlers
+ *   dispatch earlier, in `handle_events` (the `.on_click` /
+ *   `.on_right_click` / `.on_mouse_down` / `.on_scroll` / `.on_key_down` /
+ *   `.on_key_up` / `.on_mouse_move` / `.on_resize` desugars), and close
+ *   requests consult `close_requested`.
+ * - `handle_events` — the per-frame event pump: drains every registered
+ *   control event (clicks, focus/blur, text input). Declared here as a
+ *   default-empty method; the `.on_<event>(closure)` desugars
+ *   (docs/HANDLERS.md) synthesize the override on conformers with
+ *   registrations, so user code only writes the registration and never
+ *   sees the machinery. New control events extend the pump's arms — the
+ *   App contract is fixed.
+ * - `run_handler` — the up-call protocol (Stage 3): a composite with an
+ *   enrolled event calls back `owner.run_handler(id, ref win)` from its
+ *   `tick` (the app forwards itself down once per tick). Default-empty;
+ *   the desugar synthesizes the override dispatching ids to the app's
+ *   `.on_<event>` handlers.
+ *
+ * Handlers are METHODS on the app (the `ref self` receiver), so app state —
+ * every control field — is reachable without lambda captures (capturing a
+ * control MOVES it; a capture-free method reference moves nothing). The
+ * `.on_click` desugar is that shape with registration ergonomics: the
+ * closure you write IS hoisted into a hidden method, and the dispatch
+ * borrow of `self` is taken by the run loop per frame.
+ **/
+pub trait App {
+	// Called once before the window is shown, after the app is in its
+	// final storage. Register layout roots here.
+	func start = (ref self, ref Window win) {
+	}
+
+	// Called every frame until the window closes.
+	func frame = (ref self, ref Window win, FrameEvents ev) {
+	}
+
+	// The per-frame event pump: drains every registered control event —
+	// clicks, focus/blur, text input — through arms the `.on_<event>`
+	// desugar (docs/HANDLERS.md) synthesizes on conformers with
+	// registrations: one hidden method per closure, one drain arm per
+	// registered control, one event-source prologue per family.
+	// `Window.run` calls it before `frame`. New control events are new arms
+	// in this one slot — the App contract never grows with the event
+	// catalog. Conformers without registrations inherit this empty default
+	// (trait defaults have precedent: `Enumerable.length`).
+	func handle_events = (ref self, ref Window win) {
+	}
+
+	// The up-call protocol (docs/HANDLERS.md Stage 3): a composite the app
+	// has enrolled events on calls back into this — `owner.run_handler(id,
+	// ref win)` from its `tick` — one vtable hop into the desugar's
+	// synthesized override, whose arms dispatch the id to the app's handler.
+	// The borrow flows down per call; nothing outlives it. Default-empty,
+	// like `handle_events`.
+	func run_handler = (ref self, int id, ref Window win) {
+	}
+
+	// Close interception (the unsaved-changes pattern): run consults this
+	// on the frame after the user requests close (the red button — the
+	// delegate refuses the native close and sets a pending flag). Return
+	// false to refuse: the window stays, the flag is cleared, and a later
+	// close request consults again. Programmatic `win.close()` is FORCED
+	// and bypasses this — handlers closing their own window never trip the
+	// interception. Default: allow.
+	func close_requested = (ref self, ref Window win, out bool) {
+		return true
+	}
+}
+
+/**
+ * One frame's input state, passed to App.frame
+ *
+ * Pure scalars, so the by-value parameter copies safely (no destroy).
+ * Click coordinates are the window's content coordinates, top-left origin
+ * (the same values `Window.click_x`/`click_y` report) — translate through
+ * `content_click` before hit-testing controls hosted on a Scrollable.
+ **/
+pub mv struct FrameEvents {
+	// 0 = no mouse-down this frame, 1 = left, 2 = right (edge-triggered:
+	// only the frame that pumped the event reports it).
+	pub var click = 0
+	pub var int click_x = -1
+	pub var int click_y = -1
+	// The full mouse record for this frame (0 = no mouse-down): the 1-based
+	// button number (1 left, 2 right, 3 middle, 4+ extra buttons), the
+	// AppKit click count (2 = double-click), and the device-independent
+	// modifier flags (Command = 0x100000, Option = 0x80000, Control =
+	// 0x40000, Shift = 0x20000). The same values the `win.mouse_button()` /
+	// `mouse_click_count()` / `mouse_modifiers()` getters report to
+	// `on_mouse_down` handlers. `click` remains the left/right compat view.
+	pub var mouse_button = 0
+	pub var mouse_click_count = 0
+	pub var mouse_modifiers = 0
+	// This frame's accumulated scroll-wheel deltas (dy positive scrolling
+	// up/away, dx positive right; trackpad frames sum every small event).
+	// `Scrollable.on_scroll` is the registered-handler form.
+	pub var scroll_dx = 0
+	pub var scroll_dy = 0
+	// The keyboard record for this frame (-1 = no key this frame): the
+	// hardware keycode of the last key-down (Space = 49, Return = 36,
+	// arrows = 123–126, letters a…z = 0–25), the modifiers at key-down,
+	// whether it was an auto-repeat, and the keycode of the last key-up.
+	// `on_key_down` / `on_key_up` are the registered-handler forms; text
+	// ENTRY flows through `on_input` (the field editor), not here.
+	pub var int key_code = -1
+	pub var key_modifiers = 0
+	pub var key_repeat = false
+	pub var int key_up_code = -1
+	// The pointer-MOVE record for this frame (-1 = no movement): the
+	// current pointer position. `on_mouse_move` is the registered-handler
+	// form; hover/tooltips hit-test this against Container.contains.
+	pub var int mouse_x = -1
+	pub var int mouse_y = -1
+	// Milliseconds since the previous frame (0 on the first) — the
+	// animation clock. `win.dt()` reports the same value.
+	pub var dt = 0
+	// True when the window's content rect changed since the last frame —
+	// the framework has already re-laid-out the registered roots; re-layout
+	// App-owned panes (tab pages, split panes) here.
+	pub var resized = false
+	pub var width = 0
+	pub var height = 0
+}