ui: port game UI framework into library/modules/ui

20 files (~3,830 lines): view protocol, layout, renderer, glyph cache,
fonts, gestures, animation, scroll, stacks, modifiers, etc.

Internal imports rewritten from "ui/..." to "modules/ui/...".
Consumers now `#import "modules/ui"` from any project; no symlink
hacks needed. Verified by compiling game/main.sx without its local
ui/ — resolves via the Phase 6 stdlib fallback.

library/modules/ui/pipeline.sx

@@ -0,0 +1,162 @@
+#import "modules/std.sx";
+#import "modules/allocators.sx";
+#import "modules/opengl.sx";
+#import "modules/ui/types.sx";
+#import "modules/ui/render.sx";
+#import "modules/ui/events.sx";
+#import "modules/ui/view.sx";
+#import "modules/ui/renderer.sx";
+
+UIPipeline :: struct {
+    renderer: UIRenderer;
+    render_tree: RenderTree;
+    font: GlyphCache;
+    screen_width: f32;
+    screen_height: f32;
+    root: ViewChild;
+    has_root: bool;
+
+    // Frame arena infrastructure
+    arena_a: Arena;
+    arena_b: Arena;
+    frame_index: s64;
+    body: Closure() -> View;
+    has_body: bool;
+    parent_allocator: Allocator;
+
+    init :: (self: *UIPipeline, width: f32, height: f32) {
+        self.render_tree = RenderTree.init();
+        self.renderer.init();
+        self.screen_width = width;
+        self.screen_height = height;
+        self.has_root = false;
+        self.has_body = false;
+        self.frame_index = 0;
+    }
+
+    init_font :: (self: *UIPipeline, path: [:0]u8, size: f32, dpi_scale: f32) {
+        self.font.init(path, size);
+        self.font.set_dpi_scale(dpi_scale);
+        self.renderer.dpi_scale = dpi_scale;
+        set_global_font(@self.font);
+    }
+
+    set_root :: (self: *UIPipeline, view: View) {
+        self.root = .{ view = view };
+        self.has_root = true;
+    }
+
+    set_body :: (self: *UIPipeline, body_fn: Closure() -> View) {
+        self.body = body_fn;
+        self.has_body = true;
+        self.parent_allocator = context.allocator;
+        // Initialize both arenas (256KB initial, grows automatically)
+        self.arena_a.create(self.parent_allocator, 262144);
+        self.arena_b.create(self.parent_allocator, 262144);
+        self.frame_index = 0;
+    }
+
+    resize :: (self: *UIPipeline, width: f32, height: f32) {
+        self.screen_width = width;
+        self.screen_height = height;
+    }
+
+    // Re-layout and re-render the existing view tree at current screen size.
+    // Does NOT rebuild from body — safe to call from C callbacks (no arena/context needed).
+    tick_relayout :: (self: *UIPipeline) {
+        if self.has_root == false { return; }
+
+        proposal := ProposedSize.fixed(self.screen_width, self.screen_height);
+        self.root.view.size_that_fits(proposal);
+        self.root.computed_frame = Frame.{
+            origin = Point.zero(),
+            size = Size.{ width = self.screen_width, height = self.screen_height }
+        };
+        self.root.view.layout(self.root.computed_frame);
+
+        self.render_tree.clear();
+        ctx := RenderContext.init(@self.render_tree);
+        self.root.view.render(@ctx, self.root.computed_frame);
+
+        self.commit_gpu();
+    }
+
+    // Process a single event through the view tree
+    dispatch_event :: (self: *UIPipeline, event: *Event) -> bool {
+        if self.has_root == false { return false; }
+        self.root.view.handle_event(event, self.root.computed_frame);
+    }
+
+    // Run one frame: layout → render → commit
+    tick :: (self: *UIPipeline) {
+        if self.has_body {
+            self.tick_with_body();
+            return;
+        }
+        if self.has_root == false { return; }
+
+        proposal := ProposedSize.fixed(self.screen_width, self.screen_height);
+
+        // Layout
+        self.root.view.size_that_fits(proposal);
+        self.root.computed_frame = Frame.{
+            origin = Point.zero(),
+            size = Size.{ width = self.screen_width, height = self.screen_height }
+        };
+        self.root.view.layout(self.root.computed_frame);
+
+        // Render to tree
+        self.render_tree.clear();
+        ctx := RenderContext.init(@self.render_tree);
+        self.root.view.render(@ctx, self.root.computed_frame);
+
+        // Commit to GPU
+        self.commit_gpu();
+    }
+
+    tick_with_body :: (self: *UIPipeline) {
+        build_arena : *Arena = if self.frame_index & 1 == 0 then @self.arena_a else @self.arena_b;
+        build_arena.reset();
+
+        // Reset render_tree nodes (backing is stale after arena reset)
+        self.render_tree.nodes.items = null;
+        self.render_tree.nodes.len = 0;
+        self.render_tree.nodes.cap = 0;
+
+        push Context.{ allocator = xx build_arena, data = context.data } {
+            // Workaround: self.body() crashes through struct field (issue-0010)
+            body_fn := self.body;
+            root_view := body_fn();
+            self.root = .{ view = root_view };
+            self.has_root = true;
+
+            proposal := ProposedSize.fixed(self.screen_width, self.screen_height);
+            self.root.view.size_that_fits(proposal);
+            self.root.computed_frame = Frame.{
+                origin = Point.zero(),
+                size = Size.{ width = self.screen_width, height = self.screen_height }
+            };
+            self.root.view.layout(self.root.computed_frame);
+
+            self.render_tree.clear();
+            ctx := RenderContext.init(@self.render_tree);
+            self.root.view.render(@ctx, self.root.computed_frame);
+
+            self.commit_gpu();
+        }
+
+        self.frame_index += 1;
+    }
+
+    commit_gpu :: (self: *UIPipeline) {
+        glEnable(GL_BLEND);
+        glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
+        glDisable(GL_DEPTH_TEST);
+
+        self.renderer.begin(self.screen_width, self.screen_height, self.font.texture_id);
+        self.renderer.process(@self.render_tree);
+        self.renderer.flush();
+
+        glDisable(GL_BLEND);
+    }
+}