Merge pull request #202 from RtlZeroMemory/release/alpha-40

chore(release): bump Zireael vendor and prepare alpha.40

Author: RtlZeroMemory

CHANGELOG.md

@@ -6,6 +6,27 @@ The format is based on Keep a Changelog and the project follows Semantic Version
 
 ## [Unreleased]
 
+## [0.1.0-alpha.40] - 2026-02-25
+
+### Bug Fixes
+
+- **native/vendor**: Bumped vendored Zireael engine to `v1.3.8-alpha.7` (`8d8b5f8`) and synchronized `packages/native/vendor` sources.
+- **runtime/errors**: Hardened dev warning paths for swallowed callback exceptions, including safe thrown-value formatting in catch blocks.
+- **runtime/ids**: Strengthened widget ID validation; whitespace-only interactive IDs are now rejected deterministically.
+- **collections**: `each()` / `eachInline()` now detect duplicate keys at construction time with deterministic diagnostics.
+- **forms**: Async form validation no longer applies canceled/stale rejection results and now preserves actionable wrapped error context.
+- **router**: Hardened route guard error handling and param validation paths.
+- **keybindings**: Added max chord length enforcement and duplicate keybinding warnings.
+
+### Merged Pull Requests
+
+- [#195](https://github.com/RtlZeroMemory/Rezi/pull/195) fix(core): dev-mode warnings for silently swallowed callback errors
+- [#196](https://github.com/RtlZeroMemory/Rezi/pull/196) fix(core): harden widget ID validation and view function return checks
+- [#197](https://github.com/RtlZeroMemory/Rezi/pull/197) fix(core): detect duplicate keys in each()/eachInline() at construction time
+- [#198](https://github.com/RtlZeroMemory/Rezi/pull/198) fix(core): stop swallowing async form validation errors
+- [#199](https://github.com/RtlZeroMemory/Rezi/pull/199) fix(core): harden router guard error handling and param validation
+- [#200](https://github.com/RtlZeroMemory/Rezi/pull/200) fix(core): add max chord length and duplicate keybinding warnings
+
 ## [0.1.0-alpha.39] - 2026-02-24
 
 ### Bug Fixes

packages/native/vendor/VENDOR_COMMIT.txt

@@ -1 +1 @@
-7ec5c0d5e8ecc3e4bb8261685aeab039fa02816b
+8d8b5f8687b04ee3aaed6b133948724a595a9886

packages/native/vendor/zireael/include/zr/zr_debug.h

@@ -18,6 +18,9 @@
 
 #include <stdint.h>
 
+#define ZR_DEBUG_SOURCE_FILE_LEN 32u
+#define ZR_DEBUG_MESSAGE_LEN 64u
+
 /*
   Debug record categories.
 
@@ -111,11 +114,11 @@ typedef struct zr_debug_error_record_t {
     source_file: 32-byte fixed buffer for source file name (truncated).
     Why: Avoids pointer indirection while providing actionable context.
   */
-  char source_file[32];
+  char source_file[ZR_DEBUG_SOURCE_FILE_LEN];
   /*
     message: 64-byte fixed buffer for error message (truncated).
   */
-  char message[64];
+  char message[ZR_DEBUG_MESSAGE_LEN];
 } zr_debug_error_record_t;
 
 /*

packages/native/vendor/zireael/include/zr/zr_drawlist.h

@@ -67,6 +67,11 @@ typedef enum zr_dl_opcode_t {
   ZR_DL_OP_DRAW_IMAGE = 9
 } zr_dl_opcode_t;
 
+/*
+  Sub-cell blitter selector for DRAW_CANVAS / image fallback paths.
+
+  A "blitter" maps RGBA pixels onto terminal cell glyph/style combinations.
+*/
 typedef enum zr_blitter_t {
   ZR_BLIT_AUTO = 0,      /* engine selects based on capability policy */
   ZR_BLIT_PIXEL = 1,     /* reserved for graphics protocol path */
@@ -77,6 +82,36 @@ typedef enum zr_blitter_t {
   ZR_BLIT_ASCII = 6      /* 1x1 space+background fallback */
 } zr_blitter_t;
 
+typedef enum zr_dl_cursor_shape_t {
+  ZR_DL_CURSOR_BLOCK = 0,
+  ZR_DL_CURSOR_UNDERLINE = 1,
+  ZR_DL_CURSOR_BAR = 2
+} zr_dl_cursor_shape_t;
+
+typedef enum zr_dl_draw_image_format_t {
+  ZR_DL_DRAW_IMAGE_FORMAT_RGBA = 0,
+  ZR_DL_DRAW_IMAGE_FORMAT_PNG = 1
+} zr_dl_draw_image_format_t;
+
+typedef enum zr_dl_draw_image_protocol_t {
+  ZR_DL_DRAW_IMAGE_PROTOCOL_AUTO = 0,
+  ZR_DL_DRAW_IMAGE_PROTOCOL_KITTY = 1,
+  ZR_DL_DRAW_IMAGE_PROTOCOL_SIXEL = 2,
+  ZR_DL_DRAW_IMAGE_PROTOCOL_ITERM2 = 3
+} zr_dl_draw_image_protocol_t;
+
+typedef enum zr_dl_draw_image_z_layer_t {
+  ZR_DL_DRAW_IMAGE_Z_BACK = -1,
+  ZR_DL_DRAW_IMAGE_Z_NORMAL = 0,
+  ZR_DL_DRAW_IMAGE_Z_FRONT = 1
+} zr_dl_draw_image_z_layer_t;
+
+typedef enum zr_dl_draw_image_fit_mode_t {
+  ZR_DL_DRAW_IMAGE_FIT_FILL = 0,
+  ZR_DL_DRAW_IMAGE_FIT_CONTAIN = 1,
+  ZR_DL_DRAW_IMAGE_FIT_COVER = 2
+} zr_dl_draw_image_fit_mode_t;
+
 typedef struct zr_dl_style_t {
   uint32_t fg;
   uint32_t bg;
@@ -161,7 +196,7 @@ typedef struct zr_dl_text_run_segment_v3_t {
 typedef struct zr_dl_cmd_set_cursor_t {
   int32_t x;         /* 0-based cell; -1 means "leave unchanged" */
   int32_t y;         /* 0-based cell; -1 means "leave unchanged" */
-  uint8_t shape;     /* 0=block, 1=underline, 2=bar */
+  uint8_t shape;     /* zr_dl_cursor_shape_t */
   uint8_t visible;   /* 0/1 */
   uint8_t blink;     /* 0/1 */
   uint8_t reserved0; /* must be 0 */
@@ -191,10 +226,10 @@ typedef struct zr_dl_cmd_draw_image_t {
   uint32_t blob_offset; /* byte offset inside drawlist blob-bytes section */
   uint32_t blob_len;    /* payload bytes */
   uint32_t image_id;    /* stable image key for protocol cache reuse */
-  uint8_t format;       /* 0=RGBA, 1=PNG */
-  uint8_t protocol;     /* 0=auto, 1=kitty, 2=sixel, 3=iterm2 */
-  int8_t z_layer;       /* -1, 0, 1 */
-  uint8_t fit_mode;     /* 0=fill, 1=contain, 2=cover */
+  uint8_t format;       /* zr_dl_draw_image_format_t */
+  uint8_t protocol;     /* zr_dl_draw_image_protocol_t */
+  int8_t z_layer;       /* zr_dl_draw_image_z_layer_t */
+  uint8_t fit_mode;     /* zr_dl_draw_image_fit_mode_t */
   uint8_t flags;        /* reserved; must be 0 */
   uint8_t reserved0;    /* reserved; must be 0 */
   uint16_t reserved1;   /* reserved; must be 0 */

packages/native/vendor/zireael/include/zr/zr_event.h

@@ -60,6 +60,17 @@ typedef enum zr_event_type_t {
 #define ZR_MOD_ALT (1u << 2u)
 #define ZR_MOD_META (1u << 3u)
 
+/*
+  Stable key-code allocation map (ABI contract):
+    - 1..4   : basic editing/navigation keys
+    - 10..15 : insert/delete/home/end/page navigation
+    - 20..23 : arrow keys
+    - 30..31 : focus in/out pseudo-keys
+    - 100+   : function keys (F1..)
+
+  Why: Values are intentionally sparse to preserve room for future additions
+  without renumbering existing keys.
+*/
 typedef enum zr_key_t {
   ZR_KEY_UNKNOWN = 0,
 

packages/native/vendor/zireael/include/zr/zr_terminal_caps.h

@@ -13,6 +13,8 @@
 
 #include <stdint.h>
 
+#define ZR_TERMINAL_VERSION_LEN 64u
+
 typedef enum zr_terminal_id_t {
   ZR_TERM_UNKNOWN = 0,
   ZR_TERM_KITTY,
@@ -34,27 +36,51 @@ typedef enum zr_terminal_id_t {
 
 typedef uint32_t zr_terminal_cap_flags_t;
 
+/*
+  Capability bit layout (zr_terminal_cap_flags_t):
+    bits 0..9   : extended profile capabilities
+    bits 10..17 : legacy/backend caps also reflected by engine_get_caps()
+*/
+#define ZR_TERM_CAP_BIT_SIXEL 0u
+#define ZR_TERM_CAP_BIT_KITTY_GRAPHICS 1u
+#define ZR_TERM_CAP_BIT_ITERM2_IMAGES 2u
+#define ZR_TERM_CAP_BIT_UNDERLINE_STYLES 3u
+#define ZR_TERM_CAP_BIT_COLORED_UNDERLINES 4u
+#define ZR_TERM_CAP_BIT_HYPERLINKS 5u
+#define ZR_TERM_CAP_BIT_GRAPHEME_CLUSTERS 6u
+#define ZR_TERM_CAP_BIT_OVERLINE 7u
+#define ZR_TERM_CAP_BIT_PIXEL_MOUSE 8u
+#define ZR_TERM_CAP_BIT_KITTY_KEYBOARD 9u
+#define ZR_TERM_CAP_BIT_MOUSE 10u
+#define ZR_TERM_CAP_BIT_BRACKETED_PASTE 11u
+#define ZR_TERM_CAP_BIT_FOCUS_EVENTS 12u
+#define ZR_TERM_CAP_BIT_OSC52 13u
+#define ZR_TERM_CAP_BIT_SYNC_UPDATE 14u
+#define ZR_TERM_CAP_BIT_SCROLL_REGION 15u
+#define ZR_TERM_CAP_BIT_CURSOR_SHAPE 16u
+#define ZR_TERM_CAP_BIT_OUTPUT_WAIT_WRITABLE 17u
+
 /* --- Extended terminal capability flags (for profile + force/suppress overrides) --- */
-#define ZR_TERM_CAP_SIXEL ((zr_terminal_cap_flags_t)(1u << 0u))
-#define ZR_TERM_CAP_KITTY_GRAPHICS ((zr_terminal_cap_flags_t)(1u << 1u))
-#define ZR_TERM_CAP_ITERM2_IMAGES ((zr_terminal_cap_flags_t)(1u << 2u))
-#define ZR_TERM_CAP_UNDERLINE_STYLES ((zr_terminal_cap_flags_t)(1u << 3u))
-#define ZR_TERM_CAP_COLORED_UNDERLINES ((zr_terminal_cap_flags_t)(1u << 4u))
-#define ZR_TERM_CAP_HYPERLINKS ((zr_terminal_cap_flags_t)(1u << 5u))
-#define ZR_TERM_CAP_GRAPHEME_CLUSTERS ((zr_terminal_cap_flags_t)(1u << 6u))
-#define ZR_TERM_CAP_OVERLINE ((zr_terminal_cap_flags_t)(1u << 7u))
-#define ZR_TERM_CAP_PIXEL_MOUSE ((zr_terminal_cap_flags_t)(1u << 8u))
-#define ZR_TERM_CAP_KITTY_KEYBOARD ((zr_terminal_cap_flags_t)(1u << 9u))
+#define ZR_TERM_CAP_SIXEL ((zr_terminal_cap_flags_t)(1u << ZR_TERM_CAP_BIT_SIXEL))
+#define ZR_TERM_CAP_KITTY_GRAPHICS ((zr_terminal_cap_flags_t)(1u << ZR_TERM_CAP_BIT_KITTY_GRAPHICS))
+#define ZR_TERM_CAP_ITERM2_IMAGES ((zr_terminal_cap_flags_t)(1u << ZR_TERM_CAP_BIT_ITERM2_IMAGES))
+#define ZR_TERM_CAP_UNDERLINE_STYLES ((zr_terminal_cap_flags_t)(1u << ZR_TERM_CAP_BIT_UNDERLINE_STYLES))
+#define ZR_TERM_CAP_COLORED_UNDERLINES ((zr_terminal_cap_flags_t)(1u << ZR_TERM_CAP_BIT_COLORED_UNDERLINES))
+#define ZR_TERM_CAP_HYPERLINKS ((zr_terminal_cap_flags_t)(1u << ZR_TERM_CAP_BIT_HYPERLINKS))
+#define ZR_TERM_CAP_GRAPHEME_CLUSTERS ((zr_terminal_cap_flags_t)(1u << ZR_TERM_CAP_BIT_GRAPHEME_CLUSTERS))
+#define ZR_TERM_CAP_OVERLINE ((zr_terminal_cap_flags_t)(1u << ZR_TERM_CAP_BIT_OVERLINE))
+#define ZR_TERM_CAP_PIXEL_MOUSE ((zr_terminal_cap_flags_t)(1u << ZR_TERM_CAP_BIT_PIXEL_MOUSE))
+#define ZR_TERM_CAP_KITTY_KEYBOARD ((zr_terminal_cap_flags_t)(1u << ZR_TERM_CAP_BIT_KITTY_KEYBOARD))
 
 /* --- Legacy/backend caps exposed through engine_get_caps() --- */
-#define ZR_TERM_CAP_MOUSE ((zr_terminal_cap_flags_t)(1u << 10u))
-#define ZR_TERM_CAP_BRACKETED_PASTE ((zr_terminal_cap_flags_t)(1u << 11u))
-#define ZR_TERM_CAP_FOCUS_EVENTS ((zr_terminal_cap_flags_t)(1u << 12u))
-#define ZR_TERM_CAP_OSC52 ((zr_terminal_cap_flags_t)(1u << 13u))
-#define ZR_TERM_CAP_SYNC_UPDATE ((zr_terminal_cap_flags_t)(1u << 14u))
-#define ZR_TERM_CAP_SCROLL_REGION ((zr_terminal_cap_flags_t)(1u << 15u))
-#define ZR_TERM_CAP_CURSOR_SHAPE ((zr_terminal_cap_flags_t)(1u << 16u))
-#define ZR_TERM_CAP_OUTPUT_WAIT_WRITABLE ((zr_terminal_cap_flags_t)(1u << 17u))
+#define ZR_TERM_CAP_MOUSE ((zr_terminal_cap_flags_t)(1u << ZR_TERM_CAP_BIT_MOUSE))
+#define ZR_TERM_CAP_BRACKETED_PASTE ((zr_terminal_cap_flags_t)(1u << ZR_TERM_CAP_BIT_BRACKETED_PASTE))
+#define ZR_TERM_CAP_FOCUS_EVENTS ((zr_terminal_cap_flags_t)(1u << ZR_TERM_CAP_BIT_FOCUS_EVENTS))
+#define ZR_TERM_CAP_OSC52 ((zr_terminal_cap_flags_t)(1u << ZR_TERM_CAP_BIT_OSC52))
+#define ZR_TERM_CAP_SYNC_UPDATE ((zr_terminal_cap_flags_t)(1u << ZR_TERM_CAP_BIT_SYNC_UPDATE))
+#define ZR_TERM_CAP_SCROLL_REGION ((zr_terminal_cap_flags_t)(1u << ZR_TERM_CAP_BIT_SCROLL_REGION))
+#define ZR_TERM_CAP_CURSOR_SHAPE ((zr_terminal_cap_flags_t)(1u << ZR_TERM_CAP_BIT_CURSOR_SHAPE))
+#define ZR_TERM_CAP_OUTPUT_WAIT_WRITABLE ((zr_terminal_cap_flags_t)(1u << ZR_TERM_CAP_BIT_OUTPUT_WAIT_WRITABLE))
 
 #define ZR_TERM_CAP_ALL_MASK                                                                                           \
   ((zr_terminal_cap_flags_t)(ZR_TERM_CAP_SIXEL | ZR_TERM_CAP_KITTY_GRAPHICS | ZR_TERM_CAP_ITERM2_IMAGES |              \
@@ -76,7 +102,7 @@ typedef struct zr_terminal_profile_t {
   zr_terminal_id_t id;
   uint8_t _pad0[3];
 
-  char version_string[64];
+  char version_string[ZR_TERMINAL_VERSION_LEN];
 
   uint8_t supports_sixel;
   uint8_t supports_kitty_graphics;

packages/native/vendor/zireael/src/core/zr_base64.c

@@ -46,10 +46,17 @@ size_t zr_base64_encoded_size(size_t in_len, uint8_t* out_overflow) {
 }
 
 static void zr_base64_encode_triplet(const uint8_t src[3], uint8_t out[4]) {
-  out[0] = ZR_BASE64_ALPHABET[(uint8_t)(src[0] >> 2u)];
-  out[1] = ZR_BASE64_ALPHABET[(uint8_t)(((src[0] & 0x03u) << 4u) | (src[1] >> 4u))];
-  out[2] = ZR_BASE64_ALPHABET[(uint8_t)(((src[1] & 0x0Fu) << 2u) | (src[2] >> 6u))];
-  out[3] = ZR_BASE64_ALPHABET[(uint8_t)(src[2] & 0x3Fu)];
+  const uint8_t idx0 = (uint8_t)(src[0] >> 2u);
+  const uint8_t idx1_hi = (uint8_t)((src[0] & 0x03u) << 4u);
+  const uint8_t idx1_lo = (uint8_t)(src[1] >> 4u);
+  const uint8_t idx2_hi = (uint8_t)((src[1] & 0x0Fu) << 2u);
+  const uint8_t idx2_lo = (uint8_t)(src[2] >> 6u);
+  const uint8_t idx3 = (uint8_t)(src[2] & 0x3Fu);
+
+  out[0] = ZR_BASE64_ALPHABET[idx0];
+  out[1] = ZR_BASE64_ALPHABET[(uint8_t)(idx1_hi | idx1_lo)];
+  out[2] = ZR_BASE64_ALPHABET[(uint8_t)(idx2_hi | idx2_lo)];
+  out[3] = ZR_BASE64_ALPHABET[idx3];
 }
 
 /* Encode input bytes with deterministic padding behavior. */

packages/native/vendor/zireael/src/core/zr_blit.c

@@ -115,7 +115,10 @@ uint8_t zr_blit_alpha_is_opaque(uint8_t alpha) {
 }
 
 uint32_t zr_blit_pack_rgb(uint8_t r, uint8_t g, uint8_t b) {
-  return ((uint32_t)r << 16u) | ((uint32_t)g << 8u) | (uint32_t)b;
+  const uint32_t rr = ((uint32_t)r << 16u);
+  const uint32_t gg = ((uint32_t)g << 8u);
+  const uint32_t bb = (uint32_t)b;
+  return rr | gg | bb;
 }
 
 static uint8_t zr_blit_rgb_r(uint32_t rgb) {

packages/native/vendor/zireael/src/core/zr_blit_braille.c

@@ -9,6 +9,13 @@
 
 static const uint8_t ZR_BRAILLE_BIT_MAP[4][2] = {{0u, 3u}, {1u, 4u}, {2u, 5u}, {6u, 7u}};
 
+enum {
+  ZR_UTF8_3BYTE_LEAD = 0xE0u,
+  ZR_UTF8_CONT_BYTE = 0x80u,
+  ZR_UTF8_3BYTE_MASK = 0x0Fu,
+  ZR_UTF8_CONT_MASK = 0x3Fu,
+};
+
 static uint32_t zr_blit_braille_cell_bg(const zr_fb_painter_t* painter, int32_t x, int32_t y) {
   const zr_cell_t* c = zr_fb_cell_const(painter->fb, (uint32_t)x, (uint32_t)y);
   if (!c) {
@@ -19,10 +26,13 @@ static uint32_t zr_blit_braille_cell_bg(const zr_fb_painter_t* painter, int32_t
 
 static zr_blit_glyph_t zr_blit_braille_glyph(uint8_t pattern) {
   const uint32_t cp = 0x2800u + (uint32_t)pattern;
+  const uint8_t top = (uint8_t)((cp >> 12u) & ZR_UTF8_3BYTE_MASK);
+  const uint8_t mid = (uint8_t)((cp >> 6u) & ZR_UTF8_CONT_MASK);
+  const uint8_t low = (uint8_t)(cp & ZR_UTF8_CONT_MASK);
   zr_blit_glyph_t g;
-  g.bytes[0] = (uint8_t)(0xE0u | ((cp >> 12u) & 0x0Fu));
-  g.bytes[1] = (uint8_t)(0x80u | ((cp >> 6u) & 0x3Fu));
-  g.bytes[2] = (uint8_t)(0x80u | (cp & 0x3Fu));
+  g.bytes[0] = (uint8_t)(ZR_UTF8_3BYTE_LEAD | top);
+  g.bytes[1] = (uint8_t)(ZR_UTF8_CONT_BYTE | mid);
+  g.bytes[2] = (uint8_t)(ZR_UTF8_CONT_BYTE | low);
   g.bytes[3] = 0u;
   g.len = 3u;
   g._pad0[0] = 0u;

packages/native/vendor/zireael/src/core/zr_diff.c

@@ -8,6 +8,7 @@
 #include "core/zr_diff.h"
 
 #include "util/zr_checked.h"
+#include "util/zr_macros.h"
 #include "util/zr_string_builder.h"
 
 #include <stdbool.h>
@@ -93,6 +94,15 @@ static const uint8_t ZR_ANSI16_PALETTE[16][3] = {
 #define ZR_ASCII_ST_FINAL ((uint8_t)'\\')
 #define ZR_ASCII_DEL 0x7Fu
 
+/*
+  VT CSI introducer (ESC '[').
+
+  Reference: ECMA-48 / ISO-6429 control sequence syntax used by VT100/xterm.
+*/
+static bool zr_diff_write_csi(zr_sb_t* sb) {
+  return zr_sb_write_u8(sb, ZR_ASCII_ESC) && zr_sb_write_u8(sb, (uint8_t)'[');
+}
+
 /* Adaptive sweep threshold tuning (dirty-row density, percent). */
 #define ZR_DIFF_SWEEP_DIRTY_LINE_PCT_BASE 35u
 #define ZR_DIFF_SWEEP_DIRTY_LINE_PCT_WIDE_FRAME 30u
@@ -584,8 +594,7 @@ static bool zr_emit_cup(zr_sb_t* sb, zr_term_state_t* ts, uint32_t x, uint32_t y
   if (zr_term_cursor_pos_is_valid(ts) && ts->cursor_x == x && ts->cursor_y == y) {
     return true;
   }
-  const uint8_t esc = 0x1Bu;
-  if (!zr_sb_write_u8(sb, esc) || !zr_sb_write_u8(sb, (uint8_t)'[')) {
+  if (!zr_diff_write_csi(sb)) {
     return false;
   }
   if (!zr_sb_write_u32_dec(sb, y + 1u) || !zr_sb_write_u8(sb, (uint8_t)';') || !zr_sb_write_u32_dec(sb, x + 1u) ||
@@ -648,8 +657,8 @@ static bool zr_emit_cursor_shape(zr_sb_t* sb, zr_term_state_t* ts, uint8_t shape
   }
 
   const uint32_t ps = zr_cursor_shape_ps(shape, blink);
-  if (!zr_sb_write_u8(sb, 0x1Bu) || !zr_sb_write_u8(sb, (uint8_t)'[') || !zr_sb_write_u32_dec(sb, ps) ||
-      !zr_sb_write_u8(sb, (uint8_t)' ') || !zr_sb_write_u8(sb, (uint8_t)'q')) {
+  if (!zr_diff_write_csi(sb) || !zr_sb_write_u32_dec(sb, ps) || !zr_sb_write_u8(sb, (uint8_t)' ') ||
+      !zr_sb_write_u8(sb, (uint8_t)'q')) {
     return false;
   }
 
@@ -831,20 +840,20 @@ static bool zr_emit_sgr_absolute(zr_sb_t* sb, zr_term_state_t* ts, zr_style_t de
     return true;
   }
 
-  if (!zr_sb_write_u8(sb, 0x1Bu) || !zr_sb_write_u8(sb, (uint8_t)'[') || !zr_sb_write_u32_dec(sb, ZR_SGR_RESET)) {
+  if (!zr_diff_write_csi(sb) || !zr_sb_write_u32_dec(sb, ZR_SGR_RESET)) {
     return false;
   }
 
   if (!zr_emit_sgr_attr_params(sb, desired.attrs, ZR_SGR_ATTRS_PRE_UNDERLINE,
-                               sizeof(ZR_SGR_ATTRS_PRE_UNDERLINE) / sizeof(ZR_SGR_ATTRS_PRE_UNDERLINE[0]))) {
+                               ZR_ARRAYLEN(ZR_SGR_ATTRS_PRE_UNDERLINE))) {
     return false;
   }
   if ((desired.attrs & ZR_STYLE_ATTR_UNDERLINE) != 0u &&
       (!zr_sb_write_u8(sb, (uint8_t)';') || !zr_emit_sgr_underline_style_param(sb, desired, caps))) {
     return false;
   }
   if (!zr_emit_sgr_attr_params(sb, desired.attrs, ZR_SGR_ATTRS_POST_UNDERLINE,
-                               sizeof(ZR_SGR_ATTRS_POST_UNDERLINE) / sizeof(ZR_SGR_ATTRS_POST_UNDERLINE[0]))) {
+                               ZR_ARRAYLEN(ZR_SGR_ATTRS_POST_UNDERLINE))) {
     return false;
   }
   if (desired_has_underline_color &&
@@ -1320,7 +1329,7 @@ static bool zr_emit_decstbm(zr_sb_t* sb, zr_term_state_t* ts, uint32_t top, uint
   if (!sb || !ts) {
     return false;
   }
-  if (!zr_sb_write_u8(sb, 0x1Bu) || !zr_sb_write_u8(sb, (uint8_t)'[')) {
+  if (!zr_diff_write_csi(sb)) {
     return false;
   }
   if (!zr_sb_write_u32_dec(sb, top + 1u) || !zr_sb_write_u8(sb, (uint8_t)';') ||
@@ -1341,7 +1350,7 @@ static bool zr_emit_scroll_op(zr_sb_t* sb, zr_term_state_t* ts, bool up, uint32_
   if (lines == 0u) {
     return true;
   }
-  if (!zr_sb_write_u8(sb, 0x1Bu) || !zr_sb_write_u8(sb, (uint8_t)'[')) {
+  if (!zr_diff_write_csi(sb)) {
     return false;
   }
   if (!zr_sb_write_u32_dec(sb, lines) || !zr_sb_write_u8(sb, up ? (uint8_t)'S' : (uint8_t)'T')) {
@@ -1354,7 +1363,7 @@ static bool zr_emit_decstbm_reset(zr_sb_t* sb, zr_term_state_t* ts) {
   if (!sb || !ts) {
     return false;
   }
-  if (!zr_sb_write_u8(sb, 0x1Bu) || !zr_sb_write_u8(sb, (uint8_t)'[') || !zr_sb_write_u8(sb, (uint8_t)'r')) {
+  if (!zr_diff_write_csi(sb) || !zr_sb_write_u8(sb, (uint8_t)'r')) {
     return false;
   }
   ts->cursor_x = 0u;