feat(content): scrollable contents; bump zterm dependency

With functional increments in `zterm`'s `Scrollable` `Element`, an
implementation (such as `Content`) can provide a size hint for the
minimal required size to dynamically change its dimensions for the
scrollable `Container` in the `Scrollable` `Element`.

src/content.zig

@@ -1,27 +1,62 @@
 pub fn Content(App: type) type {
     return struct {
+        page: App.Model.Pages,
+
         pub fn init(allocator: Allocator) @This() {
             _ = allocator;
-            return .{};
+            return .{
+                .page = .blog,
+            };
+        }
+
+        pub fn deinit(this: *@This()) void {
+            this.container.deinit();
         }
 
         pub fn element(this: *@This()) App.Element {
             return .{
                 .ptr = this,
                 .vtable = &.{
+                    .minSize = minSize,
                     .handle = handle,
                     .content = content,
                 },
             };
         }
 
+        fn minSize(ctx: *anyopaque, size: zterm.Point) zterm.Point {
+            const this: *const @This() = @ptrCast(@alignCast(ctx));
+            const text = switch (this.page) {
+                .about => @embedFile("about"),
+                .blog => @embedFile("blog"),
+            };
+            var index: usize = 0;
+            var new_size: zterm.Point = .{ .x = size.x };
+
+            for (0..text.len) |_| rows: {
+                for (0..size.x) |_| {
+                    if (index == text.len) break :rows;
+                    const cp = text[index];
+                    index += 1;
+
+                    switch (cp) {
+                        '\n' => break,
+                        else => {},
+                    }
+                }
+                new_size.y += 1;
+            }
+            return new_size;
+        }
+
         fn handle(ctx: *anyopaque, model: *App.Model, event: App.Event) !void {
-            _ = ctx;
+            const this: *@This() = @ptrCast(@alignCast(ctx));
             switch (event) {
                 .about => model.page = .about,
                 .blog => model.page = .blog,
                 else => {},
             }
+            this.page = model.page;
         }
 
         fn content(ctx: *anyopaque, model: *const App.Model, cells: []zterm.Cell, size: zterm.Point) !void {
@@ -37,7 +72,6 @@ pub fn Content(App: type) type {
             for (0..size.y) |row| {
                 for (0..size.x) |col| {
                     const cell = row * size.x + col;
-                    assert(cell < cells.len);
 
                     if (index == text.len) return;
                     const cp = text[index];