From 483f87cfbd6dd455aee47497a9b6fc496af1888b Mon Sep 17 00:00:00 2001
From: IChooseYou <IChooseYou@users.noreply.github.com>
Date: Mon, 9 Mar 2026 10:39:22 -0600
Subject: [PATCH] feat: type hints green [bracketed] notation, workspace
 cleanup, unique naming
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

- Type inference hints now show value-first with bracketed type in comment
  green: "0x7ff718570000 [ptr64]", "6, 16 [int32_t×2]"
- Raise hint threshold to strong-only (score >= 75%)
- Remove Bool inference, widen Int16 range to ±16384
- Workspace: remove dead WorkspaceProxy, fix null deref, debounce search,
  cache icons, add pinning support
- Unique naming: UnnamedClass0/UnnamedEnum1 with global counter
- Footer buttons: +10h +100h +1000h replacing +1024
- MCP: project lifecycle API, snapshot provider fix
---
 CMakeLists.txt                    |   28 -
 src/compose.cpp                   |    9 +-
 src/controller.cpp                |    9 +-
 src/core.h                        |   14 +-
 src/editor.cpp                    |   24 +-
 src/format.cpp                    |    4 +-
 src/imports/import_source.cpp     |   22 +-
 src/main.cpp                      |  116 ++-
 src/mainwindow.h                  |    9 +
 src/mcp/mcp_bridge.cpp            |   99 ++-
 src/mcp/mcp_bridge.h              |    7 +-
 src/providers/snapshot_provider.h |    1 +
 src/scannerpanel.cpp              |    2 +-
 src/typeinfer.h                   |    9 +-
 src/workspace_model.h             |   59 +-
 tests/test_controller.cpp         |    1 +
 tests/test_editor.cpp             |    6 +
 tests/test_new_features.cpp       |  807 ---------------------
 tests/test_typeinfer.cpp          |   24 +-
 tests/test_validation.cpp         | 1129 -----------------------------
 20 files changed, 310 insertions(+), 2069 deletions(-)
 delete mode 100644 tests/test_new_features.cpp
 delete mode 100644 tests/test_validation.cpp

diff --git a/CMakeLists.txt b/CMakeLists.txt
index 3f27c0e..1131a4c 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -428,20 +428,6 @@ if(BUILD_TESTING)
         endif()
         add_test(NAME test_controller COMMAND test_controller)
 
-        add_executable(test_validation tests/test_validation.cpp
-        src/editor.cpp src/compose.cpp src/format.cpp src/addressparser.cpp src/controller.cpp
-        src/processpicker.cpp src/processpicker.ui src/providerregistry.cpp
-        src/typeselectorpopup.cpp
-        src/themes/theme.cpp src/themes/thememanager.cpp ${DISASM_SRCS})
-        target_include_directories(test_validation PRIVATE src third_party/fadec)
-        target_link_libraries(test_validation PRIVATE
-        ${QT}::Widgets ${QT}::PrintSupport ${QT}::Concurrent ${QT}::Test
-        QScintilla::QScintilla)
-        if(WIN32)
-            target_link_libraries(test_validation PRIVATE dbghelp psapi ${_QT_WINEXTRAS})
-        endif()
-        add_test(NAME test_validation COMMAND test_validation)
-
         add_executable(test_context_menu tests/test_context_menu.cpp
         src/editor.cpp src/compose.cpp src/format.cpp src/addressparser.cpp src/controller.cpp
         src/processpicker.cpp src/processpicker.ui src/providerregistry.cpp
@@ -488,20 +474,6 @@ if(BUILD_TESTING)
         QScintilla::QScintilla)
         add_test(NAME test_rendered_view COMMAND test_rendered_view)
 
