Reimplement the archived UI widget stack on the new element-tree system

The old widget system (archive/dusk/ui/) depended on infrastructure this
rewrite deleted -- a static X-macro element list, a 9-slice UI_FRAME, and
a global gamepad/keyboard focus stack -- so everything below is rebuilt
on top of the new native uielement_t pool + parent/child tree instead,
gamepad/keyboard-only (no mouse support exists in the input system).

New JS widgets (assets/scripts/), all pure composites of Label/Rectangle
following the Button.js pattern: Checkbox, Tab, Slider, Dropdown. Slider/
Dropdown expose a directionInput(dx, dy) hook so a menu can hand them
LEFT/RIGHT before falling back to cursor movement.

New Menu.js replaces the old global uifocus_t stack: a small push/pop
stack of Menu instances where only the topmost consumes CANCEL/ACCEPT/
direction input each tick (needed for nested modals -- a Settings
sub-page menu plus a "discard changes?" Confirm can be open at once).
Held-direction repeat timing matches the old 0.5s delay / 0.1s repeat.

New overlay composites (added via a new UI.addOverlay()/UI.removeOverlay(),
always drawn/updated after normal roots): FpsCounter, ConsoleOverlay
(one Label per console history line, driven directly rather than via
add() since History (16) exceeds the 8-children-per-element cap), Crop
(letterbox/pillarbox bars), and Fullbox (a reusable tweened full-screen
fade covering both the old fullbox and transition effects -- reuses
shared instances rather than allocate-and-dispose, since disposing an
element from inside its own render() callback risks the same JerryScript
refcount corruption hit earlier in this rewrite).

New Confirm.js (Yes/No dialog) and Settings.js (+ SettingsGeneral/
SettingsInput sub-pages) built on Menu. Display/Audio settings pages are
intentionally not ported -- neither had a real backing engine system
even in the old code. Frame is a flat Rectangle for now, not real 9-slice
(a genuinely bigger native lift, deliberately deferred).

Small native binding additions needed by the above, each with its own
unit test: Time.renderDelta, Console.lineCount/getLine/visible/
consumeDirty, a new Screen module, a new Locale module, Input.deadzone,
a new Save module, and Label.color (was missing entirely). Also fixes
a real gap from the UI.addOverlay() work: uiElementDispose() wasn't
removing disposed elements from the new overlay root array, which would
have left dangling ids behind.

Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>

test/script/CMakeLists.txt

@@ -13,6 +13,14 @@ dusktest(test_moduleconsole.c)
 
 dusktest(test_moduleplatform.c)
 
+dusktest(test_moduletime.c)
+
+dusktest(test_modulescreen.c)
+
+dusktest(test_modulelocale.c)
+
+dusktest(test_modulesave.c)
+
 dusktest(test_moduleinput.c)
 
 dusktest(test_scriptinput.c)

test/script/test_moduleconsole.c

@@ -8,6 +8,7 @@
 #include "dusktest.h"
 #include "console/console.h"
 #include "script/scriptmanager.h"
