qml: render debug log entries with a virtualized list

Replace the Flickable and Repeater output with a ListView. Qt creates
items only for visible log entries instead of creating the entire
displayed history at once.

Keep the same row and pixel offset under the user's eyes when entries
are inserted at the top, old cached entries are removed, or older
entries are loaded at the bottom. Calculate line numbers from the
current row index and leave enough room for four-digit numbers.

Add QML and functional tests for virtualization, stable scrolling, live
updates, and loading older entries.

Author: johnny9

qml/components/DebugLogOutputView.qml

@@ -132,6 +132,11 @@ Page {
                 color: Theme.color.neutral9
                 placeholderTextColor: Theme.color.neutral5
                 placeholderText: qsTr("Search...")
+                // The page is unloaded whenever another Settings section is
+                // selected, while the C++ model intentionally retains its
+                // filter. Mirror that retained value on re-entry so the field
+                // and the rows cannot disagree.
+                text: debugLogModel.filter
                 verticalAlignment: TextInput.AlignVCenter
                 selectByMouse: true
                 Accessible.name: qsTr("Search debug log")
@@ -201,11 +206,13 @@ Page {
             topPadding: 10
             accessibleName: qsTr("Debug log entries")
             autoScrollToBottom: false
-            // DebugLogModel renders newest-first at the top, so y > 0 means
-            // "scrolled away from the newest entries" — which is exactly when
-            // the "N new entries" pill should be offered.
-            onScrolled: function(y) {
-                root.userIsScrolled = (y > 0)
+            // DebugLogModel renders newest-first at the top, so leaving the
+            // beginning is exactly when the "N new entries" pill applies.
+            onScrolled: function() {
+                // A ListView's content origin is not guaranteed to be zero,
+                // particularly with variable-height rows and incremental model
+                // changes. Its boundary state is the authoritative answer.
+                root.userIsScrolled = !logView.atTop
                 if (logView.atTop && root.pendingNewLines > 0) {
                     root.pendingNewLines = 0
                 }
@@ -220,6 +227,7 @@ Page {
             Layout.preferredHeight: 36
 
             TextButton {
+                objectName: "debugLogLoadMoreButton"
                 anchors.centerIn: parent
                 text: qsTr("Load more")
                 textSize: 13

qml/pages/settings/SettingsDebugLog.qml

@@ -6,9 +6,11 @@
 
 Walks through Settings → Debug Log and verifies:
   1. The viewer page loads with a visible search bar and log list.
-  2. The log list is non-empty (entries were actually loaded).
+  2. The initial load is capped while older entries remain available.
   3. Typing in the search field filters the list; clearing it restores
      the full count.
+  4. Auto-refresh replaces the capped tail without growing it unboundedly.
+  5. The list virtualizes offscreen rows and can load older rows on demand.
 
 This test requires the binary to be built with -DENABLE_TEST_AUTOMATION=ON.
 """
@@ -22,7 +24,11 @@
 import tempfile
 
 from qml_test_harness import GUI_STARTUP_TIMEOUT, dump_qml_tree, find_gui_binary, setup_datadir
-from qml_driver import QmlDriver, QmlDriverError
+from qml_driver import QmlDriver
+
+
+INITIAL_LOAD_LIMIT = 1000
+SEEDED_HISTORY_LINES = 1200
 
 
 def assert_close(actual, expected, label, tolerance=1):
@@ -43,6 +49,19 @@ def __init__(self):
         self.process = None
         self.driver = None
         self.datadir = setup_datadir(self.tmpdir)
+        self._seed_debug_log_history()
+
+    def _seed_debug_log_history(self):
+        """Create enough history to exercise the initial cap and Load more."""
+        network_dir = os.path.join(self.datadir, "regtest")
+        os.makedirs(network_dir, exist_ok=True)
+        log_path = os.path.join(network_dir, "debug.log")
+        with open(log_path, "w", encoding="utf-8") as f:
+            for i in range(SEEDED_HISTORY_LINES):
+                f.write(
+                    "2026-01-01T00:00:00Z "
+                    f"test-automation seeded-history marker {i}\n"
+                )
 
     def start(self):
         env = dict(os.environ)
@@ -114,10 +133,15 @@ def test_viewer_visibility(gui):
 
 
 def test_log_has_entries(gui):
-    """Verify that log entries were actually loaded into the list view."""
+    """Verify that the first snapshot is capped at 1,000 rows."""
     print("\n── test_log_has_entries ──────────────────────────────────────────")
-    count = gui.get_property("debugLogListView", "count")
-    assert count > 0, f"Expected log entries to be loaded, got count={count}"
+    count = gui.wait_for_property(
+        "debugLogListView", "count", INITIAL_LOAD_LIMIT, timeout_ms=5000
+    )
+    assert count == INITIAL_LOAD_LIMIT, (
+        f"Expected the initial load to be capped at {INITIAL_LOAD_LIMIT}, "
+        f"got count={count}"
+    )
     print(f"  PASSED: debugLogListView.count = {count}")
     return count
 
@@ -130,7 +154,6 @@ def test_search_layout_matches_design(gui):
     gui.wait_for_property("debugLogSearchDivider", "height", 1, timeout_ms=3000)
     gui.wait_for_property("debugLogListView", "topPadding", 10, timeout_ms=3000)
     gui.wait_for_property("debugLogListView_row_0", "visible", True, timeout_ms=3000)
-    gui.wait_for_property("debugLogListView_row_0", "y", 10, timeout_ms=3000)
     gui.wait_for_property("debugLogListView_lineNumber_0", "visible", True, timeout_ms=3000)
     gui.wait_for_property("debugLogListView_date_0", "visible", True, timeout_ms=3000)
 
@@ -147,6 +170,13 @@ def test_search_layout_matches_design(gui):
     divider_y = gui.get_property("debugLogSearchDivider", "y")
     divider_height = gui.get_property("debugLogSearchDivider", "height")
     list_y = gui.get_property("debugLogListView", "y")
+    first_row_viewport_y = (
+        gui.get_property("debugLogListView_row_0", "y")
+        - gui.get_property("debugLogListView", "contentY")
+    )
+    effective_line_number_width = gui.get_property(
+        "debugLogListView", "effectiveLineNumberWidth"
+    )
     page_width = gui.get_property("settingsDebugLog", "width")
     content_width = gui.get_property("debugLogContentLayout", "width")
     expected_content_width = max(0, min(page_width - 40, 600))
@@ -197,20 +227,24 @@ def test_search_layout_matches_design(gui):
                  "debug log entry command/content spacing")
     assert_close(gui.get_property("debugLogListView", "lineNumberWidth"), 20,
                  "debug log line number slot width")
-    assert_close(gui.get_property("debugLogListView", "effectiveLineNumberWidth"), 20,
-                 "debug log effective line number slot width")
+    assert effective_line_number_width >= 20, (
+        "Expected the effective line-number slot to honor its 20px minimum"
+    )
     assert_close(gui.get_property("debugLogListView", "fontPixelSize"), 12,
                  "debug log entry font size")
     assert_close(gui.get_property("debugLogListView", "textLineHeight"), 17,
                  "debug log entry line height")
-    assert_close(gui.get_property("debugLogListView_row_0", "y"), 10,
-                 "first debug log row y")
+    assert_close(first_row_viewport_y, 10,
+                 "first debug log row viewport y")
     assert_close(gui.get_property("debugLogListView_row_0", "spacing"), 10,
                  "first debug log row column gap")
     assert_close(gui.get_property("debugLogListView_entryContent_0", "spacing"), 2,
                  "first debug log entry internal gap")
-    assert_close(gui.get_property("debugLogListView_lineNumber_0", "width"), 20,
-                 "first debug log line number width")
+    assert_close(
+        gui.get_property("debugLogListView_lineNumber_0", "width"),
+        effective_line_number_width,
+        "first debug log line number width",
+    )
     first_text_object = (
         "debugLogListView_message_0"
         if first_row_has_command
@@ -236,46 +270,56 @@ def test_refresh_button(gui, original_count):
 
 
 def test_auto_refresh(gui, datadir, current_count):
-    """Appending to debug.log triggers auto-refresh and grows the entry count."""
+    """Appending refreshes the capped tail without exceeding its load limit."""
     print("\n── test_auto_refresh ─────────────────────────────────────────────")
     log_path = os.path.join(datadir, "regtest", "debug.log")
     ts = datetime.datetime.now(datetime.timezone.utc).strftime("%Y-%m-%dT%H:%M:%SZ")
     marker_body = "test-automation auto-refresh marker"
     marker = f"{ts} {marker_body}"
     with open(log_path, "a", encoding="utf-8") as f:
         f.write(marker + "\n")
-    try:
-        new_count = gui.wait_for_property(
-            "debugLogListView", "count", lambda c: c > current_count, timeout_ms=5000
-        )
-    except QmlDriverError:
-        gui.click("debugLogRefreshButton")
-        new_count = gui.wait_for_property(
-            "debugLogListView", "count", lambda c: c > current_count, timeout_ms=3000
-        )
-    assert new_count > current_count, (
-        f"Expected count to grow beyond {current_count} after appending to debug.log, "
-        f"got {new_count}"
-    )
-    print(f"  PASSED: count grew from {current_count} to {new_count} after file append")
 
+    # A capped model can insert the new row and remove one old row without
+    # changing count. Filter for the unique marker to observe the actual data
+    # update rather than treating row-count growth as the refresh signal.
     gui.set_text("debugLogSearchField", marker_body)
-    gui.wait_for_property("debugLogListView", "count", lambda c: c >= 1, timeout_ms=3000)
+    gui.wait_for_property("debugLogListView", "count", 1, timeout_ms=5000)
+    gui.wait_for_property(
+        "debugLogListView_commandlessMessage_0",
+        "text",
+        marker_body,
+        timeout_ms=3000,
+    )
+
     gui.wait_for_property("debugLogListView_command_0", "visible", False, timeout_ms=3000)
     gui.wait_for_property("debugLogListView_commandlessMessage_0", "visible", True, timeout_ms=3000)
-    gui.wait_for_property("debugLogListView_commandlessMessage_0", "text", marker_body, timeout_ms=3000)
     gui.wait_for_property("debugLogListView_message_0", "visible", False, timeout_ms=3000)
+    gui.invoke("debugLogListView_commandlessMessage_0", "selectAll")
+    gui.wait_for_property(
+        "debugLogListView_commandlessMessage_0",
+        "selectedText",
+        marker_body,
+        timeout_ms=3000,
+    )
     print("  PASSED: commandless log entry renders inline with the date")
 
     gui.set_text("debugLogSearchField", "")
     restored_count = gui.wait_for_property(
-        "debugLogListView", "count", lambda c: c >= new_count, timeout_ms=3000
+        "debugLogListView", "count", current_count, timeout_ms=3000
+    )
+    assert restored_count == INITIAL_LOAD_LIMIT, (
+        f"Expected auto-refresh to retain the {INITIAL_LOAD_LIMIT}-row cap, "
+        f"got {restored_count}"
+    )
+    print(
+        f"  PASSED: appended entry loaded and count remained capped at "
+        f"{restored_count}"
     )
     return restored_count
 
 
 def test_four_digit_line_numbers_are_not_clipped(gui, datadir, current_count):
-    """Verify the line-number column expands once visible numbers reach four digits."""
+    """Verify virtualized offscreen rows and the four-digit number column."""
     print("\n── test_four_digit_line_numbers_are_not_clipped ────────────────")
     target_count = 1000
     needed = max(0, target_count - current_count)
@@ -293,20 +337,63 @@ def test_four_digit_line_numbers_are_not_clipped(gui, datadir, current_count):
         f"Expected at least {target_count} lines after append, got {count}"
     )
 
-    gui.wait_for_property(
-        "debugLogListView_lineNumber_999", "text", str(target_count), timeout_ms=3000
-    )
-    line_number_width = gui.get_property("debugLogListView_lineNumber_999", "width")
-    line_number_implicit_width = gui.get_property(
-        "debugLogListView_lineNumber_999", "implicitWidth"
+    last_index = count - 1
+    last_line_number = f"debugLogListView_lineNumber_{last_index}"
+    gui.invoke("debugLogListView", "scrollToTop")
+    gui.wait_for_property("debugLogListView", "atTop", True, timeout_ms=3000)
+    assert not gui.object_exists(last_line_number), (
+        f"Expected offscreen row {last_index} not to be instantiated at the top"
     )
+
+    gui.invoke("debugLogListView", "scrollToBottom")
+    gui.wait_for_property("debugLogListView", "atBottom", True, timeout_ms=3000)
+    gui.wait_for_property(last_line_number, "text", str(count), timeout_ms=3000)
+    line_number_width = gui.get_property(last_line_number, "width")
+    line_number_implicit_width = gui.get_property(last_line_number, "implicitWidth")
     assert line_number_width >= line_number_implicit_width, (
         f"Expected four-digit line number width {line_number_width} to fit "
         f"implicit width {line_number_implicit_width}"
     )
     assert gui.get_property("debugLogListView", "effectiveLineNumberWidth") > 20, \
         "Expected effective line-number slot to expand beyond the design minimum"
-    print("  PASSED: four-digit line numbers fit expanded line-number slot")
+    print("  PASSED: offscreen rows are virtualized and four-digit line numbers fit")
+
+
+def test_load_more_at_bottom(gui, current_count):
+    """The bottom affordance appends older rows without moving the viewport."""
+    print("\n── test_load_more_at_bottom ───────────────────────")
+    gui.invoke("debugLogListView", "scrollToBottom")
+    gui.wait_for_property("debugLogListView", "atBottom", True, timeout_ms=3000)
+    gui.wait_for_property("debugLogLoadMoreButton", "visible", True, timeout_ms=3000)
+    content_y_before = gui.get_property("debugLogListView", "contentY")
+
+    gui.click("debugLogLoadMoreButton")
+    expanded_count = gui.wait_for_property(
+        "debugLogListView", "count", lambda c: c > current_count, timeout_ms=5000
+    )
+    content_y_after = gui.get_property("debugLogListView", "contentY")
+    assert_close(
+        content_y_after,
+        content_y_before,
+        "load-more viewport anchor",
+        tolerance=2,
+    )
+    gui.wait_for_property("debugLogLoadMoreButton", "visible", False, timeout_ms=3000)
+
+    oldest_index = expanded_count - 1
+    oldest_message = f"debugLogListView_commandlessMessage_{oldest_index}"
+    gui.invoke("debugLogListView", "scrollToBottom")
+    gui.wait_for_property(
+        oldest_message,
+        "text",
+        "test-automation seeded-history marker 0",
+        timeout_ms=3000,
+    )
+    print(
+        f"  PASSED: loaded {expanded_count - current_count} older rows without "
+        "moving the viewport, including the oldest seeded row"
+    )
+    return expanded_count
 
 
 def test_close_settings(gui):
@@ -363,9 +450,10 @@ def run_tests():
         total = test_log_has_entries(gui)
         test_search_layout_matches_design(gui)
         test_search_filter(gui, total)
-        total = test_refresh_button(gui, total)
         total = test_auto_refresh(gui, harness.datadir, total)
+        total = test_refresh_button(gui, total)
         test_four_digit_line_numbers_are_not_clipped(gui, harness.datadir, total)
+        total = test_load_more_at_bottom(gui, total)
         test_close_settings(gui)
 
         print("\n" + "=" * 50)

test/functional/qml_test_debug_log.py

@@ -14,6 +14,7 @@
         <file>tst_createpassword.qml</file>
         <file>tst_createtypeselector.qml</file>
         <file>tst_createwalletwizard.qml</file>
+        <file>tst_debuglogoutputview.qml</file>
         <file>tst_desktopwallets.qml</file>
         <file>tst_displaysettings.qml</file>
         <file>tst_dropdownbutton.qml</file>