-        add_executable(test_new_features tests/test_new_features.cpp
-        src/generator.cpp src/compose.cpp src/format.cpp src/addressparser.cpp src/controller.cpp
-        src/editor.cpp src/processpicker.cpp src/processpicker.ui src/providerregistry.cpp
-        src/typeselectorpopup.cpp
-        src/themes/theme.cpp src/themes/thememanager.cpp ${DISASM_SRCS})
-        target_include_directories(test_new_features PRIVATE src third_party/fadec)
-        target_link_libraries(test_new_features PRIVATE
-        ${QT}::Widgets ${QT}::PrintSupport ${QT}::Concurrent ${QT}::Test
-        QScintilla::QScintilla)
-        if(WIN32)
-            target_link_libraries(test_new_features PRIVATE dbghelp psapi ${_QT_WINEXTRAS})
-        endif()
-        add_test(NAME test_new_features COMMAND test_new_features)
-
         add_executable(test_type_selector tests/test_type_selector.cpp
         src/editor.cpp src/compose.cpp src/format.cpp src/addressparser.cpp src/controller.cpp
         src/processpicker.cpp src/processpicker.ui src/providerregistry.cpp
diff --git a/src/compose.cpp b/src/compose.cpp
index a20fa66..b274114 100644
--- a/src/compose.cpp
+++ b/src/compose.cpp
@@ -261,14 +261,17 @@ void composeLeaf(ComposeState& state, const NodeTree& tree,
                 ? prov.readBytes(absAddr, sz) : QByteArray(sz, '\0');
             auto suggestions = inferTypes(
                 reinterpret_cast<const uint8_t*>(b.constData()), sz);
-            if (!suggestions.isEmpty() && suggestions[0].strength >= 2) {
+            if (!suggestions.isEmpty() && suggestions[0].strength >= 3) {
                 lm.typeHintStart = lineText.size() + 2; // after "  " gap
                 lm.typeHintKinds = suggestions[0].kinds;
-                lm.typeHint = formatHint(suggestions[0]);
+                QString typeName = formatHint(suggestions[0]);
                 QString preview = formatPreview(
                     reinterpret_cast<const uint8_t*>(b.constData()), sz, suggestions[0]);
+                // Value-first with bracketed type: "0x7ff718570000 [ptr64]"
                 if (!preview.isEmpty())
-                    lm.typeHint += QStringLiteral("  ") + preview;
+                    lm.typeHint = preview + QStringLiteral(" [") + typeName + QStringLiteral("]");
+                else
+                    lm.typeHint = QStringLiteral("[") + typeName + QStringLiteral("]");
                 lineText += QStringLiteral("  ") + lm.typeHint;
             }
         }
diff --git a/src/controller.cpp b/src/controller.cpp
index c10c566..4aa62ec 100644
--- a/src/controller.cpp
+++ b/src/controller.cpp
@@ -190,9 +190,10 @@ RcxEditor* RcxController::addSplitEditor(QWidget* parent) {
 
     // Eagerly pre-warm the type popup so first click isn't slow (~350ms cold start).
     if (!m_cachedPopup) {
-        QTimer::singleShot(0, this, [this, editor]() {
-            if (!m_cachedPopup && !m_editors.isEmpty())
-                ensurePopup(editor);
+        QPointer<RcxEditor> safeEditor = editor;
+        QTimer::singleShot(0, this, [this, safeEditor]() {
+            if (!m_cachedPopup && !m_editors.isEmpty() && safeEditor)
+                ensurePopup(safeEditor);
         });
     }
     return editor;
@@ -200,7 +201,7 @@ RcxEditor* RcxController::addSplitEditor(QWidget* parent) {
 
 void RcxController::removeSplitEditor(RcxEditor* editor) {
     m_editors.removeOne(editor);
-    // Caller (MainWindow) owns the parent QTabWidget and handles widget destruction.
+    editor->disconnect(this);
 }
 
 void RcxController::connectEditor(RcxEditor* editor) {
diff --git a/src/core.h b/src/core.h
index e07718c..09e84e9 100644
--- a/src/core.h
+++ b/src/core.h
@@ -570,13 +570,13 @@ static constexpr int      kCommandRowLine = 0;
 static constexpr int      kFirstDataLine  = 1;
 static constexpr uint64_t kFooterIdBit    = 0x8000000000000000ULL;
 static constexpr uint64_t kArrayElemBit   = 0x4000000000000000ULL;  // marks array element selection
-static constexpr uint64_t kArrayElemShift = 48;                     // bits 48-61 hold element index
-static constexpr uint64_t kArrayElemMask  = 0x3FFF000000000000ULL;  // 14 bits → max 16383 elements
+static constexpr uint64_t kArrayElemShift = 42;                     // bits 42-61 hold element index
+static constexpr uint64_t kArrayElemMask  = 0x3FFFFC0000000000ULL;  // 20 bits → max 1048575 elements
 
-// Encode an array element selection ID: nodeId | kArrayElemBit | (elemIdx << 48)
+// Encode an array element selection ID: nodeId | kArrayElemBit | (elemIdx << 42)
 inline uint64_t makeArrayElemSelId(uint64_t nodeId, int elemIdx) {
     Q_ASSERT(elemIdx >= 0);
-    return nodeId | kArrayElemBit | ((uint64_t)(elemIdx & 0x3FFF) << kArrayElemShift);
+    return nodeId | kArrayElemBit | ((uint64_t)(elemIdx & 0xFFFFF) << kArrayElemShift);
 }
 inline int arrayElemIdxFromSelId(uint64_t selId) {
     return (int)((selId & kArrayElemMask) >> kArrayElemShift);
@@ -584,11 +584,11 @@ inline int arrayElemIdxFromSelId(uint64_t selId) {
 
 // Member selection encoding (enum/bitfield members) — mirrors array element pattern
 static constexpr uint64_t kMemberBit      = 0x2000000000000000ULL;
-static constexpr uint64_t kMemberSubShift = 48;
-static constexpr uint64_t kMemberSubMask  = 0x3FFF000000000000ULL;
+static constexpr uint64_t kMemberSubShift = 42;
+static constexpr uint64_t kMemberSubMask  = 0x3FFFFC0000000000ULL;
 
 inline uint64_t makeMemberSelId(uint64_t nodeId, int subLine) {
-    return nodeId | kMemberBit | ((uint64_t)(subLine & 0x3FFF) << kMemberSubShift);
+    return nodeId | kMemberBit | ((uint64_t)(subLine & 0xFFFFF) << kMemberSubShift);
 }
 inline int memberSubFromSelId(uint64_t selId) {
     return (int)((selId & kMemberSubMask) >> kMemberSubShift);
diff --git a/src/editor.cpp b/src/editor.cpp
index d1df368..2b313d1 100644
--- a/src/editor.cpp
+++ b/src/editor.cpp
@@ -762,7 +762,7 @@ void RcxEditor::applyTheme(const Theme& theme) {
     m_sci->SendScintilla(QsciScintillaBase::SCI_INDICSETFORE,
                          IND_LOCAL_OFF, theme.textFaint);
     m_sci->SendScintilla(QsciScintillaBase::SCI_INDICSETFORE,
-                         IND_TYPE_HINT, theme.textFaint);
+                         IND_TYPE_HINT, theme.indHintGreen);
     m_sci->SendScintilla(QsciScintillaBase::SCI_INDICSETFORE,
                          IND_FIND, theme.borderFocused);
 
@@ -905,7 +905,9 @@ void RcxEditor::applyDocument(const ComposeResult& result) {
         const auto& lm = result.meta[i];
         if (lm.heatLevel > 0 || isFuncPtr(lm.nodeKind) ||
             lm.nodeKind == NodeKind::Pointer32 ||
-            lm.nodeKind == NodeKind::Pointer64)
+            lm.nodeKind == NodeKind::Pointer64 ||
+            lm.lineKind == LineKind::Footer ||
+            lm.typeHintStart >= 0)
             lineTexts[i] = getLineText(m_sci, i);
     }
     applyHeatmapHighlight(result.meta, lineTexts);
@@ -915,7 +917,7 @@ void RcxEditor::applyDocument(const ComposeResult& result) {
     // Footer buttons — pill styling
     for (int i = 0; i < result.meta.size(); i++) {
         if (result.meta[i].lineKind != LineKind::Footer) continue;
-        QString ft = getLineText(m_sci, i);
+        const QString& ft = lineTexts[i];
         // Struct footer: +10h +100h +1000h Trim (search longest first)
         int p1000 = ft.indexOf(QStringLiteral("+1000h"));
         if (p1000 >= 0)
@@ -935,6 +937,15 @@ void RcxEditor::applyDocument(const ComposeResult& result) {
             fillIndicatorCols(IND_CMD_PILL, i, trimStart, trimStart + 4);
     }
 
+    // Apply type inference hint coloring (green, same as comment annotations)
+    for (int i = 0; i < result.meta.size(); i++) {
+        const auto& lm = result.meta[i];
+        if (lm.typeHintStart < 0) continue;
+        const QString& ft = lineTexts[i];
+        if (lm.typeHintStart < ft.size())
+            fillIndicatorCols(IND_TYPE_HINT, i, lm.typeHintStart, ft.size());
+    }
+
     // Reset hint line - applySelectionOverlay will repaint indicators
     m_hintLine = -1;
 
@@ -2562,6 +2573,8 @@ bool RcxEditor::beginInlineEdit(EditTarget target, int line, int col) {
         ColumnSpan cs = commentSpanFor(*lm, 9999, lm->effectiveTypeW, lm->effectiveNameW);
         m_editState.commentCol = cs.valid ? cs.start : -1;
         m_editState.lastValidationOk = true;  // original value is always valid
+    } else if (target == EditTarget::BaseAddress) {
+        m_editState.commentCol = norm.end + 2;  // command row has no column layout
     } else {
         m_editState.commentCol = -1;
     }
@@ -2575,7 +2588,8 @@ bool RcxEditor::beginInlineEdit(EditTarget target, int line, int col) {
 
     // For value editing: extend line with trailing spaces for the edit comment area
     // (comment padding is no longer baked into every line to avoid unnecessary scroll width)
-    if (target == EditTarget::Value && m_editState.commentCol >= 0) {
+    if ((target == EditTarget::Value || target == EditTarget::BaseAddress)
+        && m_editState.commentCol >= 0) {
         int commentStart = norm.end + 2;
         int neededLen = commentStart + kColComment;
         int currentLen = (int)lineText.size();
@@ -2624,6 +2638,8 @@ bool RcxEditor::beginInlineEdit(EditTarget target, int line, int col) {
     // Show initial edit hint in comment column
     if (target == EditTarget::Value)
         setEditComment(QStringLiteral("Enter=Save Esc=Cancel"));
+    else if (target == EditTarget::BaseAddress)
+        setEditComment(QStringLiteral("e.g. <mod.exe> + 0xFF | [0x1000 + 0x10] | 7ff6`1234ABCD"));
 
     // Note: Type, ArrayElementType, PointerTarget are handled by TypeSelectorPopup
     // and exit early above (never reach here).
diff --git a/src/format.cpp b/src/format.cpp
index 01e055e..9223bb0 100644
--- a/src/format.cpp
+++ b/src/format.cpp
@@ -661,8 +661,10 @@ QString validateValue(NodeKind kind, const QString& text) {
         QString digits = hasHexPrefix ? s.mid(2) : s;
 
         if (hasHexPrefix || isHexKind) {
-            // Hex mode: only 0-9, a-f, A-F
+            // Hex mode: only 0-9, a-f, A-F (spaces allowed for multi-byte hex kinds)
+            bool isMultiByteHex = (kind >= NodeKind::Hex16 && kind <= NodeKind::Hex64);
             for (QChar c : digits) {
+                if (c == ' ' && isMultiByteHex) continue;
                 if (!c.isDigit() && !(c >= 'a' && c <= 'f') && !(c >= 'A' && c <= 'F'))
                     return QStringLiteral("invalid hex '%1'").arg(c);
             }
diff --git a/src/imports/import_source.cpp b/src/imports/import_source.cpp
index ddafcc0..7c3f30a 100644
--- a/src/imports/import_source.cpp
+++ b/src/imports/import_source.cpp
@@ -1188,6 +1188,16 @@ static int structTypeSize(const QString& typeName, const BuildContext& ctx) {
     return 0;
 }
 
+// Compute total array elements from multi-dimensional sizes, capped to prevent overflow.
+static int clampedArrayElements(const QVector<int>& dims, int maxElements = 1000000) {
+    int64_t total = 1;
+    for (int dim : dims) {
+        total *= (dim > 0 ? dim : 1);
+        if (total > maxElements) return maxElements;
+    }
+    return (int)total;
+}
+
 static void buildFields(BuildContext& ctx, uint64_t parentId, int baseOffset,
                         const QVector<ParsedField>& fields) {
     int computedOffset = 0;
@@ -1276,8 +1286,7 @@ static void buildFields(BuildContext& ctx, uint64_t parentId, int baseOffset,
 
             // Array of pointers: PVOID arr[N]
             if (!field.arraySizes.isEmpty()) {
-                int totalElements = 1;
-                for (int dim : field.arraySizes) totalElements *= (dim > 0 ? dim : 1);
+                int totalElements = clampedArrayElements(field.arraySizes);
 
                 Node n;
                 n.kind = NodeKind::Array;
@@ -1315,8 +1324,7 @@ static void buildFields(BuildContext& ctx, uint64_t parentId, int baseOffset,
             int elemSize = 4;
             NodeKind elemKind = NodeKind::UInt32;
             if (!field.arraySizes.isEmpty()) {
-                int totalElements = 1;
-                for (int dim : field.arraySizes) totalElements *= (dim > 0 ? dim : 1);
+                int totalElements = clampedArrayElements(field.arraySizes);
                 Node n;
                 n.kind = NodeKind::Array;
                 n.name = field.name;
@@ -1420,8 +1428,7 @@ static void buildFields(BuildContext& ctx, uint64_t parentId, int baseOffset,
                 ctx.tree.addNode(n); computedOffset = fieldOffset + 64; continue;
             }
 
-            int totalElements = 1;
-            for (int dim : field.arraySizes) totalElements *= (dim > 0 ? dim : 1);
+            int totalElements = clampedArrayElements(field.arraySizes);
 
             Node n;
             n.kind = NodeKind::Array;
@@ -1440,8 +1447,7 @@ static void buildFields(BuildContext& ctx, uint64_t parentId, int baseOffset,
             int elemSize = structTypeSize(field.typeName, ctx);
 
             if (!field.arraySizes.isEmpty()) {
-                int totalElements = 1;
-                for (int dim : field.arraySizes) totalElements *= (dim > 0 ? dim : 1);
+                int totalElements = clampedArrayElements(field.arraySizes);
 
                 Node n;
                 n.kind = NodeKind::Array;
diff --git a/src/main.cpp b/src/main.cpp
index ebba61d..b9852a7 100644
--- a/src/main.cpp
+++ b/src/main.cpp
@@ -604,6 +604,25 @@ MainWindow::MainWindow(QWidget* parent) : QMainWindow(parent) {
 
     createWorkspaceDock();
     createScannerDock();
+
+    // Hidden sentinel dock — never visible, only used to force Qt to create a
+    // QTabBar when the first document dock is added (Qt only creates tab bars
+    // via tabifyDockWidget).  Immediately hidden after tabification so it takes
+    // zero layout space.  An event filter on the QTabBar keeps it visible.
+    {
+        m_sentinelDock = new QDockWidget(this);
+        m_sentinelDock->setObjectName(QStringLiteral("_sentinel"));
+        m_sentinelDock->setFeatures(QDockWidget::NoDockWidgetFeatures);
+        auto* sw = new QWidget(m_sentinelDock);
+        sw->setFixedSize(0, 0);
+        m_sentinelDock->setWidget(sw);
+        auto* stb = new QWidget(m_sentinelDock);
+        stb->setFixedHeight(0);
+        m_sentinelDock->setTitleBarWidget(stb);
+        addDockWidget(Qt::TopDockWidgetArea, m_sentinelDock);
+        m_sentinelDock->hide();  // hidden = zero layout space
+    }
+
     createMenus();
     createStatusBar();
 
@@ -1644,6 +1663,16 @@ QDockWidget* MainWindow::createTab(RcxDocument* doc) {
     else
         addDockWidget(Qt::TopDockWidgetArea, dock);
 
+    // Bootstrap: tabify the hidden sentinel with the first doc dock so Qt
+    // creates a QTabBar.  Then hide sentinel (zero layout space).  The event
+    // filter in eventFilter() keeps the tab bar visible even at count==1.
+    if (m_sentinelDock && m_docDocks.isEmpty()) {
+        m_sentinelDock->show();
+        tabifyDockWidget(dock, m_sentinelDock);
+        m_sentinelDock->hide();
+        dock->raise();
+    }
+
     m_docDocks.append(dock);
     m_tabs[dock] = { doc, ctrl, splitter, {}, 0 };
     m_activeDocDock = dock;
@@ -1698,7 +1727,7 @@ QDockWidget* MainWindow::createTab(RcxDocument* doc) {
             m_activeDocDock = m_docDocks.isEmpty() ? nullptr : m_docDocks.last();
         rebuildAllDocs();
         rebuildWorkspaceModel();
-        if (m_tabs.isEmpty())
+        if (m_tabs.isEmpty() && !m_closingAll)
             project_new();
     });
 
@@ -1780,6 +1809,10 @@ QDockWidget* MainWindow::createTab(RcxDocument* doc) {
                 updateWindowTitle();
             });
     });
+    // Notify MCP clients of tree changes
+    connect(doc, &RcxDocument::documentChanged, this, [this]() {
+        if (m_mcp) m_mcp->notifyTreeChanged();
+    });
     connect(&doc->undoStack, &QUndoStack::indexChanged,
             this, [this, dockGuard](int) {
         if (!dockGuard) return;
@@ -1875,6 +1908,9 @@ void MainWindow::setupDockTabBars() {
                 .arg(theme.background.name(), theme.border.name(), theme.hover.name()));
         }
 
+        // Force tab bar visible (event filter keeps it alive, belt-and-suspenders)
+        tabBar->show();
+
         // Install tab buttons for any tab that doesn't have them yet
         for (int i = 0; i < tabBar->count(); ++i) {
             auto* existing = qobject_cast<DockTabButtons*>(
@@ -2010,6 +2046,25 @@ void MainWindow::setupDockTabBars() {
 }
 
 bool MainWindow::eventFilter(QObject* obj, QEvent* event) {
+    // Keep dock tab bars visible even when Qt wants to hide them (count==1).
+    // Qt's QMainWindowLayout calls setVisible(false) on the QTabBar when only
+    // one dock remains in a tab group.  We catch the resulting Hide event and
+    // immediately re-show the tab bar, provided at least one doc dock is docked.
+    if (event->type() == QEvent::Hide && !m_tabBarShowGuard) {
+        if (auto* tabBar = qobject_cast<QTabBar*>(obj)) {
+            if (tabBar->parent() == this && tabBar->count() >= 1) {
+                bool hasDockedDoc = false;
+                for (auto* d : m_docDocks)
+                    if (!d->isFloating() && d->isVisible()) { hasDockedDoc = true; break; }
+                if (hasDockedDoc) {
+                    m_tabBarShowGuard = true;
+                    tabBar->show();
+                    m_tabBarShowGuard = false;
+                    return true;
+                }
+            }
+        }
+    }
     if (event->type() == QEvent::MouseButtonPress) {
         auto* me = static_cast<QMouseEvent*>(event);
         if (me->button() == Qt::MiddleButton) {
@@ -3107,8 +3162,10 @@ void MainWindow::importReclassXml() {
     auto* doc = new RcxDocument(this);
     doc->tree = std::move(tree);
 
-    closeAllDocDocks();
-    createTab(doc);
+    { ClosingGuard guard(m_closingAll);
+      closeAllDocDocks();
+      createTab(doc);
+    }
     rebuildWorkspaceModel();
     setAppStatus(QStringLiteral("Imported %1 classes from %2")
         .arg(classCount).arg(QFileInfo(filePath).fileName()));
@@ -3156,8 +3213,10 @@ void MainWindow::importFromSource() {
     auto* doc = new RcxDocument(this);
     doc->tree = std::move(tree);
 
-    closeAllDocDocks();
-    createTab(doc);
+    { ClosingGuard guard(m_closingAll);
+      closeAllDocDocks();
+      createTab(doc);
+    }
     rebuildWorkspaceModel();
     if (!m_docDocks.isEmpty()) {
         splitDockWidget(m_workspaceDock, m_docDocks.first(), Qt::Horizontal);
@@ -3210,8 +3269,10 @@ void MainWindow::importPdb() {
     auto* doc = new rcx::RcxDocument(this);
     doc->tree = std::move(tree);
 
-    closeAllDocDocks();
-    createTab(doc);
+    { ClosingGuard guard(m_closingAll);
+      closeAllDocDocks();
+      createTab(doc);
+    }
     rebuildWorkspaceModel();
     if (!m_docDocks.isEmpty()) {
         splitDockWidget(m_workspaceDock, m_docDocks.first(), Qt::Horizontal);
@@ -3408,8 +3469,11 @@ QDockWidget* MainWindow::project_open(const QString& path) {
         }
         auto* doc = new RcxDocument(this);
         doc->tree = std::move(tree);
-        closeAllDocDocks();
-        auto* dock = createTab(doc);
+        QDockWidget* dock;
+        { ClosingGuard guard(m_closingAll);
+          closeAllDocDocks();
+          dock = createTab(doc);
+        }
         rebuildWorkspaceModel();
         if (!m_docDocks.isEmpty()) {
         splitDockWidget(m_workspaceDock, m_docDocks.first(), Qt::Horizontal);
@@ -3433,9 +3497,11 @@ QDockWidget* MainWindow::project_open(const QString& path) {
     }
 
     // Close all existing tabs so the project replaces the current state
-    closeAllDocDocks();
-
-    auto* dock = createTab(doc);
+    QDockWidget* dock;
+    { ClosingGuard guard(m_closingAll);
+      closeAllDocDocks();
+      dock = createTab(doc);
+    }
     rebuildWorkspaceModel();
     if (!m_docDocks.isEmpty()) {
         splitDockWidget(m_workspaceDock, m_docDocks.first(), Qt::Horizontal);
@@ -3750,6 +3816,16 @@ void MainWindow::createWorkspaceDock() {
                 actConvert = menu.addAction("Convert to Class");
         }
 
+        // Pin/Unpin
+        bool allPinned = true;
+        for (const auto& item : items)
+            if (!m_pinnedIds.contains(item.structId)) { allPinned = false; break; }
+        auto* actPin = menu.addAction(
+            QIcon(QStringLiteral(":/vsicons/pin.svg")),
+            allPinned ? QStringLiteral("Unpin") : QStringLiteral("Pin"));
+
+        menu.addSeparator();
+
         // Delete: works for single or multi
         QString delLabel = items.size() == 1
             ? QStringLiteral("Delete")
@@ -3941,6 +4017,17 @@ void MainWindow::createWorkspaceDock() {
             tab.doc->undoStack.push(new rcx::RcxCommand(tab.ctrl,
                 rcx::cmd::ChangeClassKeyword{item.structId, item.keyword, newKw}));
             rebuildWorkspaceModel();
+
+        } else if (chosen && chosen == actPin) {
+            for (const auto& item : items) {
+                if (allPinned)
+                    m_pinnedIds.remove(item.structId);
+                else
+                    m_pinnedIds.insert(item.structId);
+            }
+            // Full rebuild to reorder pinned items to top
+            m_workspaceModel->removeRows(0, m_workspaceModel->rowCount());
+            rebuildWorkspaceModelNow();
         }
     });
 
@@ -4244,9 +4331,9 @@ void MainWindow::rebuildWorkspaceModelNow() {
         QString name = rootName(tab.doc->tree, tab.ctrl->viewRootId());
         tabs.append({ &tab.doc->tree, name, static_cast<void*>(it.key()) });
     }
-    rcx::syncProjectExplorer(m_workspaceModel, tabs);
+    rcx::syncProjectExplorer(m_workspaceModel, tabs, m_pinnedIds);
 
-    // Mark items that are currently viewed in a tab
+    // Mark items that are currently viewed in a tab + pinned state
     QSet<uint64_t> viewedIds;
     for (auto it = m_tabs.begin(); it != m_tabs.end(); ++it)
         viewedIds.insert(it->ctrl->viewRootId());
@@ -4255,6 +4342,7 @@ void MainWindow::rebuildWorkspaceModelNow() {
         if (!item) continue;
         uint64_t id = item->data(Qt::UserRole + 1).toULongLong();
         item->setData(viewedIds.contains(id), Qt::UserRole + 3);
+        item->setData(m_pinnedIds.contains(id), Qt::UserRole + 4);
     }
 
     if (m_dockTitleLabel) {
diff --git a/src/mainwindow.h b/src/mainwindow.h
index 0cd8d99..6099cc6 100644
--- a/src/mainwindow.h
+++ b/src/mainwindow.h
@@ -120,7 +120,15 @@ private:
     QMap<QDockWidget*, TabState> m_tabs;
     QVector<QDockWidget*> m_docDocks;       // ordered list for tabByIndex
     QDockWidget* m_activeDocDock = nullptr;  // tracks active document dock
+    QDockWidget* m_sentinelDock  = nullptr;  // hidden dock to bootstrap tab bar creation
     QVector<RcxDocument*> m_allDocs;  // all open docs, shared with controllers
+    bool m_closingAll = false;        // guards spurious project_new during batch close
+    bool m_tabBarShowGuard = false;   // prevents recursion in event filter re-show
+    struct ClosingGuard {
+        bool& flag;
+        ClosingGuard(bool& f) : flag(f) { flag = true; }
+        ~ClosingGuard() { flag = false; }
+    };
     void rebuildAllDocs();
 
     void createMenus();
@@ -165,6 +173,7 @@ private:
     QLabel*               m_dockTitleLabel  = nullptr;
     QToolButton*          m_dockCloseBtn    = nullptr;
     DockGripWidget*       m_dockGrip        = nullptr;
+    QSet<uint64_t>        m_pinnedIds;
     void createWorkspaceDock();
     void rebuildWorkspaceModel();       // debounced — safe to call frequently
     void rebuildWorkspaceModelNow();    // immediate rebuild
diff --git a/src/mcp/mcp_bridge.cpp b/src/mcp/mcp_bridge.cpp
index f8f0fc6..8e5aff3 100644
--- a/src/mcp/mcp_bridge.cpp
+++ b/src/mcp/mcp_bridge.cpp
@@ -10,13 +10,24 @@
 
 namespace rcx {
 
+static constexpr int kMaxReadBuffer = 10 * 1024 * 1024; // 10 MB
+
 // ════════════════════════════════════════════════════════════════════
 // Construction / lifecycle
 // ════════════════════════════════════════════════════════════════════
 
 McpBridge::McpBridge(MainWindow* mainWindow, QObject* parent)
     : QObject(parent), m_mainWindow(mainWindow)
-{}
+{
+    m_notifyTimer = new QTimer(this);
+    m_notifyTimer->setSingleShot(true);
+    m_notifyTimer->setInterval(100);
+    connect(m_notifyTimer, &QTimer::timeout, this, [this]() {
+        if (m_client && m_initialized)
+            sendNotification("notifications/resources/updated",
+                             QJsonObject{{"uri", "project://tree"}});
+    });
+}
 
 McpBridge::~McpBridge() {
     stop();
@@ -84,15 +95,24 @@ void McpBridge::onNewConnection() {
 void McpBridge::onReadyRead() {
     m_readBuffer.append(m_client->readAll());
 
-    // Newline-delimited JSON framing
+    if (m_readBuffer.size() > kMaxReadBuffer) {
+        qWarning() << "[MCP] Read buffer exceeded 10MB, disconnecting client";
+        m_client->disconnectFromServer();
+        return;
+    }
+
+    // Newline-delimited JSON framing (cursor approach avoids quadratic shifting)
+    int consumed = 0;
     while (true) {
-        int idx = m_readBuffer.indexOf('\n');
+        int idx = m_readBuffer.indexOf('\n', consumed);
         if (idx < 0) break;
-        QByteArray line = m_readBuffer.left(idx).trimmed();
-        m_readBuffer.remove(0, idx + 1);
+        QByteArray line = m_readBuffer.mid(consumed, idx - consumed).trimmed();
+        consumed = idx + 1;
         if (!line.isEmpty())
             processLine(line);
     }
+    if (consumed > 0)
+        m_readBuffer.remove(0, consumed);
 }
 
 void McpBridge::onDisconnected() {
@@ -153,6 +173,7 @@ QJsonObject McpBridge::makeTextResult(const QString& text, bool isError) {
 // ════════════════════════════════════════════════════════════════════
 
 void McpBridge::processLine(const QByteArray& line) {
+  try {
     qDebug() << "[MCP] <<" << line.trimmed().left(200);
     auto doc = QJsonDocument::fromJson(line);
     if (!doc.isObject()) {
@@ -172,12 +193,10 @@ void McpBridge::processLine(const QByteArray& line) {
 
     if (method == "initialize") {
         m_mainWindow->setMcpStatus(QStringLiteral("MCP: client connected"));
-        QCoreApplication::processEvents();
         sendJson(handleInitialize(id, req.value("params").toObject()));
         m_mainWindow->clearMcpStatus();
     } else if (method == "tools/list") {
         m_mainWindow->setMcpStatus(QStringLiteral("MCP: tools/list"));
-        QCoreApplication::processEvents();
         sendJson(handleToolsList(id));
         m_mainWindow->clearMcpStatus();
     } else if (method == "tools/call") {
@@ -185,6 +204,14 @@ void McpBridge::processLine(const QByteArray& line) {
     } else {
         sendJson(errReply(id, -32601, "Method not found: " + method));
     }
+  } catch (const std::exception& e) {
+    qWarning() << "[MCP] Exception:" << e.what();
+    sendJson(errReply(QJsonValue(), -32603,
+        QStringLiteral("Internal error: %1").arg(e.what())));
+  } catch (...) {
+    qWarning() << "[MCP] Unknown exception";
+    sendJson(errReply(QJsonValue(), -32603, "Internal error"));
+  }
 }
 
 // ════════════════════════════════════════════════════════════════════
@@ -476,7 +503,7 @@ QJsonObject McpBridge::handleToolsCall(const QJsonValue& id, const QJsonObject&
 
     // Show tool activity in status bar (with shimmer)
     m_mainWindow->setMcpStatus(QStringLiteral("MCP: %1").arg(toolName));
-    QCoreApplication::processEvents();  // paint immediately
+    QCoreApplication::processEvents(QEventLoop::ExcludeUserInputEvents);
 
     QJsonObject result;
     if      (toolName == "project.state")  result = toolProjectState(args);
@@ -501,11 +528,15 @@ QJsonObject McpBridge::handleToolsCall(const QJsonValue& id, const QJsonObject&
 // ════════════════════════════════════════════════════════════════════
 
 QString McpBridge::resolvePlaceholder(const QString& ref,
-                                       const QHash<QString, uint64_t>& placeholderMap) {
+                                       const QHash<QString, uint64_t>& placeholderMap,
+                                       bool* ok) {
+    if (ok) *ok = true;
     if (ref.startsWith('$')) {
         auto it = placeholderMap.find(ref);
         if (it != placeholderMap.end())
             return QString::number(it.value());
+        if (ok) *ok = false;
+        return ref;  // unresolved placeholder
     }
     return ref;  // not a placeholder — return as-is
 }
@@ -514,26 +545,36 @@ QString McpBridge::resolvePlaceholder(const QString& ref,
 // Smart tab resolution
 // ════════════════════════════════════════════════════════════════════
 
-MainWindow::TabState* McpBridge::resolveTab(const QJsonObject& args) {
+MainWindow::TabState* McpBridge::resolveTab(const QJsonObject& args, int* resolvedIndex) {
+    if (resolvedIndex) *resolvedIndex = -1;
+
     // 1) Explicit tab index from args
     if (args.contains("tabIndex")) {
         int idx = args.value("tabIndex").toInt();
         auto* t = m_mainWindow->tabByIndex(idx);
-        if (t) return t;
+        if (t) { if (resolvedIndex) *resolvedIndex = idx; return t; }
     }
 
     // 2) Active sub-window (user clicked on it)
     auto* t = m_mainWindow->activeTab();
-    if (t) return t;
+    if (t) {
+        if (resolvedIndex) {
+            for (int i = 0; i < m_mainWindow->tabCount(); i++) {
+                if (m_mainWindow->tabByIndex(i) == t) { *resolvedIndex = i; break; }
+            }
+        }
+        return t;
+    }
 
     // 3) Fall back to first available tab
     if (m_mainWindow->tabCount() > 0) {
         t = m_mainWindow->tabByIndex(0);
-        if (t) return t;
+        if (t) { if (resolvedIndex) *resolvedIndex = 0; return t; }
     }
 
     // 4) No tabs at all — auto-create a project
     m_mainWindow->project_new();
+    if (resolvedIndex) *resolvedIndex = 0;
     return m_mainWindow->tabByIndex(0);
 }
 
@@ -725,8 +766,11 @@ QJsonObject McpBridge::toolTreeApply(const QJsonObject& args) {
     QStringList skippedOps;
     for (int i = 0; i < ops.size(); i++) {
         // Safety valve: keep paint events flowing for large batches
-        if (i % 100 == 0 && ops.size() > 200)
+        if (i % 100 == 0 && ops.size() > 200) {
+            m_mainWindow->setMcpStatus(
+                QStringLiteral("MCP: tree.apply %1/%2").arg(i).arg(ops.size()));
             QCoreApplication::processEvents(QEventLoop::ExcludeUserInputEvents, 5);
+        }
 
         QJsonObject op = ops[i].toObject();
         QString opType = op.value("op").toString();
@@ -736,15 +780,29 @@ QJsonObject McpBridge::toolTreeApply(const QJsonObject& args) {
             n.id = placeholders.value(QStringLiteral("$%1").arg(i), tree.reserveId());
             n.kind = kindFromString(op.value("kind").toString("Hex64"));
             n.name = op.value("name").toString();
-            QString pid = resolvePlaceholder(op.value("parentId").toString("0"), placeholders);
+            bool pidOk;
+            QString pid = resolvePlaceholder(op.value("parentId").toString("0"), placeholders, &pidOk);
+            if (!pidOk) {
+                skippedOps.append(QStringLiteral("op[%1]: unresolved placeholder for parentId").arg(i));
+                continue;
+            }
             n.parentId = pid.toULongLong();
+            if (n.parentId != 0 && tree.indexOfId(n.parentId) < 0) {
+                skippedOps.append(QStringLiteral("op[%1]: parentId '%2' not found").arg(i).arg(pid));
+                continue;
+            }
             n.offset = op.value("offset").toInt(0);
             n.structTypeName = op.value("structTypeName").toString();
             n.classKeyword = op.value("classKeyword").toString();
-            n.strLen = op.value("strLen").toInt(64);
+            n.strLen = qBound(1, op.value("strLen").toInt(64), 1000000);
             n.elementKind = kindFromString(op.value("elementKind").toString("UInt8"));
-            n.arrayLen = op.value("arrayLen").toInt(1);
-            QString refStr = resolvePlaceholder(op.value("refId").toString("0"), placeholders);
+            n.arrayLen = qBound(1, op.value("arrayLen").toInt(1), 1000000);
+            bool refOk;
+            QString refStr = resolvePlaceholder(op.value("refId").toString("0"), placeholders, &refOk);
+            if (!refOk) {
+                skippedOps.append(QStringLiteral("op[%1]: unresolved placeholder for refId").arg(i));
+                continue;
+            }
             n.refId = refStr.toULongLong();
 
             // Auto-place: offset -1 means "after last sibling"
@@ -870,7 +928,7 @@ QJsonObject McpBridge::toolTreeApply(const QJsonObject& args) {
             int idx = tree.indexOfId(nid.toULongLong());
             if (idx >= 0) {
                 NodeKind newElemKind = kindFromString(op.value("elementKind").toString());
-                int newLen = op.value("arrayLen").toInt(1);
+                int newLen = qBound(1, op.value("arrayLen").toInt(1), 1000000);
                 doc->undoStack.push(new RcxCommand(ctrl,
                     cmd::ChangeArrayMeta{tree.nodes[idx].id,
                         tree.nodes[idx].elementKind, newElemKind,
@@ -1383,8 +1441,7 @@ QJsonObject McpBridge::toolProcessInfo(const QJsonObject& args) {
 
 void McpBridge::notifyTreeChanged() {
     if (!m_client || !m_initialized) return;
-    sendNotification("notifications/resources/updated",
-                     QJsonObject{{"uri", "project://tree"}});
+    m_notifyTimer->start();  // debounce 100ms
 }
 
 void McpBridge::notifyDataChanged() {
diff --git a/src/mcp/mcp_bridge.h b/src/mcp/mcp_bridge.h
index 8c5f1c5..6a561fd 100644
--- a/src/mcp/mcp_bridge.h
+++ b/src/mcp/mcp_bridge.h
@@ -7,6 +7,7 @@
 #include <QJsonArray>
 #include <QJsonDocument>
 #include <QByteArray>
+#include <QTimer>
 
 namespace rcx {
 
@@ -34,6 +35,7 @@ private:
     QByteArray     m_readBuffer;
     bool           m_initialized = false;
     bool           m_slowMode    = false;
+    QTimer*        m_notifyTimer = nullptr;
 
     // JSON-RPC plumbing
     void onNewConnection();
@@ -65,10 +67,11 @@ private:
     // Helpers
     QJsonObject makeTextResult(const QString& text, bool isError = false);
     QString resolvePlaceholder(const QString& ref,
-                               const QHash<QString, uint64_t>& placeholderMap);
+                               const QHash<QString, uint64_t>& placeholderMap,
+                               bool* ok = nullptr);
 
     // Smart tab resolution: tabIndex arg → activeTab → first tab → auto-create
-    MainWindow::TabState* resolveTab(const QJsonObject& args);
+    MainWindow::TabState* resolveTab(const QJsonObject& args, int* resolvedIndex = nullptr);
 };
 
 } // namespace rcx
diff --git a/src/providers/snapshot_provider.h b/src/providers/snapshot_provider.h
index b0727c2..8781e29 100644
--- a/src/providers/snapshot_provider.h
+++ b/src/providers/snapshot_provider.h
@@ -53,6 +53,7 @@ public:
     bool isReadable(uint64_t addr, int len) const override {
         if (len <= 0) return (len == 0);
         uint64_t end = addr + static_cast<uint64_t>(len);
+        if (end < addr) return false;   // overflow
         for (uint64_t p = addr & kPageMask; p < end; p += kPageSize) {
             if (!m_pages.contains(p)) return false;
         }
diff --git a/src/scannerpanel.cpp b/src/scannerpanel.cpp
index fa0eb84..3e9238c 100644
--- a/src/scannerpanel.cpp
+++ b/src/scannerpanel.cpp
@@ -702,7 +702,7 @@ void ScannerPanel::onCellEdited(int row, int col) {
             m_statusLabel->setText(QStringLiteral("Wrote %1 byte%2 to 0x%3")
                 .arg(bytes.size())
                 .arg(bytes.size() == 1 ? "" : "s")
-                .arg(addr, 0, 16, QLatin1Char('0')).toUpper());
+                .arg(QString::number(addr, 16).toUpper()));
             // Re-read and update cache
             m_resultTable->blockSignals(true);
             int readSize = (m_lastScanMode == 1) ? valueSize() : 16;
diff --git a/src/typeinfer.h b/src/typeinfer.h
index 0a49093..5b0bced 100644
--- a/src/typeinfer.h
+++ b/src/typeinfer.h
@@ -34,15 +34,13 @@ QVector<TypeSuggestion> inferTypes(
     const InferHints& hints = {},
     int maxResults = 3);
 
-// Format top suggestion as short display string (e.g. "ptr64 strong", "float×2 moderate")
+// Format top suggestion as short type label (e.g. "ptr64", "int32_t×2")
 inline QString formatHint(const TypeSuggestion& s) {
     if (s.kinds.isEmpty()) return {};
     const char* name = kindMeta(s.kinds[0])->typeName;
-    QString base = (s.kinds.size() == 1)
+    return (s.kinds.size() == 1)
         ? QString::fromLatin1(name)
         : QStringLiteral("%1\u00D7%2").arg(QString::fromLatin1(name)).arg(s.kinds.size());
-    const char* conf = s.strength >= 3 ? " strong" : " moderate";
-    return base + QLatin1String(conf);
 }
 
 // ── Implementation (header-only) ──
@@ -258,7 +256,7 @@ inline FeatureResult countInt16Features(uint16_t val,
     int passed = 0, checked = 2;
     int16_t sv = (int16_t)val;
     passed += (val != 0) ? 1 : 0;
-    passed += (sv >= -4096 && sv <= 4096) ? 1 : 0;
+    passed += (sv >= -16384 && sv <= 16384) ? 1 : 0;
 
     if (h.sampleCount > 0 && minP && maxP) {
         checked += 2;
@@ -373,7 +371,6 @@ inline void tryWhole1(const uint8_t* data, QVector<Candidate>& out) {
     uint8_t v = data[0];
     int score = (v == 0 || v == 1) ? 50 : 25;
     addCandidate(out, NodeKind::UInt8, score);
-    if (v <= 1) addCandidate(out, NodeKind::Bool, 60);
 }
 
 // ── Try uniform splits ──
diff --git a/src/workspace_model.h b/src/workspace_model.h
index d011907..3bbb13a 100644
--- a/src/workspace_model.h
+++ b/src/workspace_model.h
@@ -95,7 +95,8 @@ inline QStandardItem* makeTypeItem(const Node* node, const NodeTree* tree,
 
 // Full rebuild — used by benchmarks and first build.
 inline void buildProjectExplorer(QStandardItemModel* model,
-                                 const QVector<TabInfo>& tabs) {
+                                 const QVector<TabInfo>& tabs,
+                                 const QSet<uint64_t>& pinnedIds = {}) {
     model->clear();
     model->setHorizontalHeaderLabels({QStringLiteral("Name")});
 
@@ -113,18 +114,32 @@ inline void buildProjectExplorer(QStandardItemModel* model,
         }
     }
 
-    for (const auto& e : types)
+    // Pinned items at the very top, then structs, then enums
+    QVector<Entry> pinned;
+    QVector<Entry> unpinnedTypes, unpinnedEnums;
+    for (const auto& e : types) {
+        if (pinnedIds.contains(e.node->id)) pinned.append(e);
+        else unpinnedTypes.append(e);
+    }
+    for (const auto& e : enums) {
+        if (pinnedIds.contains(e.node->id)) pinned.append(e);
+        else unpinnedEnums.append(e);
+    }
+    for (const auto& e : pinned)
         model->appendRow(makeTypeItem(e.node, e.tree, e.subPtr));
-    for (const auto& e : enums)
+    for (const auto& e : unpinnedTypes)
+        model->appendRow(makeTypeItem(e.node, e.tree, e.subPtr));
+    for (const auto& e : unpinnedEnums)
         model->appendRow(makeTypeItem(e.node, e.tree, e.subPtr));
 }
 
 // Incremental sync — preserves tree expansion/scroll state.
 inline void syncProjectExplorer(QStandardItemModel* model,
-                                const QVector<TabInfo>& tabs) {
+                                const QVector<TabInfo>& tabs,
+                                const QSet<uint64_t>& pinnedIds = {}) {
     // First call — full build
     if (model->rowCount() == 0 && !tabs.isEmpty()) {
-        buildProjectExplorer(model, tabs);
+        buildProjectExplorer(model, tabs, pinnedIds);
         return;
     }
 
@@ -276,27 +291,39 @@ public:
             QString name = (dashPos > 1) ? fullText.left(dashPos - 1) : fullText;
             QString count = (dashPos > 1) ? fullText.mid(dashPos + 2).trimmed() : QString();
 
+            bool pinned = index.data(Qt::UserRole + 4).toBool();
+
+            // Reserve right side for pin icon + count pill
+            int rightEdge = textRect.right();
             if (!count.isEmpty()) {
                 int cw = opt.fontMetrics.horizontalAdvance(count) + 10;
                 int ch = opt.fontMetrics.height();
                 int cy = textRect.y() + (textRect.height() - ch) / 2;
-                QRect pill(textRect.right() - cw, cy, cw, ch);
-                // Draw name clipped before pill
-                if (pill.left() > textRect.left() + 4) {
-                    QRect nameRect = textRect;
-                    nameRect.setRight(pill.left() - 4);
-                    QString elided = opt.fontMetrics.elidedText(name, Qt::ElideRight, nameRect.width());
-                    painter->setPen(m_text);
-                    painter->drawText(nameRect, Qt::AlignLeft | Qt::AlignVCenter, elided);
-                }
+                QRect pill(rightEdge - cw, cy, cw, ch);
+                rightEdge = pill.left() - 2;
+
                 painter->setPen(Qt::NoPen);
                 painter->setBrush(m_badgeBg);
                 painter->drawRect(pill);
                 painter->setPen(m_textMuted);
                 painter->drawText(pill, Qt::AlignCenter, count);
-            } else {
+            }
+            if (pinned) {
+                static const QIcon pinIcon(":/vsicons/pin.svg");
+                int isz = opt.fontMetrics.height() - 2;
+                int iy = textRect.y() + (textRect.height() - isz) / 2;
+                QRect pinRect(rightEdge - isz, iy, isz, isz);
+                pinIcon.paint(painter, pinRect);
+                rightEdge = pinRect.left() - 2;
+            }
+
+            // Draw name clipped before right-side elements
+            if (rightEdge > textRect.left() + 4) {
+                QRect nameRect = textRect;
+                nameRect.setRight(rightEdge);
+                QString elided = opt.fontMetrics.elidedText(name, Qt::ElideRight, nameRect.width());
                 painter->setPen(m_text);
-                painter->drawText(textRect, Qt::AlignLeft | Qt::AlignVCenter, name);
+                painter->drawText(nameRect, Qt::AlignLeft | Qt::AlignVCenter, elided);
             }
         } else {
             // Child: "TypeName fieldName"
diff --git a/tests/test_controller.cpp b/tests/test_controller.cpp
index ee9850d..f3b116c 100644
--- a/tests/test_controller.cpp
+++ b/tests/test_controller.cpp
@@ -38,6 +38,7 @@ static void buildSmallTree(NodeTree& tree) {
     root.name = "root";
     root.parentId = 0;
     root.offset = 0;
+    root.collapsed = false;
     int ri = tree.addNode(root);
     uint64_t rootId = tree.nodes[ri].id;
 
diff --git a/tests/test_editor.cpp b/tests/test_editor.cpp
index 9111982..4215b1e 100644
--- a/tests/test_editor.cpp
+++ b/tests/test_editor.cpp
@@ -1964,6 +1964,7 @@ private slots:
         root.structTypeName = "Chain";
         root.name = "chain";
         root.parentId = 0;
+        root.collapsed = false;
         int ri = tree.addNode(root);
         uint64_t rootId = tree.nodes[ri].id;
 
@@ -1974,6 +1975,7 @@ private slots:
         inner.name = "Inner";
         inner.parentId = 0;
         inner.offset = 300;
+        inner.collapsed = false;
         int ii = tree.addNode(inner);
         uint64_t innerId = tree.nodes[ii].id;
         {
@@ -1990,6 +1992,7 @@ private slots:
         outer.name = "Outer";
         outer.parentId = 0;
         outer.offset = 200;
+        outer.collapsed = false;
         int oi = tree.addNode(outer);
         uint64_t outerId = tree.nodes[oi].id;
         {
@@ -2002,6 +2005,7 @@ private slots:
             p.kind = NodeKind::Pointer64; p.name = "pInner";
             p.parentId = outerId; p.offset = 8;
             p.refId = innerId;
+            p.collapsed = false;
             tree.addNode(p);
         }
 
@@ -2011,6 +2015,7 @@ private slots:
             p.kind = NodeKind::Pointer64; p.name = "pOuter";
             p.parentId = rootId; p.offset = 0;
             p.refId = outerId;
+            p.collapsed = false;
             tree.addNode(p);
         }
 
@@ -2706,6 +2711,7 @@ private slots:
         sf.offset = 0;
         sf.isStatic = true;
         sf.offsetExpr = QStringLiteral("base + 0x10");
+        sf.collapsed = false;
         tree.addNode(sf);
 
         NullProvider prov;
diff --git a/tests/test_new_features.cpp b/tests/test_new_features.cpp
deleted file mode 100644
index 3bddd8d..0000000
--- a/tests/test_new_features.cpp
+++ /dev/null
@@ -1,807 +0,0 @@
-#include <QtTest/QTest>
-#include <QJsonDocument>
-#include <QJsonObject>
-#include <QTemporaryFile>
-#include <QStandardItemModel>
-#include "core.h"
-#include "generator.h"
-#include "controller.h"
-#include "workspace_model.h"
-
-using namespace rcx;
-
-class TestNewFeatures : public QObject {
-    Q_OBJECT
-
-private:
-    NodeTree makeSimpleTree() {
-        NodeTree tree;
-        tree.baseAddress = 0;
-
-        Node root;
-        root.kind = NodeKind::Struct;
-        root.name = "Player";
-        root.structTypeName = "Player";
-        root.parentId = 0;
-        root.offset = 0;
-        int ri = tree.addNode(root);
-        uint64_t rootId = tree.nodes[ri].id;
-
-        Node f1;
-        f1.kind = NodeKind::Int32;
-        f1.name = "health";
-        f1.parentId = rootId;
-        f1.offset = 0;
-        tree.addNode(f1);
-
-        Node f2;
-        f2.kind = NodeKind::Float;
-        f2.name = "speed";
-        f2.parentId = rootId;
-        f2.offset = 4;
-        tree.addNode(f2);
-
-        return tree;
-    }
-
-    NodeTree makeTwoRootTree() {
-        NodeTree tree;
-        tree.baseAddress = 0;
-
-        // Root struct A
-        Node a;
-        a.kind = NodeKind::Struct;
-        a.name = "Alpha";
-        a.structTypeName = "Alpha";
-        a.parentId = 0;
-        a.offset = 0;
-        int ai = tree.addNode(a);
-        uint64_t aId = tree.nodes[ai].id;
-
-        Node af;
-        af.kind = NodeKind::UInt32;
-        af.name = "flagsA";
-        af.parentId = aId;
-        af.offset = 0;
-        tree.addNode(af);
-
-        // Root struct B
-        Node b;
-        b.kind = NodeKind::Struct;
-        b.name = "Bravo";
-        b.structTypeName = "Bravo";
-        b.parentId = 0;
-        b.offset = 0x100;
-        int bi = tree.addNode(b);
-        uint64_t bId = tree.nodes[bi].id;
-
-        Node bf;
-        bf.kind = NodeKind::UInt64;
-        bf.name = "flagsB";
-        bf.parentId = bId;
-        bf.offset = 0;
-        tree.addNode(bf);
-
-        return tree;
-    }
-
-    NodeTree makeRichTree() {
-        NodeTree tree;
-        tree.baseAddress = 0x00400000;
-
-        // ── Pet (root struct) ──
-        Node pet;
-        pet.kind = NodeKind::Struct;
-        pet.name = "Pet";
-        pet.structTypeName = "Pet";
-        pet.parentId = 0;
-        pet.offset = 0;
-        int pi = tree.addNode(pet);
-        uint64_t petId = tree.nodes[pi].id;
-
-        { Node n; n.kind = NodeKind::Hex64;     n.name = "hex_00"; n.parentId = petId; n.offset = 0;  tree.addNode(n); }
-        { Node n; n.kind = NodeKind::UTF8;      n.name = "name";   n.parentId = petId; n.offset = 8;  n.strLen = 16; tree.addNode(n); }
-        { Node n; n.kind = NodeKind::Hex64;     n.name = "hex_18"; n.parentId = petId; n.offset = 24; tree.addNode(n); }
-        { Node n; n.kind = NodeKind::Hex32;     n.name = "hex_20"; n.parentId = petId; n.offset = 32; tree.addNode(n); }
-        { Node n; n.kind = NodeKind::Hex32;     n.name = "hex_24"; n.parentId = petId; n.offset = 36; tree.addNode(n); }
-        { Node n; n.kind = NodeKind::Pointer64; n.name = "owner";  n.parentId = petId; n.offset = 40; tree.addNode(n); }
-        { Node n; n.kind = NodeKind::Hex64;     n.name = "hex_30"; n.parentId = petId; n.offset = 48; tree.addNode(n); }
-        { Node n; n.kind = NodeKind::Hex64;     n.name = "hex_38"; n.parentId = petId; n.offset = 56; tree.addNode(n); }
-
-        // ── Cat (root struct, "inherits" Pet via nested struct) ──
-        Node cat;
-        cat.kind = NodeKind::Struct;
-        cat.name = "Cat";
-        cat.structTypeName = "Cat";
-        cat.parentId = 0;
-        cat.offset = 0;
-        int ci = tree.addNode(cat);
-        uint64_t catId = tree.nodes[ci].id;
-
-        // base = embedded Pet (nested struct child at offset 0)
-        Node base;
-        base.kind = NodeKind::Struct;
-        base.name = "base";
-        base.structTypeName = "Pet";
-        base.parentId = catId;
-        base.offset = 0;
-        int bi = tree.addNode(base);
-        uint64_t baseId = tree.nodes[bi].id;
-
-        // Children inside the nested Pet base
-        { Node n; n.kind = NodeKind::Hex64;     n.name = "hex_00"; n.parentId = baseId; n.offset = 0;  tree.addNode(n); }
-        { Node n; n.kind = NodeKind::UTF8;      n.name = "name";   n.parentId = baseId; n.offset = 8;  n.strLen = 16; tree.addNode(n); }
-        { Node n; n.kind = NodeKind::Hex64;     n.name = "hex_18"; n.parentId = baseId; n.offset = 24; tree.addNode(n); }
-        { Node n; n.kind = NodeKind::Pointer64; n.name = "owner";  n.parentId = baseId; n.offset = 32; tree.addNode(n); }
-        { Node n; n.kind = NodeKind::Hex64;     n.name = "hex_28"; n.parentId = baseId; n.offset = 40; tree.addNode(n); }
-
-        // Cat's own fields after base
-        { Node n; n.kind = NodeKind::Hex64; n.name = "hex_30";     n.parentId = catId; n.offset = 48; tree.addNode(n); }
-        { Node n; n.kind = NodeKind::Hex64; n.name = "hex_38";     n.parentId = catId; n.offset = 56; tree.addNode(n); }
-        { Node n; n.kind = NodeKind::Float; n.name = "whiskerLen"; n.parentId = catId; n.offset = 64; tree.addNode(n); }
-        { Node n; n.kind = NodeKind::Hex32; n.name = "hex_44";     n.parentId = catId; n.offset = 68; tree.addNode(n); }
-        { Node n; n.kind = NodeKind::UInt8; n.name = "lives";      n.parentId = catId; n.offset = 72; tree.addNode(n); }
-        { Node n; n.kind = NodeKind::Hex8;  n.name = "hex_49";     n.parentId = catId; n.offset = 73; tree.addNode(n); }
-        { Node n; n.kind = NodeKind::Hex16; n.name = "hex_4A";     n.parentId = catId; n.offset = 74; tree.addNode(n); }
-        { Node n; n.kind = NodeKind::Hex32; n.name = "hex_4C";     n.parentId = catId; n.offset = 76; tree.addNode(n); }
-
-        // ── Ball (independent root struct) ──
-        Node ball;
-        ball.kind = NodeKind::Struct;
-        ball.name = "Ball";
-        ball.structTypeName = "Ball";
-        ball.parentId = 0;
-        ball.offset = 0;
-        int bli = tree.addNode(ball);
-        uint64_t ballId = tree.nodes[bli].id;
-
-        { Node n; n.kind = NodeKind::Hex64;  n.name = "hex_00";   n.parentId = ballId; n.offset = 0;  tree.addNode(n); }
-        { Node n; n.kind = NodeKind::Hex64;  n.name = "hex_08";   n.parentId = ballId; n.offset = 8;  tree.addNode(n); }
-        { Node n; n.kind = NodeKind::Float;  n.name = "speed";    n.parentId = ballId; n.offset = 16; tree.addNode(n); }
-        { Node n; n.kind = NodeKind::Hex32;  n.name = "hex_14";   n.parentId = ballId; n.offset = 20; tree.addNode(n); }
-        { Node n; n.kind = NodeKind::Hex64;  n.name = "hex_18";   n.parentId = ballId; n.offset = 24; tree.addNode(n); }
-        { Node n; n.kind = NodeKind::Vec4;   n.name = "position"; n.parentId = ballId; n.offset = 32; tree.addNode(n); }
-        { Node n; n.kind = NodeKind::Hex64;  n.name = "hex_30";   n.parentId = ballId; n.offset = 48; tree.addNode(n); }
-        { Node n; n.kind = NodeKind::UInt32; n.name = "color";    n.parentId = ballId; n.offset = 56; tree.addNode(n); }
-        { Node n; n.kind = NodeKind::Hex32;  n.name = "hex_3C";   n.parentId = ballId; n.offset = 60; tree.addNode(n); }
-        { Node n; n.kind = NodeKind::Hex64;  n.name = "hex_40";   n.parentId = ballId; n.offset = 64; tree.addNode(n); }
-
-        return tree;
-    }
-
-private slots:
-
-    // ═══════════════════════════════════════════════════
-    // Feature 1: Type Aliases
-    // ═══════════════════════════════════════════════════
-
-    void testResolveTypeName_noAlias() {
-        RcxDocument doc;
-        // No aliases set — should return default type name
-        QString name = doc.resolveTypeName(NodeKind::Int32);
-        QCOMPARE(name, QString("int32_t"));
-
-        name = doc.resolveTypeName(NodeKind::Float);
-        QCOMPARE(name, QString("float"));
-
-        name = doc.resolveTypeName(NodeKind::Hex64);
-        QCOMPARE(name, QString("hex64"));
-    }
-
-    void testResolveTypeName_withAlias() {
-        RcxDocument doc;
-        doc.typeAliases[NodeKind::Int32] = "DWORD";
-        doc.typeAliases[NodeKind::Float] = "FLOAT";
-
-        QCOMPARE(doc.resolveTypeName(NodeKind::Int32), QString("DWORD"));
-        QCOMPARE(doc.resolveTypeName(NodeKind::Float), QString("FLOAT"));
-        // Non-aliased types still return default
-        QCOMPARE(doc.resolveTypeName(NodeKind::UInt64), QString("uint64_t"));
-    }
-
-    void testResolveTypeName_emptyAlias() {
-        RcxDocument doc;
-        doc.typeAliases[NodeKind::Int32] = "";  // empty alias should be ignored
-        QCOMPARE(doc.resolveTypeName(NodeKind::Int32), QString("int32_t"));
-    }
-
-    void testTypeAliases_saveLoad() {
-        // Save a document with type aliases, reload, verify aliases persist
-        QTemporaryFile tmpFile;
-        tmpFile.setAutoRemove(true);
-        QVERIFY(tmpFile.open());
-        QString path = tmpFile.fileName();
-        tmpFile.close();
-
-        // Create document with aliases and save
-        {
-            RcxDocument doc;
-            doc.tree = makeSimpleTree();
-            doc.typeAliases[NodeKind::Int32] = "DWORD";
-            doc.typeAliases[NodeKind::Float] = "FLOAT";
-            QVERIFY(doc.save(path));
-        }
-
-        // Reload and check aliases
-        {
-            RcxDocument doc;
-            QVERIFY(doc.load(path));
-            QCOMPARE(doc.typeAliases.size(), 2);
-            QCOMPARE(doc.typeAliases.value(NodeKind::Int32), QString("DWORD"));
-            QCOMPARE(doc.typeAliases.value(NodeKind::Float), QString("FLOAT"));
-        }
-    }
-
-    void testTypeAliases_saveLoadEmpty() {
-        // Save without aliases, reload, verify no aliases
-        QTemporaryFile tmpFile;
-        tmpFile.setAutoRemove(true);
-        QVERIFY(tmpFile.open());
-        QString path = tmpFile.fileName();
-        tmpFile.close();
-
-        {
-            RcxDocument doc;
-            doc.tree = makeSimpleTree();
-            QVERIFY(doc.save(path));
-        }
-
-        {
-            RcxDocument doc;
-            QVERIFY(doc.load(path));
-            QVERIFY(doc.typeAliases.isEmpty());
-        }
-    }
-
-    void testTypeAliases_jsonFormat() {
-        // Verify the JSON format of saved aliases
-        QTemporaryFile tmpFile;
-        tmpFile.setAutoRemove(true);
-        QVERIFY(tmpFile.open());
-        QString path = tmpFile.fileName();
-        tmpFile.close();
-
-        RcxDocument doc;
-        doc.tree = makeSimpleTree();
-        doc.typeAliases[NodeKind::UInt32] = "UINT";
-        QVERIFY(doc.save(path));
-
-        // Read raw JSON
-        QFile file(path);
-        QVERIFY(file.open(QIODevice::ReadOnly));
-        QJsonDocument jdoc = QJsonDocument::fromJson(file.readAll());
-        QJsonObject root = jdoc.object();
-
-        QVERIFY(root.contains("typeAliases"));
-        QJsonObject aliases = root["typeAliases"].toObject();
-        QCOMPARE(aliases["UInt32"].toString(), QString("UINT"));
-    }
-
-    void testGenerator_typeAliases() {
-        // Generator should use aliases for field types
-        auto tree = makeSimpleTree();
-        uint64_t rootId = tree.nodes[0].id;
-
-        QHash<NodeKind, QString> aliases;
-        aliases[NodeKind::Int32] = "LONG";
-        aliases[NodeKind::Float] = "FLOAT";
-
-        QString result = renderCpp(tree, rootId, &aliases);
-
-        QVERIFY(result.contains("LONG health;"));
-        QVERIFY(result.contains("FLOAT speed;"));
-        // struct keyword itself should not be aliased
-        QVERIFY(result.contains("struct Player {"));
-    }
-
-    void testGenerator_typeAliases_null() {
-        // With nullptr aliases, should behave like before
-        auto tree = makeSimpleTree();
-        uint64_t rootId = tree.nodes[0].id;
-
-        QString result = renderCpp(tree, rootId, nullptr);
-        QVERIFY(result.contains("int32_t health;"));
-        QVERIFY(result.contains("float speed;"));
-    }
-
-    void testGenerator_typeAliases_array() {
-        // Array element type should use alias
-        NodeTree tree;
-        Node root;
-        root.kind = NodeKind::Struct;
-        root.name = "ArrTest";
-        root.structTypeName = "ArrTest";
-        root.parentId = 0;
-        int ri = tree.addNode(root);
-        uint64_t rootId = tree.nodes[ri].id;
-
-        Node arr;
-        arr.kind = NodeKind::Array;
-        arr.name = "data";
-        arr.parentId = rootId;
-        arr.offset = 0;
-        arr.arrayLen = 16;
-        arr.elementKind = NodeKind::UInt32;
-        tree.addNode(arr);
-
-        QHash<NodeKind, QString> aliases;
-        aliases[NodeKind::UInt32] = "DWORD";
-
-        QString result = renderCpp(tree, rootId, &aliases);
-        QVERIFY(result.contains("DWORD data[16];"));
-    }
-
-    void testGenerator_renderCppAll_typeAliases() {
-        auto tree = makeTwoRootTree();
-
-        QHash<NodeKind, QString> aliases;
-        aliases[NodeKind::UInt32] = "DWORD";
-        aliases[NodeKind::UInt64] = "QWORD";
-
-        QString result = renderCppAll(tree, &aliases);
-        QVERIFY(result.contains("DWORD flagsA;"));
-        QVERIFY(result.contains("QWORD flagsB;"));
-    }
-
-    // ═══════════════════════════════════════════════════
-    // Feature 3: Per-Window View Root Class
-    // ═══════════════════════════════════════════════════
-
-    void testCompose_viewRootId_zero() {
-        // viewRootId=0 should show all roots (same as default)
-        auto tree = makeTwoRootTree();
-
-        NullProvider prov;
-        ComposeResult result = compose(tree, prov, 0);
-
-        // Should have content from both structs
-        QStringList lines = result.text.split('\n');
-        bool foundFlagsA = false, foundFlagsB = false;
-        for (const QString& l : lines) {
-            if (l.contains("flagsA")) foundFlagsA = true;
-            if (l.contains("flagsB")) foundFlagsB = true;
-        }
-        QVERIFY2(foundFlagsA, "viewRootId=0 should include Alpha struct");
-        QVERIFY2(foundFlagsB, "viewRootId=0 should include Bravo struct");
-    }
-
-    void testCompose_viewRootId_filter() {
-        // viewRootId set to Alpha's id should only show Alpha's fields
-        auto tree = makeTwoRootTree();
-        uint64_t alphaId = tree.nodes[0].id;
-
-        NullProvider prov;
-        ComposeResult result = compose(tree, prov, alphaId);
-
-        QStringList lines = result.text.split('\n');
-        bool foundFlagsA = false, foundFlagsB = false;
-        for (const QString& l : lines) {
-            if (l.contains("flagsA")) foundFlagsA = true;
-            if (l.contains("flagsB")) foundFlagsB = true;
-        }
-        QVERIFY2(foundFlagsA, "viewRootId=Alpha should include Alpha's fields");
-        QVERIFY2(!foundFlagsB, "viewRootId=Alpha should NOT include Bravo's fields");
-    }
-
-    void testCompose_viewRootId_otherRoot() {
-        // viewRootId set to Bravo's id should only show Bravo's fields
-        auto tree = makeTwoRootTree();
-        uint64_t bravoId = tree.nodes[2].id;  // Bravo is the 3rd node (index 2)
-
-        NullProvider prov;
-        ComposeResult result = compose(tree, prov, bravoId);
-
-        QStringList lines = result.text.split('\n');
-        bool foundFlagsA = false, foundFlagsB = false;
-        for (const QString& l : lines) {
-            if (l.contains("flagsA")) foundFlagsA = true;
-            if (l.contains("flagsB")) foundFlagsB = true;
-        }
-        QVERIFY2(!foundFlagsA, "viewRootId=Bravo should NOT include Alpha's fields");
-        QVERIFY2(foundFlagsB, "viewRootId=Bravo should include Bravo's fields");
-    }
-
-    void testCompose_viewRootId_invalid() {
-        // viewRootId pointing to non-existent node: should show nothing (only command rows)
-        auto tree = makeTwoRootTree();
-
-        NullProvider prov;
-        ComposeResult result = compose(tree, prov, 99999);
-
-        // Only command row
-        QCOMPARE(result.meta.size(), 1);
-        QCOMPARE(result.meta[0].lineKind, LineKind::CommandRow);
-    }
-
-    void testCompose_viewRootId_singleRoot() {
-        // Single root tree with viewRootId set to that root — should work normally
-        auto tree = makeSimpleTree();
-        uint64_t rootId = tree.nodes[0].id;
-
-        NullProvider prov;
-        ComposeResult full = compose(tree, prov, 0);
-        ComposeResult filtered = compose(tree, prov, rootId);
-
-        // Both should have same number of lines (only one root anyway)
-        QCOMPARE(full.meta.size(), filtered.meta.size());
-    }
-
-    void testDocument_compose_viewRootId() {
-        // Test RcxDocument::compose passes viewRootId through
-        RcxDocument doc;
-        doc.tree = makeTwoRootTree();
-        uint64_t alphaId = doc.tree.nodes[0].id;
-
-        ComposeResult fullResult = doc.compose(0);
-        ComposeResult filtered = doc.compose(alphaId);
-
-        // Filtered should have fewer lines than full
-        QVERIFY(filtered.meta.size() < fullResult.meta.size());
-
-        // Filtered should have Alpha's fields
-        bool foundFlagsA = false;
-        for (const QString& l : filtered.text.split('\n')) {
-            if (l.contains("flagsA")) foundFlagsA = true;
-        }
-        QVERIFY(foundFlagsA);
-    }
-
-    // ═══════════════════════════════════════════════════
-    // Feature 2: Project Lifecycle API (document-level)
-    // ═══════════════════════════════════════════════════
-
-    void testDocument_saveLoadPreservesData() {
-        // Verify save/load round-trip preserves tree + aliases + baseAddress
-        QTemporaryFile tmpFile;
-        tmpFile.setAutoRemove(true);
-        QVERIFY(tmpFile.open());
-        QString path = tmpFile.fileName();
-        tmpFile.close();
-
-        {
-            RcxDocument doc;
-            doc.tree = makeTwoRootTree();
-            doc.tree.baseAddress = 0xDEADBEEF;
-            doc.typeAliases[NodeKind::Int32] = "INT";
-            QVERIFY(doc.save(path));
-        }
-
-        {
-            RcxDocument doc;
-            QVERIFY(doc.load(path));
-            QCOMPARE(doc.tree.baseAddress, (uint64_t)0xDEADBEEF);
-            QCOMPARE(doc.tree.nodes.size(), 4);  // 2 roots + 2 fields
-            QCOMPARE(doc.typeAliases.value(NodeKind::Int32), QString("INT"));
-            QCOMPARE(doc.filePath, path);
-            QVERIFY(!doc.modified);
-        }
-    }
-
-    void testDocument_saveCreatesFile() {
-        QTemporaryFile tmpFile;
-        tmpFile.setAutoRemove(true);
-        QVERIFY(tmpFile.open());
-        QString path = tmpFile.fileName();
-        tmpFile.close();
-
-        RcxDocument doc;
-        doc.tree = makeSimpleTree();
-        QVERIFY(doc.save(path));
-        QCOMPARE(doc.filePath, path);
-        QVERIFY(!doc.modified);
-
-        // Verify file exists and is valid JSON
-        QFile file(path);
-        QVERIFY(file.open(QIODevice::ReadOnly));
-        QJsonDocument jdoc = QJsonDocument::fromJson(file.readAll());
-        QVERIFY(!jdoc.isNull());
-        QVERIFY(jdoc.object().contains("nodes"));
-    }
-
-    void testDocument_loadInvalidPath() {
-        RcxDocument doc;
-        QVERIFY(!doc.load("/nonexistent/path/file.rcx"));
-    }
-
-    // ═══════════════════════════════════════════════════
-    // Integration: Type aliases + compose + generator
-    // ═══════════════════════════════════════════════════
-
-    // ═══════════════════════════════════════════════════
-    // Feature 4: Workspace Model
-    // ═══════════════════════════════════════════════════
-
-    void testWorkspace_simpleTree() {
-        auto tree = makeSimpleTree();
-        QStandardItemModel model;
-        QVector<TabInfo> tabs = {{ &tree, "TestProject.rcx", nullptr }};
-        buildProjectExplorer(&model, tabs);
-
-        // Flat model: Player at root (has 2 non-hex members → lazy placeholder)
-        QCOMPARE(model.rowCount(), 1);
-        QVERIFY(model.item(0)->text().contains("Player"));
-        QVERIFY(model.item(0)->text().contains("struct"));
-        QVERIFY(model.item(0)->rowCount() > 0);  // children populated directly
-    }
-
-    void testWorkspace_twoRootTree() {
-        auto tree = makeTwoRootTree();
-        QStandardItemModel model;
-        QVector<TabInfo> tabs = {{ &tree, "TwoRoot.rcx", nullptr }};
-        buildProjectExplorer(&model, tabs);
-
-        // Flat model: 2 types at root
-        QCOMPARE(model.rowCount(), 2);
-        QVERIFY(model.item(0)->text().contains("Alpha"));
-        QVERIFY(model.item(1)->text().contains("Bravo"));
-    }
-
-    void testWorkspace_richTree_rootCount() {
-        auto tree = makeRichTree();
-        QStandardItemModel model;
-        QVector<TabInfo> tabs = {{ &tree, "Rich.rcx", nullptr }};
-        buildProjectExplorer(&model, tabs);
-
-        QCOMPARE(model.rowCount(), 3);  // Ball, Cat, Pet
-    }
-
-    void testWorkspace_richTree_insertionOrder() {
-        auto tree = makeRichTree();
-        QStandardItemModel model;
-        QVector<TabInfo> tabs = {{ &tree, "Rich.rcx", nullptr }};
-        buildProjectExplorer(&model, tabs);
-
-        // Types at root in insertion order: Pet, Cat, Ball
-        QVERIFY(model.item(0)->text().contains("Pet"));
-        QVERIFY(model.item(1)->text().contains("Cat"));
-        QVERIFY(model.item(2)->text().contains("Ball"));
-    }
-
-    void testWorkspace_emptyTree() {
-        NodeTree tree;
-        QStandardItemModel model;
-        QVector<TabInfo> tabs = {{ &tree, "Empty.rcx", nullptr }};
-        buildProjectExplorer(&model, tabs);
-
-        // Flat model: no types means no rows
-        QCOMPARE(model.rowCount(), 0);
-    }
-
-    void testWorkspace_structIdRole() {
-        auto tree = makeSimpleTree();
-        QStandardItemModel model;
-        QVector<TabInfo> tabs = {{ &tree, "Test.rcx", nullptr }};
-        buildProjectExplorer(&model, tabs);
-
-        // Flat model: first item is the Player type with its structId
-        QVERIFY(model.rowCount() > 0);
-        QStandardItem* player = model.item(0);
-        QVERIFY(player->data(Qt::UserRole + 1).isValid());
-        QVERIFY(player->data(Qt::UserRole + 1).toULongLong() > 0);
-    }
-
-    // ═══════════════════════════════════════════════════
-    // Feature: Double-click navigation (viewRootId + scroll)
-    // ═══════════════════════════════════════════════════
-
-    void testDoubleClick_switchToCollapsedClass() {
-        // Simulates: Ball is collapsed (hidden). Double-click Ball in workspace
-        // → uncollapse, set viewRootId, compose shows only Ball with children.
-        RcxDocument doc;
-        doc.tree = makeRichTree();
-
-        // Collapse Ball (3rd root struct)
-        uint64_t ballId = 0;
-        for (auto& node : doc.tree.nodes) {
-            if (node.parentId == 0 && node.kind == NodeKind::Struct
-                && node.structTypeName == "Ball") {
-                node.collapsed = true;
-                ballId = node.id;
-                break;
-            }
-        }
-        QVERIFY(ballId != 0);
-
-        // Compose with viewRootId=0 should skip collapsed Ball
-        {
-            NullProvider prov;
-            ComposeResult result = compose(doc.tree, prov, 0);
-            bool foundSpeed = false;
-            for (const auto& lm : result.meta) {
-                int ni = lm.nodeIdx;
-                if (ni >= 0 && ni < doc.tree.nodes.size()
-                    && doc.tree.nodes[ni].name == "speed")
-                    foundSpeed = true;
-            }
-            QVERIFY2(!foundSpeed, "Collapsed Ball's children should not appear with viewRootId=0");
-        }
-
-        // Simulate double-click: uncollapse Ball + set viewRootId
-        int bi = doc.tree.indexOfId(ballId);
-        QVERIFY(bi >= 0);
-        doc.tree.nodes[bi].collapsed = false;
-
-        // Compose with viewRootId=Ball should show Ball and its children
-        {
-            NullProvider prov;
-            ComposeResult result = compose(doc.tree, prov, ballId);
-            bool foundSpeed = false, foundPosition = false, foundColor = false;
-            for (const auto& lm : result.meta) {
-                int ni = lm.nodeIdx;
-                if (ni < 0 || ni >= doc.tree.nodes.size()) continue;
-                const QString& name = doc.tree.nodes[ni].name;
-                if (name == "speed")    foundSpeed = true;
-                if (name == "position") foundPosition = true;
-                if (name == "color")    foundColor = true;
-            }
-            QVERIFY2(foundSpeed, "Ball's speed field should appear");
-            QVERIFY2(foundPosition, "Ball's position field should appear");
-            QVERIFY2(foundColor, "Ball's color field should appear");
-        }
-
-        // Pet/Cat fields should NOT be in the Ball-filtered result
-        {
-            NullProvider prov;
-            ComposeResult result = compose(doc.tree, prov, ballId);
-            bool foundPetField = false;
-            for (const auto& lm : result.meta) {
-                int ni = lm.nodeIdx;
-                if (ni < 0 || ni >= doc.tree.nodes.size()) continue;
-                if (doc.tree.nodes[ni].name == "owner") foundPetField = true;
-            }
-            QVERIFY2(!foundPetField, "Pet's owner should not appear when viewing Ball");
-        }
-    }
-
-    void testDoubleClick_fieldNavigatesToParentRoot() {
-        // Simulates: double-click a field inside Ball → walk up to Ball root,
-        // set viewRootId to Ball, and the field should be in the compose output.
-        RcxDocument doc;
-        doc.tree = makeRichTree();
-
-        // Find Ball's "speed" child
-        uint64_t ballId = 0, speedId = 0;
-        for (auto& node : doc.tree.nodes) {
-            if (node.parentId == 0 && node.structTypeName == "Ball")
-                ballId = node.id;
-        }
-        QVERIFY(ballId != 0);
-        for (auto& node : doc.tree.nodes) {
-            if (node.parentId == ballId && node.name == "speed")
-                speedId = node.id;
-        }
-        QVERIFY(speedId != 0);
-
-        // Walk up from speed to find root struct (simulating handler logic)
-        uint64_t rootId = 0;
-        uint64_t cur = speedId;
-        while (cur != 0) {
-            int idx = doc.tree.indexOfId(cur);
-            if (idx < 0) break;
-            if (doc.tree.nodes[idx].parentId == 0) { rootId = cur; break; }
-            cur = doc.tree.nodes[idx].parentId;
-        }
-        QCOMPARE(rootId, ballId);
-
-        // Compose with viewRootId=Ball should contain speed
-        NullProvider prov;
-        ComposeResult result = compose(doc.tree, prov, ballId);
-        bool foundSpeed = false;
-        for (const auto& lm : result.meta) {
-            if (lm.nodeId == speedId) { foundSpeed = true; break; }
-        }
-        QVERIFY2(foundSpeed, "speed field should be in compose output when viewing its root");
-    }
-
-    void testDoubleClick_projectRootShowsAll() {
-        // Double-click project root clears viewRootId → all non-collapsed roots shown
-        RcxDocument doc;
-        doc.tree = makeRichTree();
-
-        // Collapse Ball
-        for (auto& node : doc.tree.nodes) {
-            if (node.parentId == 0 && node.structTypeName == "Ball")
-                node.collapsed = true;
-        }
-
-        // viewRootId=0 → Pet and Cat visible, Ball hidden
-        NullProvider prov;
-        ComposeResult result = compose(doc.tree, prov, 0);
-        bool foundOwner = false, foundWhiskerLen = false, foundSpeed = false;
-        for (const auto& lm : result.meta) {
-            int ni = lm.nodeIdx;
-            if (ni < 0 || ni >= doc.tree.nodes.size()) continue;
-            const QString& name = doc.tree.nodes[ni].name;
-            if (name == "owner")      foundOwner = true;
-            if (name == "whiskerLen") foundWhiskerLen = true;
-            if (name == "speed")      foundSpeed = true;
-        }
-        QVERIFY2(foundOwner, "Pet's owner should appear with viewRootId=0");
-        QVERIFY2(foundWhiskerLen, "Cat's whiskerLen should appear with viewRootId=0");
-        QVERIFY2(!foundSpeed, "Collapsed Ball's speed should not appear with viewRootId=0");
-    }
-
-    // ═══════════════════════════════════════════════════
-    // Integration: Type aliases + compose + generator
-    // ═══════════════════════════════════════════════════
-
-    void testAliasesPreservedThroughSaveReloadCompose() {
-        // Full workflow: set aliases, save, reload, compose + generate
-        QTemporaryFile tmpFile;
-        tmpFile.setAutoRemove(true);
-        QVERIFY(tmpFile.open());
-        QString path = tmpFile.fileName();
-        tmpFile.close();
-
-        auto tree = makeSimpleTree();
-
-        // Save with aliases
-        {
-            RcxDocument doc;
-            doc.tree = tree;
-            doc.typeAliases[NodeKind::Int32] = "my_int32";
-            doc.typeAliases[NodeKind::Float] = "my_float";
-            QVERIFY(doc.save(path));
-        }
-
-        // Reload and verify compose + generate work
-        {
-            RcxDocument doc;
-            QVERIFY(doc.load(path));
-
-            // Compose should succeed
-            ComposeResult result = doc.compose();
-            QVERIFY(result.meta.size() > 0);
-
-            // Generator should use aliases
-            uint64_t rootId = doc.tree.nodes[0].id;
-            const QHash<NodeKind, QString>* aliases =
-                doc.typeAliases.isEmpty() ? nullptr : &doc.typeAliases;
-            QString cpp = renderCpp(doc.tree, rootId, aliases);
-            QVERIFY(cpp.contains("my_int32 health;"));
-            QVERIFY(cpp.contains("my_float speed;"));
-        }
-    }
-    void testVec4SingleLineValue() {
-        NodeTree tree;
-        tree.baseAddress = 0;
-
-        Node root;
-        root.kind = NodeKind::Struct;
-        root.name = "Obj";
-        root.parentId = 0;
-        int ri = tree.addNode(root);
-        uint64_t rootId = tree.nodes[ri].id;
-
-        Node v;
-        v.kind = NodeKind::Vec4;
-        v.name = "position";
-        v.parentId = rootId;
-        v.offset = 0;
-        tree.addNode(v);
-
-        NullProvider prov;
-        ComposeResult result = compose(tree, prov);
-
-        // CommandRow + 1 Vec4 line + footer = 3
-        QCOMPARE(result.meta.size(), 3);
-
-        // The Vec4 line (index 1) is a single field line, not continuation
-        QCOMPARE(result.meta[1].lineKind, LineKind::Field);
-        QCOMPARE(result.meta[1].nodeKind, NodeKind::Vec4);
-        QVERIFY(!result.meta[1].isContinuation);
-
-        // Copy text (equivalent to editor's "Copy All as Text")
-        QString text = result.text;
-        // NullProvider reads 0 for all floats, values are "0.f, 0.f, 0.f, 0.f"
-        QVERIFY(text.contains("0.f, 0.f, 0.f, 0.f"));
-        // Confirm type, name, and values all on the same line
-        QStringList lines = text.split('\n');
-        QVERIFY(lines[1].contains("vec4"));
-        QVERIFY(lines[1].contains("position"));
-        QVERIFY(lines[1].contains("0.f, 0.f, 0.f, 0.f"));
-    }
-};
-
-QTEST_MAIN(TestNewFeatures)
-#include "test_new_features.moc"
diff --git a/tests/test_typeinfer.cpp b/tests/test_typeinfer.cpp
index 208f0bb..ff71d9e 100644
--- a/tests/test_typeinfer.cpp
+++ b/tests/test_typeinfer.cpp
@@ -125,39 +125,27 @@ private slots:
         QVERIFY(r[0].kinds[0] == NodeKind::Int16 || r[0].kinds[0] == NodeKind::UInt16);
     }
 
-    // ── Hex8: bool-like ──
-    void hex8_bool() {
+    // ── Hex8: uint8 ──
+    void hex8_uint() {
         uint8_t d[1] = {1};
         auto r = inferTypes(d, 1);
         QVERIFY(!r.isEmpty());
-        bool foundBool = false;
-        for (const auto& s : r)
-            if (s.kinds.size() == 1 && s.kinds[0] == NodeKind::Bool)
-                foundBool = true;
-        QVERIFY(foundBool);
+        QCOMPARE(r[0].kinds[0], NodeKind::UInt8);
     }
 
     // ── formatHint ──
-    void formatHint_strong() {
+    void formatHint_single() {
         TypeSuggestion s;
         s.kinds = {NodeKind::Float};
         s.strength = 3;
-        QCOMPARE(formatHint(s), QStringLiteral("float strong"));
-    }
-    void formatHint_moderate() {
-        TypeSuggestion s;
-        s.kinds = {NodeKind::Float};
-        s.strength = 2;
-        QCOMPARE(formatHint(s), QStringLiteral("float moderate"));
+        QCOMPARE(formatHint(s), QStringLiteral("float"));
     }
     void formatHint_split() {
         TypeSuggestion s;
         s.kinds = {NodeKind::Float, NodeKind::Float};
         s.strength = 3;
         QString h = formatHint(s);
-        QVERIFY(h.contains("float"));
-        QVERIFY(h.contains("2"));
-        QVERIFY(h.endsWith("strong"));
+        QCOMPARE(h, QStringLiteral("float\u00D72"));
     }
 
     // ── Denormal rejection ──
diff --git a/tests/test_validation.cpp b/tests/test_validation.cpp
deleted file mode 100644
index 5c10cb3..0000000
--- a/tests/test_validation.cpp
+++ /dev/null
@@ -1,1129 +0,0 @@
-// Stress tests for editor/controller validation:
-// – Invalid values, boundary values, excessive inputs
-// – Ensures no crashes and data integrity after rejected edits
-// Skips: ASCII/byte preview editing (under discussion)
-
-#include <QtTest/QTest>
-#include <QtTest/QSignalSpy>
-#include <QApplication>
-#include <QSplitter>
-#include <Qsci/qsciscintilla.h>
-#include "controller.h"
-#include "core.h"
-
-using namespace rcx;
-
-// ── Fixture: small tree with diverse field types ──
-
-static void buildValidationTree(NodeTree& tree) {
-    tree.baseAddress = 0;
-
-    Node root;
-    root.kind = NodeKind::Struct;
-    root.structTypeName = "TestStruct";
-    root.name = "root";
-    root.parentId = 0;
-    root.offset = 0;
-    int ri = tree.addNode(root);
-    uint64_t rootId = tree.nodes[ri].id;
-
-    auto field = [&](int off, NodeKind k, const char* name) {
-        Node n;
-        n.kind = k; n.name = name;
-        n.parentId = rootId; n.offset = off;
-        tree.addNode(n);
-    };
-    auto fieldArr = [&](int off, NodeKind ek, int count, const char* name) {
-        Node n;
-        n.kind = NodeKind::Array; n.name = name;
-        n.parentId = rootId; n.offset = off;
-        n.arrayLen = count; n.elementKind = ek;
-        tree.addNode(n);
-    };
-
-    field(0,  NodeKind::Int8,       "field_i8");
-    field(1,  NodeKind::UInt8,      "field_u8");
-    field(2,  NodeKind::Int16,      "field_i16");
-    field(4,  NodeKind::UInt16,     "field_u16");
-    field(6,  NodeKind::Int32,      "field_i32");
-    field(10, NodeKind::UInt32,     "field_u32");
-    field(14, NodeKind::Int64,      "field_i64");
-    field(22, NodeKind::UInt64,     "field_u64");
-    field(30, NodeKind::Float,      "field_float");
-    field(34, NodeKind::Double,     "field_dbl");
-    field(42, NodeKind::Bool,       "field_bool");
-    field(43, NodeKind::Hex8,       "field_h8");
-    field(44, NodeKind::Hex16,      "field_h16");
-    field(46, NodeKind::Hex32,      "field_h32");
-    field(50, NodeKind::Hex64,      "field_h64");
-    field(58, NodeKind::Pointer64,  "field_ptr");
-    field(66, NodeKind::Hex32,      "pad0");
-    field(70, NodeKind::Hex16,      "pad1");
-    fieldArr(72, NodeKind::UInt32, 4, "field_arr");
-}
-
-static QByteArray makeValidationBuffer() {
-    QByteArray data(256, '\0');
-    // i8 = -5
-    data[0] = (char)(int8_t)-5;
-    // u8 = 0x42
-    data[1] = 0x42;
-    // i16 = -1000
-    int16_t i16v = -1000;
-    memcpy(data.data() + 2, &i16v, 2);
-    // u16 = 60000
-    uint16_t u16v = 60000;
-    memcpy(data.data() + 4, &u16v, 2);
-    // i32 = -100000
-    int32_t i32v = -100000;
-    memcpy(data.data() + 6, &i32v, 4);
-    // u32 = 0xDEADBEEF
-    uint32_t u32v = 0xDEADBEEF;
-    memcpy(data.data() + 10, &u32v, 4);
-    // i64 = -1
-    int64_t i64v = -1;
-    memcpy(data.data() + 14, &i64v, 8);
-    // u64 = UINT64_MAX
-    uint64_t u64v = ~0ULL;
-    memcpy(data.data() + 22, &u64v, 8);
-    // float = 3.14f
-    float fv = 3.14f;
-    memcpy(data.data() + 30, &fv, 4);
-    // double = 2.718
-    double dv = 2.718;
-    memcpy(data.data() + 34, &dv, 8);
-    // bool = 1
-    data[42] = 1;
-    // hex8 = 0xAB
-    data[43] = (char)0xAB;
-    // hex16 = 0xCAFE
-    uint16_t h16 = 0xCAFE;
-    memcpy(data.data() + 44, &h16, 2);
-    // hex32 = 0xBAADF00D
-    uint32_t h32 = 0xBAADF00D;
-    memcpy(data.data() + 46, &h32, 4);
-    // hex64 = 0xDEADC0DEDEADBEEF
-    uint64_t h64 = 0xDEADC0DEDEADBEEFULL;
-    memcpy(data.data() + 50, &h64, 8);
-    // pointer = 0x7FFE3B8D4260
-    uint64_t ptr = 0x00007FFE3B8D4260ULL;
-    memcpy(data.data() + 58, &ptr, 8);
-    return data;
-}
-
-// ── Helper: find node index by name ──
-
-static int findNode(const NodeTree& tree, const char* name) {
-    for (int i = 0; i < tree.nodes.size(); i++)
-        if (tree.nodes[i].name == name) return i;
-    return -1;
-}
-
-// ══════════════════════════════════════════════════════════════════════
-// Part 1: Pure unit tests – fmt::parseValue / fmt::validateValue
-// These are mixed into TestValidationController so they all run under
-// one QTEST_MAIN. The init()/cleanup() create GUI fixtures but the
-// pure parsing tests simply don't use them.
-// ══════════════════════════════════════════════════════════════════════
-
-// (forward-declared — tests are added as slots of TestValidationController below)
-
-// ══════════════════════════════════════════════════════════════════════
-// Part 2: Controller-level stress tests (requires GUI)
-// Tests that invalid inputs through the controller API don't corrupt data.
-// ══════════════════════════════════════════════════════════════════════
-
-class TestValidationController : public QObject {
-    Q_OBJECT
-private:
-    RcxDocument* m_doc = nullptr;
-    RcxController* m_ctrl = nullptr;
-    QSplitter* m_splitter = nullptr;
-    RcxEditor* m_editor = nullptr;
-
-    QByteArray snapshotProvider() {
-        return m_doc->provider->readBytes(m_doc->tree.baseAddress,
-                                          m_doc->provider->isReadable(m_doc->tree.baseAddress, 256) ? 256 : 0);
-    }
-
-private slots:
-
-    void init() {
-        m_doc = new RcxDocument();
-        buildValidationTree(m_doc->tree);
-        m_doc->provider = std::make_unique<BufferProvider>(makeValidationBuffer());
-
-        m_splitter = new QSplitter();
-        m_ctrl = new RcxController(m_doc, nullptr);
-        m_editor = m_ctrl->addSplitEditor(m_splitter);
-
-        m_splitter->resize(800, 600);
-        m_splitter->show();
-        QVERIFY(QTest::qWaitForWindowExposed(m_splitter));
-        QApplication::processEvents();
-    }
-
-    void cleanup() {
-        delete m_ctrl;  m_ctrl = nullptr; m_editor = nullptr;
-        delete m_splitter; m_splitter = nullptr;
-        delete m_doc; m_doc = nullptr;
-    }
-
-    // ════════════════════════════════════════════════════════
-    // Pure parsing/validation tests (no GUI interaction)
-    // ════════════════════════════════════════════════════════
-
-    // ── Integer overflow: values that exceed type max ──
-
-    void testInt8Overflow() {
-        bool ok;
-        // Max int8 = 127, min = -128
-        fmt::parseValue(NodeKind::Int8, "128", &ok);
-        QVERIFY2(!ok, "128 overflows int8");
-
-        fmt::parseValue(NodeKind::Int8, "-129", &ok);
-        QVERIFY2(!ok, "-129 underflows int8");
-
-        fmt::parseValue(NodeKind::Int8, "127", &ok);
-        QVERIFY(ok);
-
-        fmt::parseValue(NodeKind::Int8, "-128", &ok);
-        QVERIFY(ok);
-
-        // Hex overflow: 0x100 > 0xFF
-        fmt::parseValue(NodeKind::Int8, "0x100", &ok);
-        QVERIFY2(!ok, "0x100 overflows int8 hex");
-
-        fmt::parseValue(NodeKind::Int8, "0xFF", &ok);
-        QVERIFY(ok);
-    }
-
-    void testUInt8Overflow() {
-        bool ok;
-        fmt::parseValue(NodeKind::UInt8, "256", &ok);
-        QVERIFY2(!ok, "256 overflows uint8");
-
-        fmt::parseValue(NodeKind::UInt8, "255", &ok);
-        QVERIFY(ok);
-
-        fmt::parseValue(NodeKind::UInt8, "0", &ok);
-        QVERIFY(ok);
-
-        // Negative should fail for unsigned
-        fmt::parseValue(NodeKind::UInt8, "-1", &ok);
-        QVERIFY2(!ok, "Negative should fail for uint8");
-    }
-
-    void testInt16Overflow() {
-        bool ok;
-        fmt::parseValue(NodeKind::Int16, "32768", &ok);
-        QVERIFY2(!ok, "32768 overflows int16");
-
-        fmt::parseValue(NodeKind::Int16, "-32769", &ok);
-        QVERIFY2(!ok, "-32769 underflows int16");
-
-        fmt::parseValue(NodeKind::Int16, "32767", &ok);
-        QVERIFY(ok);
-
-        fmt::parseValue(NodeKind::Int16, "-32768", &ok);
-        QVERIFY(ok);
-
-        fmt::parseValue(NodeKind::Int16, "0x10000", &ok);
-        QVERIFY2(!ok, "0x10000 overflows int16 hex");
-    }
-
-    void testUInt16Overflow() {
-        bool ok;
-        fmt::parseValue(NodeKind::UInt16, "65536", &ok);
-        QVERIFY2(!ok, "65536 overflows uint16");
-
-        fmt::parseValue(NodeKind::UInt16, "65535", &ok);
-        QVERIFY(ok);
-    }
-
-    void testInt32Overflow() {
-        bool ok;
-        // 2147483647 is INT32_MAX
-        fmt::parseValue(NodeKind::Int32, "2147483647", &ok);
-        QVERIFY(ok);
-
-        // 2147483648 overflows signed int32 in decimal
-        // Note: toInt returns false for overflow
-        fmt::parseValue(NodeKind::Int32, "2147483648", &ok);
-        QVERIFY2(!ok, "2147483648 overflows int32 decimal");
-
-        fmt::parseValue(NodeKind::Int32, "0xFFFFFFFF", &ok);
-        QVERIFY(ok);  // hex path allows up to 0xFFFFFFFF
-
-        fmt::parseValue(NodeKind::Int32, "0x100000000", &ok);
-        QVERIFY2(!ok, "0x100000000 overflows int32 hex");
-    }
-
-    void testUInt32Overflow() {
-        bool ok;
-        fmt::parseValue(NodeKind::UInt32, "4294967295", &ok);
-        QVERIFY(ok);
-
-        fmt::parseValue(NodeKind::UInt32, "4294967296", &ok);
-        QVERIFY2(!ok, "4294967296 overflows uint32");
-    }
-
-    void testUInt64Max() {
-        bool ok;
-        // UINT64_MAX = 18446744073709551615
-        fmt::parseValue(NodeKind::UInt64, "18446744073709551615", &ok);
-        QVERIFY(ok);
-
-        // Beyond UINT64_MAX should fail to parse
-        fmt::parseValue(NodeKind::UInt64, "18446744073709551616", &ok);
-        QVERIFY2(!ok, "UINT64_MAX+1 should fail");
-
-        fmt::parseValue(NodeKind::UInt64, "0xFFFFFFFFFFFFFFFF", &ok);
-        QVERIFY(ok);
-    }
-
-    // ── Invalid characters in numeric fields ──
-
-    void testInvalidCharsInIntegers() {
-        bool ok;
-        fmt::parseValue(NodeKind::Int32, "12abc", &ok);
-        QVERIFY(!ok);
-
-        fmt::parseValue(NodeKind::UInt32, "hello", &ok);
-        QVERIFY(!ok);
-
-        fmt::parseValue(NodeKind::Int8, "3.14", &ok);
-        QVERIFY(!ok);  // Not a valid integer
-
-        fmt::parseValue(NodeKind::UInt16, "", &ok);
-        QVERIFY(!ok);  // Empty string fails for non-string types
-    }
-
-    void testInvalidCharsInHex() {
-        bool ok;
-        fmt::parseValue(NodeKind::Hex32, "GHIJKL", &ok);
-        QVERIFY(!ok);
-
-        fmt::parseValue(NodeKind::Hex64, "0xZZZZ", &ok);
-        QVERIFY(!ok);
-
-        fmt::parseValue(NodeKind::Hex8, "XY", &ok);
-        QVERIFY(!ok);
-    }
-
-    // ── Hex wrong byte count ──
-
-    void testHexWrongByteCount() {
-        bool ok;
-        // Hex32 expects 4 bytes when space-separated
-        fmt::parseValue(NodeKind::Hex32, "AA BB CC DD EE", &ok);
-        QVERIFY2(!ok, "5 bytes should fail for Hex32");
-
-        fmt::parseValue(NodeKind::Hex32, "AA BB", &ok);
-        QVERIFY2(!ok, "2 bytes should fail for Hex32");
-
-        // Correct: 4 bytes
-        fmt::parseValue(NodeKind::Hex32, "AA BB CC DD", &ok);
-        QVERIFY(ok);
-
-        // Hex64 expects 8 bytes
-        fmt::parseValue(NodeKind::Hex64, "AA BB CC DD", &ok);
-        QVERIFY2(!ok, "4 bytes should fail for Hex64");
-
-        fmt::parseValue(NodeKind::Hex64, "AA BB CC DD EE FF 00 11", &ok);
-        QVERIFY(ok);
-    }
-
-    // ── Float/Double edge cases ──
-
-    void testFloatEdgeCases() {
-        bool ok;
-        // Valid floats
-        fmt::parseValue(NodeKind::Float, "0", &ok);
-        QVERIFY(ok);
-
-        fmt::parseValue(NodeKind::Float, "-0.0", &ok);
-        QVERIFY(ok);
-
-        fmt::parseValue(NodeKind::Float, "1e38", &ok);
-        QVERIFY(ok);
-
-        // EU comma separator (converted to dot internally)
-        fmt::parseValue(NodeKind::Float, "3,14", &ok);
-        QVERIFY(ok);
-
-        // Junk
-        fmt::parseValue(NodeKind::Float, "not_a_number", &ok);
-        QVERIFY(!ok);
-
-        fmt::parseValue(NodeKind::Float, "", &ok);
-        QVERIFY(!ok);
-    }
-
-    void testDoubleEdgeCases() {
-        bool ok;
-        fmt::parseValue(NodeKind::Double, "1.7976931348623157e+308", &ok);
-        QVERIFY(ok);
-
-        fmt::parseValue(NodeKind::Double, "abc", &ok);
-        QVERIFY(!ok);
-
-        fmt::parseValue(NodeKind::Double, "1,5", &ok);
-        QVERIFY(ok);  // EU comma
-    }
-
-    // ── Bool: only "true"/"false"/"0"/"1" are valid ──
-
-    void testBoolInvalid() {
-        bool ok;
-        fmt::parseValue(NodeKind::Bool, "true", &ok);
-        QVERIFY(ok);
-
-        fmt::parseValue(NodeKind::Bool, "false", &ok);
-        QVERIFY(ok);
-
-        fmt::parseValue(NodeKind::Bool, "1", &ok);
-        QVERIFY(ok);
-
-        fmt::parseValue(NodeKind::Bool, "0", &ok);
-        QVERIFY(ok);
-
-        // Invalid: "yes", "no", "2", random text
-        fmt::parseValue(NodeKind::Bool, "yes", &ok);
-        QVERIFY2(!ok, "'yes' is not valid bool");
-
-        fmt::parseValue(NodeKind::Bool, "no", &ok);
-        QVERIFY2(!ok, "'no' is not valid bool");
-
-        fmt::parseValue(NodeKind::Bool, "2", &ok);
-        QVERIFY2(!ok, "'2' is not valid bool");
-
-        fmt::parseValue(NodeKind::Bool, "TRUE", &ok);
-        QVERIFY2(!ok, "'TRUE' (uppercase) is not valid bool");
-
-        fmt::parseValue(NodeKind::Bool, "", &ok);
-        QVERIFY(!ok);
-    }
-
-    // ── Pointer: hex-only parsing ──
-
-    void testPointerInvalid() {
-        bool ok;
-        // Valid
-        fmt::parseValue(NodeKind::Pointer64, "0x7FFE3B8D4260", &ok);
-        QVERIFY(ok);
-
-        fmt::parseValue(NodeKind::Pointer64, "7FFE3B8D4260", &ok);
-        QVERIFY(ok);
-
-        // Invalid chars
-        fmt::parseValue(NodeKind::Pointer64, "0xGGGG", &ok);
-        QVERIFY(!ok);
-
-        // Pointer32 overflow
-        fmt::parseValue(NodeKind::Pointer32, "0x100000000", &ok);
-        QVERIFY2(!ok, "0x100000000 overflows ptr32");
-
-        fmt::parseValue(NodeKind::Pointer32, "0xFFFFFFFF", &ok);
-        QVERIFY(ok);
-    }
-
-    // ── validateValue: error message testing ──
-
-    void testValidateValueMessages() {
-        // Hex kind with non-hex chars → character-level error
-        QString err = fmt::validateValue(NodeKind::Hex32, "GGGG");
-        QVERIFY(!err.isEmpty());
-        QVERIFY(err.contains("invalid hex"));
-
-        // Int kind overflow → "too large" message
-        err = fmt::validateValue(NodeKind::UInt8, "999");
-        QVERIFY(!err.isEmpty());
-        QVERIFY(err.contains("too large"));
-
-        // Decimal with non-digit
-        err = fmt::validateValue(NodeKind::UInt32, "12!3");
-        QVERIFY(!err.isEmpty());
-        QVERIFY(err.contains("invalid"));
-
-        // Signed integer with leading minus accepted
-        err = fmt::validateValue(NodeKind::Int32, "-42");
-        QVERIFY2(err.isEmpty(), qPrintable("Negative int32 should be valid: " + err));
-
-        // Unsigned with minus → invalid
-        err = fmt::validateValue(NodeKind::UInt32, "-1");
-        QVERIFY(!err.isEmpty());
-
-        // Float junk
-        err = fmt::validateValue(NodeKind::Float, "abc");
-        QVERIFY(!err.isEmpty());
-        QVERIFY(err.contains("invalid number"));
-
-        // Empty is valid (special case)
-        err = fmt::validateValue(NodeKind::UInt32, "");
-        QVERIFY(err.isEmpty());
-
-        // Spaces only trimmed to empty → valid
-        err = fmt::validateValue(NodeKind::UInt32, "   ");
-        QVERIFY(err.isEmpty());
-    }
-
-    // ── validateBaseAddress: equation syntax ──
-
-    void testValidateBaseAddressEdgeCases() {
-        // Valid cases
-        QVERIFY(fmt::validateBaseAddress("0x1000").isEmpty());
-        QVERIFY(fmt::validateBaseAddress("1000").isEmpty());
-        QVERIFY(fmt::validateBaseAddress("0x1000 + 0x100").isEmpty());
-        QVERIFY(fmt::validateBaseAddress("0x2000 - 0x10").isEmpty());
-        QVERIFY(fmt::validateBaseAddress("0x400+0x200-0x100").isEmpty());
-        QVERIFY(fmt::validateBaseAddress("  0xDEAD  ").isEmpty());
-
-        // Invalid cases
-        QVERIFY(!fmt::validateBaseAddress("").isEmpty());   // empty
-        QVERIFY(!fmt::validateBaseAddress("  ").isEmpty()); // whitespace only - no hex digits
-        QVERIFY(!fmt::validateBaseAddress("0xGGGG").isEmpty());
-        QVERIFY(fmt::validateBaseAddress("0x1000 * 2").isEmpty());   // multiplication supported
-        QVERIFY(!fmt::validateBaseAddress("0x1000 ++ 0x100").isEmpty());  // double operator
-        QVERIFY(!fmt::validateBaseAddress("hello").isEmpty());
-    }
-
-    // ── Extremely long strings ──
-
-    void testExtremelyLongInput() {
-        bool ok;
-        // 10000-char string of hex digits
-        QString longHex = QString("F").repeated(10000);
-        fmt::parseValue(NodeKind::Hex32, longHex, &ok);
-        // Should either fail or succeed gracefully (no crash)
-        // For Hex32 continuous mode, this is a valid huge hex number that overflows uint32
-        Q_UNUSED(ok);  // Just testing it doesn't crash
-
-        // Long garbage
-        QString longJunk = QString("@#$%^&*").repeated(1000);
-        fmt::parseValue(NodeKind::Int32, longJunk, &ok);
-        QVERIFY(!ok);
-
-        // Very long decimal number
-        QString longDec = QString("9").repeated(100);
-        fmt::parseValue(NodeKind::UInt64, longDec, &ok);
-        QVERIFY(!ok);  // Way beyond UINT64_MAX
-
-        // Extremely long hex for parseValue
-        fmt::parseValue(NodeKind::Hex64, "0x" + QString("F").repeated(200), &ok);
-        // No crash is the test
-    }
-
-    // ── Special/weird characters ──
-
-    void testSpecialCharacters() {
-        bool ok;
-        fmt::parseValue(NodeKind::Int32, "\0", &ok);
-        QVERIFY(!ok);
-
-        fmt::parseValue(NodeKind::Int32, "\t42\n", &ok);
-        // trimmed internally — may or may not parse; just don't crash
-        Q_UNUSED(ok);
-
-        fmt::parseValue(NodeKind::UInt32, "  42  ", &ok);
-        QVERIFY(ok);  // Leading/trailing whitespace should be trimmed
-
-        // Unicode characters
-        fmt::parseValue(NodeKind::UInt32, QString::fromUtf8("\xC3\xA9"), &ok);  // é
-        QVERIFY(!ok);
-    }
-
-    // ── Container kinds: parseValue should fail gracefully ──
-
-    void testContainerKindParseValue() {
-        bool ok;
-        fmt::parseValue(NodeKind::Struct, "anything", &ok);
-        QVERIFY(!ok);
-
-        fmt::parseValue(NodeKind::Array, "42", &ok);
-        QVERIFY(!ok);
-    }
-
-    // ════════════════════════════════════════════════════════
-    // Controller-level stress tests (uses GUI fixtures)
-    // ════════════════════════════════════════════════════════
-
-    // ── setNodeValue rejects overflowing values without changing data ──
-
-    void testRejectOverflowInt8() {
-        int idx = findNode(m_doc->tree, "field_i8");
-        QVERIFY(idx >= 0);
-        uint64_t addr = m_doc->tree.computeOffset(idx);
-        QByteArray before = m_doc->provider->readBytes(addr, 1);
-
-        m_ctrl->setNodeValue(idx, 0, "999");
-        QApplication::processEvents();
-
-        QByteArray after = m_doc->provider->readBytes(addr, 1);
-        QCOMPARE(after, before);  // Data unchanged
-        QCOMPARE(m_doc->undoStack.count(), 0);  // No command pushed
-    }
-
-    void testRejectOverflowUInt8() {
-        int idx = findNode(m_doc->tree, "field_u8");
-        QVERIFY(idx >= 0);
-        uint64_t addr = m_doc->tree.computeOffset(idx);
-        QByteArray before = m_doc->provider->readBytes(addr, 1);
-
-        m_ctrl->setNodeValue(idx, 0, "256");
-        QApplication::processEvents();
-
-        QByteArray after = m_doc->provider->readBytes(addr, 1);
-        QCOMPARE(after, before);
-        QCOMPARE(m_doc->undoStack.count(), 0);
-    }
-
-    void testRejectOverflowUInt16() {
-        int idx = findNode(m_doc->tree, "field_u16");
-        QVERIFY(idx >= 0);
-        uint64_t addr = m_doc->tree.computeOffset(idx);
-        QByteArray before = m_doc->provider->readBytes(addr, 2);
-
-        m_ctrl->setNodeValue(idx, 0, "70000");
-        QApplication::processEvents();
-
-        QByteArray after = m_doc->provider->readBytes(addr, 2);
-        QCOMPARE(after, before);
-        QCOMPARE(m_doc->undoStack.count(), 0);
-    }
-
-    void testRejectOverflowUInt32() {
-        int idx = findNode(m_doc->tree, "field_u32");
-        QVERIFY(idx >= 0);
-        uint64_t addr = m_doc->tree.computeOffset(idx);
-        QByteArray before = m_doc->provider->readBytes(addr, 4);
-
-        m_ctrl->setNodeValue(idx, 0, "4294967296");
-        QApplication::processEvents();
-
-        QByteArray after = m_doc->provider->readBytes(addr, 4);
-        QCOMPARE(after, before);
-        QCOMPARE(m_doc->undoStack.count(), 0);
-    }
-
-    // ── setNodeValue rejects garbage text ──
-
-    void testRejectGarbageText() {
-        int idx = findNode(m_doc->tree, "field_u32");
-        QVERIFY(idx >= 0);
-        uint64_t addr = m_doc->tree.computeOffset(idx);
-        QByteArray before = m_doc->provider->readBytes(addr, 4);
-
-        // Various garbage inputs
-        const char* junk[] = {
-            "hello", "!@#$%", "", "   ", "0xGGGG", "3.14",
-            "true", "null", "NaN", "inf", "\t\n\r"
-        };
-        for (const char* s : junk) {
-            m_ctrl->setNodeValue(idx, 0, s);
-            QApplication::processEvents();
-        }
-
-        QByteArray after = m_doc->provider->readBytes(addr, 4);
-        QCOMPARE(after, before);
-        QCOMPARE(m_doc->undoStack.count(), 0);
-    }
-
-    void testRejectGarbageFloat() {
-        int idx = findNode(m_doc->tree, "field_float");
-        QVERIFY(idx >= 0);
-        uint64_t addr = m_doc->tree.computeOffset(idx);
-        QByteArray before = m_doc->provider->readBytes(addr, 4);
-
-        m_ctrl->setNodeValue(idx, 0, "not_a_number");
-        m_ctrl->setNodeValue(idx, 0, "");
-        m_ctrl->setNodeValue(idx, 0, "0xDEAD");  // hex not valid for float
-        QApplication::processEvents();
-
-        QByteArray after = m_doc->provider->readBytes(addr, 4);
-        QCOMPARE(after, before);
-        QCOMPARE(m_doc->undoStack.count(), 0);
-    }
-
-    void testRejectGarbageBool() {
-        int idx = findNode(m_doc->tree, "field_bool");
-        QVERIFY(idx >= 0);
-        uint64_t addr = m_doc->tree.computeOffset(idx);
-        QByteArray before = m_doc->provider->readBytes(addr, 1);
-
-        m_ctrl->setNodeValue(idx, 0, "yes");
-        m_ctrl->setNodeValue(idx, 0, "2");
-        m_ctrl->setNodeValue(idx, 0, "TRUE");
-        m_ctrl->setNodeValue(idx, 0, "maybe");
-        QApplication::processEvents();
-
-        QByteArray after = m_doc->provider->readBytes(addr, 1);
-        QCOMPARE(after, before);
-        QCOMPARE(m_doc->undoStack.count(), 0);
-    }
-
-    // ── setNodeValue on invalid node indices ──
-
-    void testOutOfBoundsNodeIndex() {
-        QByteArray before = m_doc->provider->readBytes(m_doc->tree.baseAddress, 256);
-
-        m_ctrl->setNodeValue(-1, 0, "42");
-        m_ctrl->setNodeValue(-100, 0, "42");
-        m_ctrl->setNodeValue(99999, 0, "42");
-        m_ctrl->setNodeValue(INT_MAX, 0, "42");
-        QApplication::processEvents();
-
-        QByteArray after = m_doc->provider->readBytes(m_doc->tree.baseAddress, 256);
-        QCOMPARE(after, before);
-        QCOMPARE(m_doc->undoStack.count(), 0);
-    }
-
-    // ── renameNode with edge cases ──
-
-    void testRenameNodeEdgeCases() {
-        int idx = findNode(m_doc->tree, "field_u32");
-        QVERIFY(idx >= 0);
-
-        // Empty name is allowed at controller level
-        m_ctrl->renameNode(idx, "");
-        QApplication::processEvents();
-        QCOMPARE(m_doc->tree.nodes[idx].name, QString(""));
-        m_doc->undoStack.undo();
-        QCOMPARE(m_doc->tree.nodes[idx].name, QString("field_u32"));
-
-        // Very long name (1000 chars)
-        QString longName = QString("a").repeated(1000);
-        m_ctrl->renameNode(idx, longName);
-        QApplication::processEvents();
-        QCOMPARE(m_doc->tree.nodes[idx].name, longName);
-        m_doc->undoStack.undo();
-
-        // Special characters
-        m_ctrl->renameNode(idx, "field with spaces & <special> \"chars\"");
-        QApplication::processEvents();
-        QCOMPARE(m_doc->tree.nodes[idx].name,
-                 QString("field with spaces & <special> \"chars\""));
-        m_doc->undoStack.undo();
-
-        // Out of bounds indices
-        m_ctrl->renameNode(-1, "bad");
-        m_ctrl->renameNode(99999, "bad");
-        QApplication::processEvents();
-        // Should not crash; undo stack not affected
-    }
-
-    // ── changeNodeKind with invalid indices ──
-
-    void testChangeKindOutOfBounds() {
-        int origCount = m_doc->tree.nodes.size();
-
-        m_ctrl->changeNodeKind(-1, NodeKind::Float);
-        m_ctrl->changeNodeKind(99999, NodeKind::Float);
-        QApplication::processEvents();
-
-        QCOMPARE(m_doc->tree.nodes.size(), origCount);
-        QCOMPARE(m_doc->undoStack.count(), 0);
-    }
-
-    // ── changeNodeKind size transitions: shrink inserts hex nodes ──
-
-    void testChangeKindShrinkInsertsHexNodes() {
-        int idx = findNode(m_doc->tree, "field_u32");
-        QVERIFY(idx >= 0);
-        QCOMPARE(m_doc->tree.nodes[idx].kind, NodeKind::UInt32);  // 4 bytes
-
-        int origCount = m_doc->tree.nodes.size();
-        m_ctrl->changeNodeKind(idx, NodeKind::UInt8);  // 4 → 1 byte = 3 gap
-        QApplication::processEvents();
-
-        QCOMPARE(m_doc->tree.nodes[idx].kind, NodeKind::UInt8);
-        // Should have inserted hex nodes (Hex16 + Hex8 = 3 bytes, or similar)
-        QVERIFY(m_doc->tree.nodes.size() > origCount);
-
-        // Undo restores everything
-        m_doc->undoStack.undo();
-        QApplication::processEvents();
-        QCOMPARE(m_doc->tree.nodes[idx].kind, NodeKind::UInt32);
-        QCOMPARE(m_doc->tree.nodes.size(), origCount);
-    }
-
-    // ── insertNode / removeNode boundary conditions ──
-
-    void testInsertNodeWithInvalidParent() {
-        int origCount = m_doc->tree.nodes.size();
-
-        // Non-existent parent ID — insertNode doesn't validate parent existence,
-        // so it will add a node with an orphan parentId. Verify no crash.
-        m_ctrl->insertNode(0xDEADBEEF, 0, NodeKind::UInt32, "orphan");
-        QApplication::processEvents();
-
-        // The node was added (the tree accepts orphan parentId)
-        QCOMPARE(m_doc->tree.nodes.size(), origCount + 1);
-
-        // Undo cleans up
-        m_doc->undoStack.undo();
-        QApplication::processEvents();
-        QCOMPARE(m_doc->tree.nodes.size(), origCount);
-    }
-
-    void testRemoveNodeOutOfBounds() {
-        int origCount = m_doc->tree.nodes.size();
-
-        m_ctrl->removeNode(-1);
-        m_ctrl->removeNode(99999);
-        QApplication::processEvents();
-
-        QCOMPARE(m_doc->tree.nodes.size(), origCount);
-        QCOMPARE(m_doc->undoStack.count(), 0);
-    }
-
-    // ── Array element count: boundary validation ──
-
-    void testArrayCountBoundaries() {
-        int idx = findNode(m_doc->tree, "field_arr");
-        QVERIFY(idx >= 0);
-        QCOMPARE(m_doc->tree.nodes[idx].kind, NodeKind::Array);
-        int origLen = m_doc->tree.nodes[idx].arrayLen;
-
-        // Simulate EditTarget::ArrayElementCount through the controller API
-        // The controller validates: ok && newLen > 0 && newLen <= 100000
-
-        // Zero count — should be rejected (> 0 check)
-        m_doc->undoStack.clear();
-        {
-            bool ok;
-            int newLen = QString("0").toInt(&ok);
-            // Controller logic: ok && newLen > 0 → false
-            QVERIFY(ok && newLen == 0);  // toInt succeeds, but newLen is 0
-            // This should NOT push a command
-        }
-
-        // Negative count
-        {
-            bool ok;
-            int newLen = QString("-5").toInt(&ok);
-            QVERIFY(ok && newLen < 0);  // toInt succeeds, but negative
-        }
-
-        // Just above max: 100001
-        {
-            bool ok;
-            int newLen = QString("100001").toInt(&ok);
-            QVERIFY(ok && newLen > 100000);
-        }
-
-        // At max: 100000 (should be accepted)
-        {
-            bool ok;
-            int newLen = QString("100000").toInt(&ok);
-            QVERIFY(ok && newLen > 0 && newLen <= 100000);
-        }
-
-        // Non-numeric text
-        {
-            bool ok;
-            QString("hello").toInt(&ok);
-            QVERIFY(!ok);
-        }
-
-        // Verify actual array length is unchanged
-        QCOMPARE(m_doc->tree.nodes[idx].arrayLen, origLen);
-    }
-
-    // ── Hex values: space-separated with wrong count ──
-
-    void testHexWrongByteCountAtController() {
-        int idx = findNode(m_doc->tree, "field_h32");
-        QVERIFY(idx >= 0);
-        uint64_t addr = m_doc->tree.computeOffset(idx);
-        QByteArray before = m_doc->provider->readBytes(addr, 4);
-
-        // 5 bytes for a 4-byte field
-        m_ctrl->setNodeValue(idx, 0, "AA BB CC DD EE");
-        QApplication::processEvents();
-
-        QByteArray after = m_doc->provider->readBytes(addr, 4);
-        QCOMPARE(after, before);
-        QCOMPARE(m_doc->undoStack.count(), 0);
-    }
-
-    // ── Valid writes followed by undo: verify round-trip integrity ──
-
-    void testValueWriteUndoIntegrity() {
-        // Write valid values to multiple fields, undo all, verify original data
-        int i8idx  = findNode(m_doc->tree, "field_i8");
-        int u32idx = findNode(m_doc->tree, "field_u32");
-        int fltidx = findNode(m_doc->tree, "field_float");
-        QVERIFY(i8idx >= 0 && u32idx >= 0 && fltidx >= 0);
-
-        // Snapshot original provider
-        QByteArray origData = m_doc->provider->readBytes(
-            m_doc->tree.baseAddress, 256);
-
-        // Write three valid values
-        m_ctrl->setNodeValue(i8idx, 0, "42");
-        m_ctrl->setNodeValue(u32idx, 0, "12345");
-        m_ctrl->setNodeValue(fltidx, 0, "2.5");
-        QApplication::processEvents();
-
-        QCOMPARE(m_doc->undoStack.count(), 3);
-
-        // Undo all three
-        m_doc->undoStack.undo();
-        m_doc->undoStack.undo();
-        m_doc->undoStack.undo();
-        QApplication::processEvents();
-
-        QByteArray afterUndo = m_doc->provider->readBytes(
-            m_doc->tree.baseAddress, 256);
-        QCOMPARE(afterUndo, origData);
-    }
-
-    // ── toggleCollapse on out-of-bounds index ──
-
-    void testToggleCollapseOutOfBounds() {
-        m_ctrl->toggleCollapse(-1);
-        m_ctrl->toggleCollapse(99999);
-        QApplication::processEvents();
-        QCOMPARE(m_doc->undoStack.count(), 0);
-    }
-
-    // ── Rapid fire: many rejected writes don't accumulate undo history ──
-
-    void testRapidFireRejectedWrites() {
-        int idx = findNode(m_doc->tree, "field_u8");
-        QVERIFY(idx >= 0);
-
-        for (int i = 0; i < 100; i++)
-            m_ctrl->setNodeValue(idx, 0, "9999");  // overflow
-        QApplication::processEvents();
-
-        QCOMPARE(m_doc->undoStack.count(), 0);
-    }
-
-    // ── Duplicate nodes: verify they get unique IDs ──
-
-    void testDuplicateNodeGetsUniqueId() {
-        int idx = findNode(m_doc->tree, "field_u32");
-        QVERIFY(idx >= 0);
-        int origCount = m_doc->tree.nodes.size();
-
-        m_ctrl->duplicateNode(idx);
-        QApplication::processEvents();
-
-        // duplicateNode appends "_copy" to the name
-        QCOMPARE(m_doc->tree.nodes.size(), origCount + 1);
-
-        int copyIdx = findNode(m_doc->tree, "field_u32_copy");
-        QVERIFY2(copyIdx >= 0, "Duplicate node should exist with '_copy' suffix");
-
-        // Verify all IDs are unique
-        QSet<uint64_t> ids;
-        for (const auto& n : m_doc->tree.nodes) {
-            QVERIFY2(!ids.contains(n.id),
-                     qPrintable(QString("Duplicate ID found: %1").arg(n.id)));
-            ids.insert(n.id);
-        }
-
-        m_doc->undoStack.undo();
-        QApplication::processEvents();
-        QCOMPARE(m_doc->tree.nodes.size(), origCount);
-    }
-
-    // ── Batch remove with invalid indices in the mix ──
-
-    void testBatchRemoveWithInvalidIndices() {
-        int origCount = m_doc->tree.nodes.size();
-        int validIdx = findNode(m_doc->tree, "field_u8");
-        QVERIFY(validIdx >= 0);
-
-        // Mix of valid and invalid indices — batchRemoveNodes filters internally
-        QVector<int> indices = {validIdx, -1, 99999};
-        m_ctrl->batchRemoveNodes(indices);
-        QApplication::processEvents();
-
-        // At least the valid node should have been removed
-        QVERIFY(m_doc->tree.nodes.size() < origCount);
-
-        // Undo restores
-        m_doc->undoStack.undo();
-        QApplication::processEvents();
-        QCOMPARE(m_doc->tree.nodes.size(), origCount);
-    }
-
-    // ── Batch change kind with invalid indices ──
-
-    void testBatchChangeKindWithInvalidIndices() {
-        int validIdx = findNode(m_doc->tree, "field_i32");
-        QVERIFY(validIdx >= 0);
-        NodeKind origKind = m_doc->tree.nodes[validIdx].kind;
-
-        // Mix of valid and invalid
-        QVector<int> indices = {-1, validIdx, 99999};
-        m_ctrl->batchChangeKind(indices, NodeKind::Float);
-        QApplication::processEvents();
-
-        // Valid node should have changed
-        QCOMPARE(m_doc->tree.nodes[validIdx].kind, NodeKind::Float);
-
-        m_doc->undoStack.undo();
-        QApplication::processEvents();
-        QCOMPARE(m_doc->tree.nodes[validIdx].kind, origKind);
-    }
-
-    // ── Editor: inline edit rejected on out-of-range lines ──
-
-    void testInlineEditOutOfRangeLines() {
-        m_ctrl->refresh();
-        QApplication::processEvents();
-
-        // Try to edit a line that doesn't exist
-        QVERIFY(!m_editor->beginInlineEdit(EditTarget::Name, 99999));
-        QVERIFY(!m_editor->isEditing());
-
-        QVERIFY(!m_editor->beginInlineEdit(EditTarget::Value, -1));
-        QVERIFY(!m_editor->isEditing());
-    }
-
-    // ── Editor: struct header rejects value edit ──
-
-    void testStructHeaderRejectsValueEdit() {
-        m_ctrl->refresh();
-        QApplication::processEvents();
-
-        ComposeResult result = m_doc->compose();
-        m_editor->applyDocument(result);
-        QApplication::processEvents();
-
-        // Find a non-root header line (root header has no editable name/type spans)
-        int headerLine = -1;
-        for (int i = 0; i < result.meta.size(); i++) {
-            if (result.meta[i].lineKind == LineKind::Header && !result.meta[i].isRootHeader) {
-                headerLine = i;
-                break;
-            }
-        }
-        QVERIFY(headerLine >= 0);
-
-        QVERIFY(!m_editor->beginInlineEdit(EditTarget::Value, headerLine));
-        QVERIFY(!m_editor->isEditing());
-
-        // But Name and Type should work
-        bool ok = m_editor->beginInlineEdit(EditTarget::Name, headerLine);
-        QVERIFY(ok);
-        m_editor->cancelInlineEdit();
-    }
-
-    // ── Base address: invalid equation syntax ──
-
-    void testBaseAddressInvalidEquation() {
-        uint64_t origBase = m_doc->tree.baseAddress;
-
-        m_ctrl->refresh();
-        QApplication::processEvents();
-
-        // These are processed through the inlineEditCommitted handler,
-        // but we can test the parsing logic directly:
-        // The controller silently ignores invalid base address text
-
-        // Test the validation function directly
-        QVERIFY(!fmt::validateBaseAddress("0x1000 ** 2").isEmpty());
-        QVERIFY(fmt::validateBaseAddress("0x1000 / 2").isEmpty());  // division supported
-        QVERIFY(!fmt::validateBaseAddress("abc xyz").isEmpty());
-
-        // Original base should be unchanged
-        QCOMPARE(m_doc->tree.baseAddress, origBase);
-    }
-
-    // ── Pointer64 value: accepts hex, rejects garbage ──
-
-    void testPointerValueValidation() {
-        int idx = findNode(m_doc->tree, "field_ptr");
-        QVERIFY(idx >= 0);
-        uint64_t addr = m_doc->tree.computeOffset(idx);
-        QByteArray before = m_doc->provider->readBytes(addr, 8);
-
-        // Garbage
-        m_ctrl->setNodeValue(idx, 0, "not_a_pointer");
-        m_ctrl->setNodeValue(idx, 0, "");
-        m_ctrl->setNodeValue(idx, 0, "0xZZZZ");
-        QApplication::processEvents();
-
-        QByteArray after = m_doc->provider->readBytes(addr, 8);
-        QCOMPARE(after, before);
-        QCOMPARE(m_doc->undoStack.count(), 0);
-
-        // Valid hex write
-        m_ctrl->setNodeValue(idx, 0, "0xDEADBEEFCAFEBABE");
-        QApplication::processEvents();
-
-        QByteArray written = m_doc->provider->readBytes(addr, 8);
-        uint64_t writtenVal;
-        memcpy(&writtenVal, written.data(), 8);
-        QCOMPARE(writtenVal, (uint64_t)0xDEADBEEFCAFEBABEULL);
-
-        m_doc->undoStack.undo();
-        QApplication::processEvents();
-        QByteArray restored = m_doc->provider->readBytes(addr, 8);
-        QCOMPARE(restored, before);
-    }
-
-    // ── Hex64 space-separated: exact 8 bytes accepted, other counts rejected ──
-
-    void testHex64SpaceSeparatedBoundary() {
-        int idx = findNode(m_doc->tree, "field_h64");
-        QVERIFY(idx >= 0);
-        uint64_t addr = m_doc->tree.computeOffset(idx);
-        QByteArray before = m_doc->provider->readBytes(addr, 8);
-
-        // 7 bytes — reject
-        m_ctrl->setNodeValue(idx, 0, "AA BB CC DD EE FF 00");
-        QApplication::processEvents();
-        QCOMPARE(m_doc->provider->readBytes(addr, 8), before);
-
-        // 9 bytes — reject
-        m_ctrl->setNodeValue(idx, 0, "AA BB CC DD EE FF 00 11 22");
-        QApplication::processEvents();
-        QCOMPARE(m_doc->provider->readBytes(addr, 8), before);
-
-        QCOMPARE(m_doc->undoStack.count(), 0);
-
-        // 8 bytes — accept
-        m_ctrl->setNodeValue(idx, 0, "01 02 03 04 05 06 07 08");
-        QApplication::processEvents();
-        QCOMPARE(m_doc->undoStack.count(), 1);
-
-        QByteArray written = m_doc->provider->readBytes(addr, 8);
-        QCOMPARE((uint8_t)written[0], (uint8_t)0x01);
-        QCOMPARE((uint8_t)written[7], (uint8_t)0x08);
-
-        m_doc->undoStack.undo();
-    }
-
-    // ── Multiple undos past the beginning don't crash ──
-
-    void testExcessiveUndos() {
-        int idx = findNode(m_doc->tree, "field_u32");
-        QVERIFY(idx >= 0);
-
-        m_ctrl->setNodeValue(idx, 0, "42");
-        QApplication::processEvents();
-        QCOMPARE(m_doc->undoStack.count(), 1);
-
-        // Undo once (valid)
-        m_doc->undoStack.undo();
-        // Undo 50 more times (all no-ops, should not crash)
-        for (int i = 0; i < 50; i++)
-            m_doc->undoStack.undo();
-        QApplication::processEvents();
-
-        // Redo 50 times past the end
-        m_doc->undoStack.redo();
-        for (int i = 0; i < 50; i++)
-            m_doc->undoStack.redo();
-        QApplication::processEvents();
-    }
-};
-
-QTEST_MAIN(TestValidationController)
-#include "test_validation.moc"