+#include "script/module/modulebase.h"
 #include "util/memory.h"
 
 static int console_setup(void **state) {
@@ -53,6 +54,59 @@ static void test_console_print_no_args_prints_empty_line(void **state) {
   assert_int_equal(memoryGetAllocatedCount(), 0);
 }
 
+static void test_console_line_count_is_history_max(void **state) {
+  jerry_value_t result;
+  errorret_t ret = scriptManagerExec("Console.lineCount;", &result);
+  assert_true(errorIsOk(ret));
+  assert_int_equal((int32_t)jerry_value_as_number(result), CONSOLE_HISTORY_MAX);
+  jerry_value_free(result);
+}
+
+static void test_console_get_line_reads_history(void **state) {
+  jerry_value_t result;
+  errorret_t ret = scriptManagerExec(
+    "Console.print('a line'); Console.getLine(Console.lineCount - 1);",
+    &result
+  );
+  assert_true(errorIsOk(ret));
+
+  char_t buf[32];
+  moduleBaseToString(result, buf, sizeof(buf));
+  assert_string_equal(buf, "a line");
+  jerry_value_free(result);
+}
+
+static void test_console_get_line_out_of_range_throws(void **state) {
+  errorret_t ret = scriptManagerExec("Console.getLine(999);", NULL);
+  assert_true(errorIsNotOk(ret));
+  errorCatch(ret);
+}
+
+static void test_console_visible_defaults_false(void **state) {
+  jerry_value_t result;
+  errorret_t ret = scriptManagerExec("Console.visible;", &result);
+  assert_true(errorIsOk(ret));
+  assert_false(jerry_value_is_true(result));
+  jerry_value_free(result);
+}
+
+static void test_console_consume_dirty_clears_flag(void **state) {
+  CONSOLE.dirty = true;
+
+  jerry_value_t result;
+  errorret_t ret = scriptManagerExec("Console.consumeDirty();", &result);
+  assert_true(errorIsOk(ret));
+  assert_true(jerry_value_is_true(result));
+  jerry_value_free(result);
+
+  assert_false(CONSOLE.dirty);
+
+  ret = scriptManagerExec("Console.consumeDirty();", &result);
+  assert_true(errorIsOk(ret));
+  assert_false(jerry_value_is_true(result));
+  jerry_value_free(result);
+}
+
 int main(void) {
   assertInit();
   const struct CMUnitTest tests[] = {
@@ -64,6 +118,22 @@ int main(void) {
       test_console_print_no_args_prints_empty_line,
       console_setup, console_teardown
     ),
+    cmocka_unit_test_setup_teardown(
+      test_console_line_count_is_history_max, console_setup, console_teardown
+    ),
+    cmocka_unit_test_setup_teardown(
+      test_console_get_line_reads_history, console_setup, console_teardown
+    ),
+    cmocka_unit_test_setup_teardown(
+      test_console_get_line_out_of_range_throws,
+      console_setup, console_teardown
+    ),
+    cmocka_unit_test_setup_teardown(
+      test_console_visible_defaults_false, console_setup, console_teardown
+    ),
+    cmocka_unit_test_setup_teardown(
+      test_console_consume_dirty_clears_flag, console_setup, console_teardown
+    ),
   };
   return cmocka_run_group_tests(tests, NULL, NULL);
 }

test/script/test_moduleinput.c

@@ -122,12 +122,29 @@ static void test_input_query_functions_default_to_zero(void **state) {
   jerry_value_free(result);
 }
 
+static void test_input_deadzone_readback(void **state) {
+  jerry_value_t result;
+  errorret_t ret = scriptManagerExec("Input.deadzone = 0.25;", &result);
+  assert_true(errorIsOk(ret));
+  jerry_value_free(result);
+
+  assert_float_equal(INPUT.deadzone, 0.25f, 0.0001f);
+
+  ret = scriptManagerExec("Input.deadzone;", &result);
+  assert_true(errorIsOk(ret));
+  assert_float_equal((float_t)jerry_value_as_number(result), 0.25f, 0.0001f);
+  jerry_value_free(result);
+}
+
 int main(void) {
   assertInit();
   const struct CMUnitTest tests[] = {
     cmocka_unit_test_setup_teardown(
       test_inputbind_exposes_action_ordinals, input_setup, input_teardown
     ),
+    cmocka_unit_test_setup_teardown(
+      test_input_deadzone_readback, input_setup, input_teardown
+    ),
     cmocka_unit_test_setup_teardown(
       test_inputbutton_exposes_platform_button_names,
       input_setup, input_teardown

test/script/test_modulelocale.c

@@ -0,0 +1,70 @@
+/**
+ * Copyright (c) 2026 Dominic Masters
+ *
+ * This software is released under the MIT License.
+ * https://opensource.org/licenses/MIT
+ */
+
+#include "dusktest.h"
+#include "script/scriptmanager.h"
+#include "locale/localemanager.h"
+
+static int locale_setup(void **state) {
+  errorret_t ret = scriptManagerInit();
+  if(errorIsNotOk(ret)) { errorCatch(ret); return -1; }
+  return 0;
+}
+
+static int locale_teardown(void **state) {
+  errorret_t ret = scriptManagerDispose();
+  if(errorIsNotOk(ret)) errorCatch(ret);
+  return 0;
+}
+
+// Only the binding shape is covered here -- localeManagerInit() was never
+// called (LOCALE.locale stays NULL, as a fresh process leaves it), and an
+// actual successful Locale.set() requires the real asset pipeline (a
+// mounted locale/*.po file) which the main Dusk binary's headless run
+// exercises instead; a plain module test isn't the place to stand up the
+// full asset system just for this.
+
+static void test_locale_current_defaults_to_empty_string(void **state) {
+  jerry_value_t result;
+  errorret_t ret = scriptManagerExec("Locale.current;", &result);
+  assert_true(errorIsOk(ret));
+
+  char_t buf[8];
+  jerry_string_to_buffer(
+    result, JERRY_ENCODING_UTF8, (jerry_char_t *)buf, sizeof(buf) - 1
+  );
+  jerry_value_free(result);
+}
+
+static void test_locale_set_unknown_name_throws(void **state) {
+  errorret_t ret = scriptManagerExec("Locale.set('xx-XX');", NULL);
+  assert_true(errorIsNotOk(ret));
+  errorCatch(ret);
+}
+
+static void test_locale_set_requires_a_string(void **state) {
+  errorret_t ret = scriptManagerExec("Locale.set(42);", NULL);
+  assert_true(errorIsNotOk(ret));
+  errorCatch(ret);
+}
+
+int main(void) {
+  assertInit();
+  const struct CMUnitTest tests[] = {
+    cmocka_unit_test_setup_teardown(
+      test_locale_current_defaults_to_empty_string,
+      locale_setup, locale_teardown
+    ),
+    cmocka_unit_test_setup_teardown(
+      test_locale_set_unknown_name_throws, locale_setup, locale_teardown
+    ),
+    cmocka_unit_test_setup_teardown(
+      test_locale_set_requires_a_string, locale_setup, locale_teardown
+    ),
+  };
+  return cmocka_run_group_tests(tests, NULL, NULL);
+}

test/script/test_modulesave.c

@@ -0,0 +1,59 @@
+/**
+ * Copyright (c) 2026 Dominic Masters
+ *
+ * This software is released under the MIT License.
+ * https://opensource.org/licenses/MIT
+ */
+
+#include "dusktest.h"
+#include "script/scriptmanager.h"
+#include "save/save.h"
+#include "save/savesettings.h"
+#include "input/input.h"
+
+static int save_setup(void **state) {
+  // Writes under ./saves relative to this test binary's own working
+  // directory (SAVE_LINUX_PATH's default) -- a build artifact, not real
+  // user save data.
+  errorret_t ret = saveInit();
+  if(errorIsNotOk(ret)) { errorCatch(ret); return -1; }
+
+  ret = scriptManagerInit();
+  if(errorIsNotOk(ret)) { errorCatch(ret); return -1; }
+
+  return 0;
+}
+
+static int save_teardown(void **state) {
+  errorret_t ret = scriptManagerDispose();
+  if(errorIsNotOk(ret)) errorCatch(ret);
+
+  ret = saveDispose();
+  if(errorIsNotOk(ret)) errorCatch(ret);
+
+  return 0;
+}
+
+static void test_save_write_persists_settings(void **state) {
+  INPUT.deadzone = 0.42f;
+
+  jerry_value_t result;
+  errorret_t ret = scriptManagerExec("Save.write();", &result);
+  assert_true(errorIsOk(ret));
+  jerry_value_free(result);
+
+  INPUT.deadzone = 0.0f;
+  ret = saveSettingsLoad();
+  assert_true(errorIsOk(ret));
+  assert_float_equal(INPUT.deadzone, 0.42f, 0.0001f);
+}
+
+int main(void) {
+  assertInit();
+  const struct CMUnitTest tests[] = {
+    cmocka_unit_test_setup_teardown(
+      test_save_write_persists_settings, save_setup, save_teardown
+    ),
+  };
+  return cmocka_run_group_tests(tests, NULL, NULL);
+}

test/script/test_modulescreen.c

@@ -0,0 +1,73 @@
+/**
+ * Copyright (c) 2026 Dominic Masters
+ *
+ * This software is released under the MIT License.
+ * https://opensource.org/licenses/MIT
+ */
+
+#include "dusktest.h"
+#include "script/scriptmanager.h"
+#include "display/screen/screen.h"
+
+static int screen_setup(void **state) {
+  errorret_t ret = scriptManagerInit();
+  if(errorIsNotOk(ret)) { errorCatch(ret); return -1; }
+  return 0;
+}
+
+static int screen_teardown(void **state) {
+  errorret_t ret = scriptManagerDispose();
+  if(errorIsNotOk(ret)) errorCatch(ret);
+  return 0;
+}
+
+static void test_screen_dimensions_readback(void **state) {
+  SCREEN.width = 640;
+  SCREEN.height = 480;
+  SCREEN.scanX = 10;
+  SCREEN.scanY = 20;
+  SCREEN.scanWidth = 600;
+  SCREEN.scanHeight = 440;
+
+  jerry_value_t result;
+
+  errorret_t ret = scriptManagerExec("Screen.width;", &result);
+  assert_true(errorIsOk(ret));
+  assert_int_equal((int32_t)jerry_value_as_number(result), 640);
+  jerry_value_free(result);
+
+  ret = scriptManagerExec("Screen.height;", &result);
+  assert_true(errorIsOk(ret));
+  assert_int_equal((int32_t)jerry_value_as_number(result), 480);
+  jerry_value_free(result);
+
+  ret = scriptManagerExec("Screen.scanX;", &result);
+  assert_true(errorIsOk(ret));
+  assert_int_equal((int32_t)jerry_value_as_number(result), 10);
+  jerry_value_free(result);
+
+  ret = scriptManagerExec("Screen.scanY;", &result);
+  assert_true(errorIsOk(ret));
+  assert_int_equal((int32_t)jerry_value_as_number(result), 20);
+  jerry_value_free(result);
+
+  ret = scriptManagerExec("Screen.scanWidth;", &result);
+  assert_true(errorIsOk(ret));
+  assert_int_equal((int32_t)jerry_value_as_number(result), 600);
+  jerry_value_free(result);
+
+  ret = scriptManagerExec("Screen.scanHeight;", &result);
+  assert_true(errorIsOk(ret));
+  assert_int_equal((int32_t)jerry_value_as_number(result), 440);
+  jerry_value_free(result);
+}
+
+int main(void) {
+  assertInit();
+  const struct CMUnitTest tests[] = {
+    cmocka_unit_test_setup_teardown(
+      test_screen_dimensions_readback, screen_setup, screen_teardown
+    ),
+  };
+  return cmocka_run_group_tests(tests, NULL, NULL);
+}

test/script/test_moduletime.c

@@ -0,0 +1,71 @@
+/**
+ * Copyright (c) 2026 Dominic Masters
+ *
+ * This software is released under the MIT License.
+ * https://opensource.org/licenses/MIT
+ */
+
+#include "dusktest.h"
+#include "script/scriptmanager.h"
+#include "time/time.h"
+
+static int time_setup(void **state) {
+  errorret_t ret = scriptManagerInit();
+  if(errorIsNotOk(ret)) { errorCatch(ret); return -1; }
+  return 0;
+}
+
+static int time_teardown(void **state) {
+  errorret_t ret = scriptManagerDispose();
+  if(errorIsNotOk(ret)) errorCatch(ret);
+  return 0;
+}
+
+static void test_time_delta_and_time_readback(void **state) {
+  TIME.delta = 0.5f;
+  TIME.time = 12.0f;
+
+  jerry_value_t result;
+  errorret_t ret = scriptManagerExec("Time.delta;", &result);
+  assert_true(errorIsOk(ret));
+  assert_float_equal((float_t)jerry_value_as_number(result), 0.5f, 0.0001f);
+  jerry_value_free(result);
+
+  ret = scriptManagerExec("Time.time;", &result);
+  assert_true(errorIsOk(ret));
+  assert_float_equal((float_t)jerry_value_as_number(result), 12.0f, 0.0001f);
+  jerry_value_free(result);
+}
+
+static void test_time_render_delta_readback(void **state) {
+  // Under DUSK_TIME_DYNAMIC, renderDelta reads dynamicDelta (real
+  // per-render-frame time); otherwise it falls back to the fixed delta.
+  // Set both so this test passes either way this binary was built.
+  TIME.delta = 0.25f;
+  #ifdef DUSK_TIME_DYNAMIC
+    TIME.dynamicDelta = 0.75f;
+  #endif
+
+  jerry_value_t result;
+  errorret_t ret = scriptManagerExec("Time.renderDelta;", &result);
+  assert_true(errorIsOk(ret));
+  #ifdef DUSK_TIME_DYNAMIC
+    assert_float_equal((float_t)jerry_value_as_number(result), 0.75f, 0.0001f);
+  #else
+    assert_float_equal((float_t)jerry_value_as_number(result), 0.25f, 0.0001f);
+  #endif
+  jerry_value_free(result);
+}
+
+int main(void) {
+  assertInit();
+  const struct CMUnitTest tests[] = {
+    cmocka_unit_test_setup_teardown(
+      test_time_delta_and_time_readback, time_setup, time_teardown
+    ),
+    cmocka_unit_test_setup_teardown(
+      test_time_render_delta_readback, time_setup, time_teardown
+    ),
+  };
+  return cmocka_run_group_tests(tests, NULL, NULL);
+}

test/script/test_moduleui.c

@@ -17,6 +17,9 @@ static int ui_setup(void **state) {
   memoryZero(UI_ELEMENTS, sizeof(UI_ELEMENTS));
   memoryZero(&UI, sizeof(UI));
   for(uint8_t i = 0; i < UI_ROOT_MAX; i++) UI.root[i] = UI_ELEMENT_ID_INVALID;
+  for(uint8_t i = 0; i < UI_OVERLAY_ROOT_MAX; i++) {
+    UI.overlayRoot[i] = UI_ELEMENT_ID_INVALID;
+  }
 
   errorret_t ret = scriptManagerInit();
   if(errorIsNotOk(ret)) { errorCatch(ret); return -1; }
@@ -32,6 +35,17 @@ static int ui_teardown(void **state) {
   return 0;
 }
 
+static void exec(const char_t *script) {
+  jerry_value_t result;
+  errorret_t ret = scriptManagerExec(script, &result);
+  if(errorIsNotOk(ret)) {
+    errorCatch(errorPrint(ret));
+    fail_msg("Script execution failed (see printed error above)");
+  }
+  assert_true(errorIsOk(ret));
+  jerry_value_free(result);
+}
+
 static void test_ui_add_requires_an_argument(void **state) {
   errorret_t ret = scriptManagerExec("UI.add();", NULL);
   assert_true(errorIsNotOk(ret));
@@ -65,6 +79,64 @@ static void test_ui_remove_of_untracked_element_is_a_noop(void **state) {
   jerry_value_free(result);
 }
 
+static void test_ui_add_overlay_and_remove_overlay(void **state) {
+  assert_true(UI.overlayRoot[0] == UI_ELEMENT_ID_INVALID);
+
+  exec(
+    "globalThis.el = new UIElement();"
+    "el.x = 3;"
+    "UI.addOverlay(el);"
+  );
+
+  assert_true(UI.overlayRoot[0] != UI_ELEMENT_ID_INVALID);
+  assert_true(UI_ELEMENTS[UI.overlayRoot[0]].type == UI_ELEMENT_TYPE_SCRIPTED);
+  assert_float_equal(UI_ELEMENTS[UI.overlayRoot[0]].x, 3.0f, 0.001f);
+
+  exec("UI.removeOverlay(el);");
+
+  assert_true(UI.overlayRoot[0] == UI_ELEMENT_ID_INVALID);
+}
+
+static void test_ui_add_overlay_detaches_from_parent(void **state) {
+  exec(
+    "globalThis.parent = new UIElement();"
+    "globalThis.child = new UIElement();"
+    "parent.add(child);"
+    "if(parent.childCount !== 1) throw new Error('expected 1 child');"
+    "UI.addOverlay(child);"
+    "if(parent.childCount !== 0) {"
+    "  throw new Error('expected 0 children after UI.addOverlay');"
+    "}"
+    "if(child.parent !== undefined) throw new Error('child.parent should be undefined');"
+  );
+}
+
+static void test_ui_dispose_removes_overlay_root(void **state) {
+  exec(
+    "globalThis.el = new UIElement();"
+    "UI.addOverlay(el);"
+  );
+  assert_true(UI.overlayRoot[0] != UI_ELEMENT_ID_INVALID);
+
+  exec("el.dispose();");
+  assert_true(UI.overlayRoot[0] == UI_ELEMENT_ID_INVALID);
+}
+
+static void test_ui_overlay_root_is_independent_of_root(void **state) {
+  // A normal root and an overlay root are two separate arrays -- adding
+  // to one must never touch the other.
+  exec(
+    "globalThis.a = new UIElement();"
+    "globalThis.b = new UIElement();"
+    "UI.add(a);"
+    "UI.addOverlay(b);"
+  );
+
+  assert_true(UI.root[0] != UI_ELEMENT_ID_INVALID);
+  assert_true(UI.overlayRoot[0] != UI_ELEMENT_ID_INVALID);
+  assert_true(UI.root[0] != UI.overlayRoot[0]);
+}
+
 int main(void) {
   assertInit();
   const struct CMUnitTest tests[] = {
@@ -80,6 +152,18 @@ int main(void) {
     cmocka_unit_test_setup_teardown(
       test_ui_remove_of_untracked_element_is_a_noop, ui_setup, ui_teardown
     ),
+    cmocka_unit_test_setup_teardown(
+      test_ui_add_overlay_and_remove_overlay, ui_setup, ui_teardown
+    ),
+    cmocka_unit_test_setup_teardown(
+      test_ui_add_overlay_detaches_from_parent, ui_setup, ui_teardown
+    ),
+    cmocka_unit_test_setup_teardown(
+      test_ui_dispose_removes_overlay_root, ui_setup, ui_teardown
+    ),
+    cmocka_unit_test_setup_teardown(
+      test_ui_overlay_root_is_independent_of_root, ui_setup, ui_teardown
+    ),
   };
   return cmocka_run_group_tests(tests, NULL, NULL);
 }

test/script/test_moduleuielement.c

@@ -173,6 +173,96 @@ static void test_uielement_render_children_explicit_opt_in(void **state) {
   );
 }
 
+static void test_uielement_update_no_override_is_noop_when_childless(
+  void **state
+) {
+  // No override, no children -- update() should just do nothing, safely.
+  exec("new UIElement().update();");
+}
+
+static void test_uielement_update_dispatches_to_js_override(void **state) {
+  exec(
+    "class Foo extends UIElement {"
+    "  update() { this.updated = true; }"
+    "}"
+    "var foo = new Foo();"
+    "foo.update();"
+    "if(foo.updated !== true) throw new Error('update() override not called');"
+  );
+}
+
+static void test_uielement_no_override_auto_updates_children(void **state) {
+  exec(
+    "class Child extends UIElement {"
+    "  update() { this.updated = true; }"
+    "}"
+    "var parent = new UIElement();"
+    "var child = new Child();"
+    "parent.add(child);"
+    "parent.update();"
+    "if(child.updated !== true) throw new Error('child was not auto-updated');"
+  );
+}
+
+static void test_uielement_override_does_not_auto_update_children(
+  void **state
+) {
+  exec(
+    "class Child extends UIElement {"
+    "  update() { this.updated = true; }"
+    "}"
+    "class Parent extends UIElement {"
+    "  update() { this.overrideCalled = true; }"
+    "}"
+    "var parent = new Parent();"
+    "var child = new Child();"
+    "parent.add(child);"
+    "parent.update();"
+    "if(parent.overrideCalled !== true) throw new Error('override not called');"
+    "if(child.updated === true) {"
+    "  throw new Error('child should not auto-update under an override');"
+    "}"
+  );
+}
+
+static void test_uielement_update_children_explicit_opt_in(void **state) {
+  exec(
+    "class Child extends UIElement {"
+    "  update() { this.updated = true; }"
+    "}"
+    "class Parent extends UIElement {"
+    "  update() { this.updateChildren(); }"
+    "}"
+    "var parent = new Parent();"
+    "var child = new Child();"
+    "parent.add(child);"
+    "parent.update();"
+    "if(child.updated !== true) throw new Error('updateChildren() did not update child');"
+  );
+}
+
+static void test_ui_update_reaches_root_and_children(void **state) {
+  exec(
+    "globalThis.parent = new UIElement();"
+    "globalThis.child = new UIElement();"
+    "class Grandchild extends UIElement {"
+    "  update() { this.updated = true; }"
+    "}"
+    "globalThis.grandchild = new Grandchild();"
+    "parent.add(child);"
+    "child.add(grandchild);"
+    "UI.add(parent);"
+  );
+
+  errorCatch(errorPrint(uiUpdate()));
+
+  exec(
+    "if(grandchild.updated !== true) {"
+    "  throw new Error('uiUpdate() did not reach a rooted grandchild');"
+    "}"
+  );
+}
+
 static void test_uielement_add_self_throws(void **state) {
   execExpectError("var el = new UIElement(); el.add(el);");
 }
@@ -252,6 +342,17 @@ static void test_label_text_default_and_set(void **state) {
   );
 }
 
+static void test_label_color_readback(void **state) {
+  exec(
+    "var label = new Label();"
+    "label.color = { r: 10, g: 20, b: 30, a: 40 };"
+    "if(label.color.r !== 10 || label.color.g !== 20 ||"
+    "   label.color.b !== 30 || label.color.a !== 40) {"
+    "  throw new Error('color readback wrong');"
+    "}"
+  );
+}
+
 static void test_rectangle_size_and_color(void **state) {
   exec(
     "var rect = new Rectangle();"
@@ -332,6 +433,30 @@ int main(void) {
       test_uielement_render_children_explicit_opt_in,
       uielement_setup, uielement_teardown
     ),
+    cmocka_unit_test_setup_teardown(
+      test_uielement_update_no_override_is_noop_when_childless,
+      uielement_setup, uielement_teardown
+    ),
+    cmocka_unit_test_setup_teardown(
+      test_uielement_update_dispatches_to_js_override,
+      uielement_setup, uielement_teardown
+    ),
+    cmocka_unit_test_setup_teardown(
+      test_uielement_no_override_auto_updates_children,
+      uielement_setup, uielement_teardown
+    ),
+    cmocka_unit_test_setup_teardown(
+      test_uielement_override_does_not_auto_update_children,
+      uielement_setup, uielement_teardown
+    ),
+    cmocka_unit_test_setup_teardown(
+      test_uielement_update_children_explicit_opt_in,
+      uielement_setup, uielement_teardown
+    ),
+    cmocka_unit_test_setup_teardown(
+      test_ui_update_reaches_root_and_children,
+      uielement_setup, uielement_teardown
+    ),
     cmocka_unit_test_setup_teardown(
       test_uielement_add_self_throws, uielement_setup, uielement_teardown
     ),
@@ -355,6 +480,9 @@ int main(void) {
     cmocka_unit_test_setup_teardown(
       test_label_text_default_and_set, uielement_setup, uielement_teardown
     ),
+    cmocka_unit_test_setup_teardown(
+      test_label_color_readback, uielement_setup, uielement_teardown
+    ),
     cmocka_unit_test_setup_teardown(
       test_rectangle_size_and_color, uielement_setup, uielement_teardown
     ),