diff --git a/Source/Components/Interfaces/DebugService/DebugCore.h b/Source/Components/Interfaces/DebugService/DebugCore.h
index abab7fe..a7ce8a7 100644
--- a/Source/Components/Interfaces/DebugService/DebugCore.h
+++ b/Source/Components/Interfaces/DebugService/DebugCore.h
@@ -28,6 +28,7 @@ struct DebugSignalInfo {
     volatile bool isTracing;
     volatile bool isForcing;
     uint8 forcedValue[1024];
+    uint8 forcedMask[32];   // bit e set → element e is forced; supports up to 256 elements
     uint32 internalID;
     volatile uint32 decimationFactor;
     volatile uint32 decimationCounter;
diff --git a/Source/Components/Interfaces/DebugService/DebugServiceBase.cpp b/Source/Components/Interfaces/DebugService/DebugServiceBase.cpp
index 082fad1..601f97e 100644
--- a/Source/Components/Interfaces/DebugService/DebugServiceBase.cpp
+++ b/Source/Components/Interfaces/DebugService/DebugServiceBase.cpp
@@ -64,16 +64,34 @@ static void EscapeJson(const char8 *src, StreamString &dst) {
   }
 }
 
-static bool SuffixMatch(const char8 *target, const char8 *pattern) {
-  uint32 tLen = StringHelper::Length(target);
-  uint32 pLen = StringHelper::Length(pattern);
-  if (pLen > tLen)
+// Returns true if `str` ends with `suffix` at a word boundary (i.e. the char
+// immediately before the match is '.', or the match covers the entire string).
+static bool SuffixMatch(const char8 *str, const char8 *suffix) {
+  uint32 sLen   = StringHelper::Length(str);
+  uint32 sufLen = StringHelper::Length(suffix);
+  if (sufLen > sLen)
     return false;
-  const char8 *suffix = target + (tLen - pLen);
-  if (StringHelper::Compare(suffix, pattern) == 0) {
-    if (tLen == pLen || *(suffix - 1) == '.')
-      return true;
-  }
+  const char8 *tail = str + (sLen - sufLen);
+  if (StringHelper::Compare(tail, suffix) != 0)
+    return false;
+  return (sLen == sufLen || *(tail - 1u) == '.');
+}
+
+// Match a stored alias against a user-supplied name.
+// Three cases are tried in order:
+//   1. Exact match         ("App.DS.Sig"  == "App.DS.Sig")
+//   2. Alias is longer     (alias "App.DS.Sig" ends with user name "Sig")
+//      → user used a short / unqualified name in the command.
+//   3. User name is longer (user name "App.GAM.In.Sig" ends with alias "GAM.In.Sig")
+//      → alias was registered with a short fallback path (FindByNameRecursive
+//        failed during broker init) but the client uses the full ORD path.
+static bool AliasMatch(const char8 *aliasName, const char8 *userName) {
+  if (StringHelper::Compare(aliasName, userName) == 0)
+    return true;
+  if (SuffixMatch(aliasName, userName))   // case 2: alias ⊇ userName
+    return true;
+  if (SuffixMatch(userName, aliasName))   // case 3: userName ⊇ alias
+    return true;
   return false;
 }
 
@@ -286,7 +304,21 @@ void DebugServiceBase::ProcessSignal(DebugSignalInfo *signalInfo, uint32 size,
   if (signalInfo == NULL_PTR(DebugSignalInfo *))
     return;
   if (signalInfo->isForcing) {
-    memcpy(signalInfo->memoryAddress, signalInfo->forcedValue, size);
+    uint32 nEl = signalInfo->numberOfElements;
+    if (nEl <= 1u) {
+      // Scalar — single memcpy.
+      memcpy(signalInfo->memoryAddress, signalInfo->forcedValue, size);
+    } else {
+      // Array — copy only the elements whose bit is set in forcedMask.
+      uint32 elemBytes = size / nEl;
+      for (uint32 e = 0u; e < nEl; e++) {
+        if (signalInfo->forcedMask[e >> 3u] & (uint8)(1u << (e & 7u))) {
+          memcpy((uint8 *)signalInfo->memoryAddress + e * elemBytes,
+                 signalInfo->forcedValue             + e * elemBytes,
+                 elemBytes);
+        }
+      }
+    }
   }
   if (signalInfo->isTracing) {
     Atomic::Add((volatile int32 *)&signalInfo->decimationCounter, 1);
@@ -352,14 +384,39 @@ void DebugServiceBase::ConsumeStepIfNeeded(const char8 *gamName,
 // ---------------------------------------------------------------------------
 
 uint32 DebugServiceBase::ForceSignal(const char8 *name, const char8 *valueStr) {
+  // Parse optional array-element suffix: "SignalName[idx]" → baseName + elemIdx.
+  // elemIdx == -1 means "force all elements".
+  const char8 *bracketPos = StringHelper::SearchChar(name, '[');
+  StreamString baseName;
+  int32        elemIdx = -1;
+
+  if (bracketPos != NULL_PTR(const char8 *)) {
+    uint32 baseLen = (uint32)(bracketPos - name);
+    (void)baseName.Write(name, baseLen);
+    const char8 *closePos =
+        StringHelper::SearchChar(bracketPos + 1u, ']');
+    if (closePos != NULL_PTR(const char8 *)) {
+      uint32 idxLen = (uint32)(closePos - bracketPos - 1u);
+      StreamString idxStr;
+      (void)idxStr.Write(bracketPos + 1u, idxLen);
+      uint32 parsed = 0u;
+      AnyType iv(UnsignedInteger32Bit, 0u, &parsed);
+      AnyType is_src(CharString, 0u, idxStr.Buffer());
+      if (TypeConvert(iv, is_src))
+        elemIdx = (int32)parsed;
+    }
+  } else {
+    baseName = name;
+  }
+  const char8 *effectiveName = baseName.Buffer();
+
   mutex.FastLock();
   uint32 count = 0u;
   for (uint32 i = 0u; i < aliases.GetNumberOfElements(); i++) {
-    if (aliases[i].name == name ||
-        SuffixMatch(aliases[i].name.Buffer(), name)) {
-      DebugSignalInfo *s = signals[aliases[i].signalIndex];
-      uint32 elemBytes = (uint32)(s->type.numberOfBits) / 8u;
-      uint32 totalBytes = elemBytes * s->numberOfElements;
+    if (AliasMatch(aliases[i].name.Buffer(), effectiveName)) {
+      DebugSignalInfo *s         = signals[aliases[i].signalIndex];
+      uint32           elemBytes = (uint32)(s->type.numberOfBits) / 8u;
+      uint32           totalBytes = elemBytes * s->numberOfElements;
       if (elemBytes == 0u || totalBytes > (uint32)sizeof(s->forcedValue)) {
         REPORT_ERROR_STATIC(
             ErrorManagement::Warning,
@@ -369,9 +426,27 @@ uint32 DebugServiceBase::ForceSignal(const char8 *name, const char8 *valueStr) {
         continue;
       }
       s->isForcing = true;
-      AnyType dest(s->type, 0u, s->forcedValue);
-      AnyType source(CharString, 0u, valueStr);
-      (void)TypeConvert(dest, source);
+
+      if (elemIdx >= 0 && (uint32)elemIdx < s->numberOfElements) {
+        // Force a single element — write to its slot and set its mask bit.
+        uint8 *dest = (uint8 *)s->forcedValue + (uint32)elemIdx * elemBytes;
+        AnyType dv(s->type, 0u, (void *)dest);
+        AnyType sv(CharString, 0u, valueStr);
+        (void)TypeConvert(dv, sv);
+        s->forcedMask[(uint32)elemIdx >> 3u] |= (uint8)(1u << ((uint32)elemIdx & 7u));
+      } else {
+        // Force all elements to the same value — convert once, replicate, set all bits.
+        AnyType dv(s->type, 0u, s->forcedValue);
+        AnyType sv(CharString, 0u, valueStr);
+        (void)TypeConvert(dv, sv);
+        for (uint32 k = 1u; k < s->numberOfElements; k++) {
+          memcpy(s->forcedValue + k * elemBytes, s->forcedValue, elemBytes);
+        }
+        uint32 fullBytes = s->numberOfElements / 8u;
+        uint32 remBits   = s->numberOfElements % 8u;
+        memset(s->forcedMask, 0xFF, fullBytes);
+        if (remBits > 0u) s->forcedMask[fullBytes] = (uint8)((1u << remBits) - 1u);
+      }
       count++;
     }
   }
@@ -381,12 +456,48 @@ uint32 DebugServiceBase::ForceSignal(const char8 *name, const char8 *valueStr) {
 }
 
 uint32 DebugServiceBase::UnforceSignal(const char8 *name) {
+  // Parse optional "[idx]" suffix.  If present, clear only that element's bit;
+  // if absent, clear all bits and the isForcing flag entirely.
+  const char8 *bracketPos = StringHelper::SearchChar(name, '[');
+  StreamString baseName;
+  int32 elemIdx = -1;
+
+  if (bracketPos != NULL_PTR(const char8 *)) {
+    uint32 baseLen = (uint32)(bracketPos - name);
+    (void)baseName.Write(name, baseLen);
+    const char8 *closePos = StringHelper::SearchChar(bracketPos + 1u, ']');
+    if (closePos != NULL_PTR(const char8 *)) {
+      uint32 idxLen = (uint32)(closePos - bracketPos - 1u);
+      StreamString idxStr;
+      (void)idxStr.Write(bracketPos + 1u, idxLen);
+      uint32 parsed = 0u;
+      AnyType iv(UnsignedInteger32Bit, 0u, &parsed);
+      AnyType is_src(CharString, 0u, idxStr.Buffer());
+      if (TypeConvert(iv, is_src)) elemIdx = (int32)parsed;
+    }
+  } else {
+    baseName = name;
+  }
+  const char8 *effectiveName = baseName.Buffer();
+
   mutex.FastLock();
   uint32 count = 0u;
   for (uint32 i = 0u; i < aliases.GetNumberOfElements(); i++) {
-    if (aliases[i].name == name ||
-        SuffixMatch(aliases[i].name.Buffer(), name)) {
-      signals[aliases[i].signalIndex]->isForcing = false;
+    if (AliasMatch(aliases[i].name.Buffer(), effectiveName)) {
+      DebugSignalInfo *s = signals[aliases[i].signalIndex];
+      if (elemIdx >= 0 && (uint32)elemIdx < s->numberOfElements) {
+        // Clear just this element's force bit.
+        s->forcedMask[(uint32)elemIdx >> 3u] &= (uint8)(~(1u << ((uint32)elemIdx & 7u)));
+        // Deactivate forcing entirely if no bits remain.
+        uint32 numBytes = (s->numberOfElements + 7u) / 8u;
+        bool anySet = false;
+        for (uint32 b = 0u; b < numBytes && !anySet; b++) anySet = (s->forcedMask[b] != 0u);
+        if (!anySet) s->isForcing = false;
+      } else {
+        // Unforce all elements.
+        memset(s->forcedMask, 0, sizeof(s->forcedMask));
+        s->isForcing = false;
+      }
       count++;
     }
   }
@@ -400,8 +511,7 @@ uint32 DebugServiceBase::TraceSignal(const char8 *name, bool enable,
   mutex.FastLock();
   uint32 count = 0u;
   for (uint32 i = 0u; i < aliases.GetNumberOfElements(); i++) {
-    if (aliases[i].name == name ||
-        SuffixMatch(aliases[i].name.Buffer(), name)) {
+    if (AliasMatch(aliases[i].name.Buffer(), name)) {
       DebugSignalInfo *s = signals[aliases[i].signalIndex];
       s->isTracing = enable;
       s->decimationFactor = decimation;
@@ -419,8 +529,7 @@ uint32 DebugServiceBase::SetBreak(const char8 *name, uint8 op,
   mutex.FastLock();
   uint32 count = 0u;
   for (uint32 i = 0u; i < aliases.GetNumberOfElements(); i++) {
-    if (aliases[i].name == name ||
-        SuffixMatch(aliases[i].name.Buffer(), name)) {
+    if (AliasMatch(aliases[i].name.Buffer(), name)) {
       DebugSignalInfo *s = signals[aliases[i].signalIndex];
       s->breakThreshold = threshold;
       s->breakOp = op;
@@ -437,8 +546,7 @@ uint32 DebugServiceBase::ClearBreak(const char8 *name) {
   mutex.FastLock();
   uint32 count = 0u;
   for (uint32 i = 0u; i < aliases.GetNumberOfElements(); i++) {
-    if (aliases[i].name == name ||
-        SuffixMatch(aliases[i].name.Buffer(), name)) {
+    if (AliasMatch(aliases[i].name.Buffer(), name)) {
       signals[aliases[i].signalIndex]->breakOp = BREAK_OFF;
       count++;
     }
@@ -454,8 +562,7 @@ bool DebugServiceBase::IsInstrumented(const char8 *fullPath, bool &traceable,
   mutex.FastLock();
   bool found = false;
   for (uint32 i = 0u; i < aliases.GetNumberOfElements(); i++) {
-    if (aliases[i].name == fullPath ||
-        SuffixMatch(aliases[i].name.Buffer(), fullPath)) {
+    if (AliasMatch(aliases[i].name.Buffer(), fullPath)) {
       found = true;
       break;
     }
@@ -517,8 +624,7 @@ uint32 DebugServiceBase::RegisterMonitorSignal(const char8 *path,
         m.internalID = 0x80000000u | monitoredSignals.GetNumberOfElements();
         // Re-use existing brokered signal ID if available
         for (uint32 i = 0u; i < aliases.GetNumberOfElements(); i++) {
-          if (aliases[i].name == path ||
-              SuffixMatch(aliases[i].name.Buffer(), path)) {
+          if (AliasMatch(aliases[i].name.Buffer(), path)) {
             m.internalID = signals[aliases[i].signalIndex]->internalID;
             break;
           }
@@ -652,8 +758,7 @@ void DebugServiceBase::GetSignalValue(const char8 *name, StreamString &out) {
   mutex.FastLock();
   DebugSignalInfo *sig = NULL_PTR(DebugSignalInfo *);
   for (uint32 i = 0u; i < aliases.GetNumberOfElements(); i++) {
-    if (aliases[i].name == name ||
-        SuffixMatch(aliases[i].name.Buffer(), name)) {
+    if (AliasMatch(aliases[i].name.Buffer(), name)) {
       sig = signals[aliases[i].signalIndex];
       break;
     }
@@ -809,14 +914,156 @@ void DebugServiceBase::BuildDiscoverCache() {
 }
 
 void DebugServiceBase::BuildTreeCache() {
-  treeCacheValid = false;
-  treeCache      = "";
-  treeCache += "{\"Name\":\"Root\",\"Class\":\"ObjectRegistryDatabase\","
-               "\"Children\":[\n";
-  (void)ExportTree(ObjectRegistryDatabase::Instance(), treeCache,
-                   NULL_PTR(const char8 *));
-  treeCache += "\n]}\nOK TREE\n";
-  treeCacheValid = true;
+  // No-op: tree is now served per-node via ExportTreeNode.
+}
+
+// ---------------------------------------------------------------------------
+// ExportTreeNode — serve one level of the object tree
+// ---------------------------------------------------------------------------
+
+void DebugServiceBase::ExportTreeNode(const char8 *path, StreamString &out) {
+  bool isRoot =
+      (path == NULL_PTR(const char8 *) || StringHelper::Length(path) == 0);
+
+  out += "{\"Path\":\"";
+  EscapeJson(isRoot ? "" : path, out);
+  out += "\",\"Children\":[\n";
+
+  uint32 count = 0u;
+
+  ReferenceContainer *container = NULL_PTR(ReferenceContainer *);
+  DataSourceI *       ds        = NULL_PTR(DataSourceI *);
+  GAM *               gam       = NULL_PTR(GAM *);
+
+  if (isRoot) {
+    container = ObjectRegistryDatabase::Instance();
+  } else {
+    Reference ref = ObjectRegistryDatabase::Instance()->Find(path);
+    if (ref.IsValid()) {
+      container = dynamic_cast<ReferenceContainer *>(ref.operator->());
+      ds        = dynamic_cast<DataSourceI *>(ref.operator->());
+      gam       = dynamic_cast<GAM *>(ref.operator->());
+    }
+  }
+
+  // ReferenceContainer children
+  if (container != NULL_PTR(ReferenceContainer *)) {
+    uint32 n = container->Size();
+    for (uint32 i = 0u; i < n; i++) {
+      Reference child = container->Get(i);
+      if (!child.IsValid())
+        continue;
+      const char8 *cname = child->GetName();
+      if (cname == NULL_PTR(const char8 *))
+        cname = "unnamed";
+
+      ReferenceContainer *irc =
+          dynamic_cast<ReferenceContainer *>(child.operator->());
+      DataSourceI *ids = dynamic_cast<DataSourceI *>(child.operator->());
+      GAM *        igam = dynamic_cast<GAM *>(child.operator->());
+      bool hasCh =
+          (irc != NULL_PTR(ReferenceContainer *) && irc->Size() > 0u) ||
+          ids != NULL_PTR(DataSourceI *) || igam != NULL_PTR(GAM *);
+
+      if (count > 0u)
+        out += ",\n";
+      out += "{\"Name\":\"";
+      EscapeJson(cname, out);
+      out += "\",\"Class\":\"";
+      EscapeJson(child->GetClassProperties()->GetName(), out);
+      out.Printf("\",\"HasChildren\":%s}", hasCh ? "true" : "false");
+      count++;
+    }
+  }
+
+  // DataSourceI signals
+  if (ds != NULL_PTR(DataSourceI *)) {
+    uint32 ns = ds->GetNumberOfSignals();
+    for (uint32 j = 0u; j < ns; j++) {
+      StreamString sn;
+      (void)ds->GetSignalName(j, sn);
+      const char8 *st = TypeDescriptor::GetTypeNameFromTypeDescriptor(
+          ds->GetSignalType(j));
+      uint8  d  = 0u;
+      (void)ds->GetSignalNumberOfDimensions(j, d);
+      uint32 el = 0u;
+      (void)ds->GetSignalNumberOfElements(j, el);
+      StreamString sfp;
+      sfp.Printf("%s.%s", path, sn.Buffer());
+      bool tr = false, fo = false;
+      (void)IsInstrumented(sfp.Buffer(), tr, fo);
+
+      if (count > 0u)
+        out += ",\n";
+      out += "{\"Name\":\"";
+      EscapeJson(sn.Buffer(), out);
+      out += "\",\"Class\":\"Signal\",\"Type\":\"";
+      EscapeJson(st ? st : "Unknown", out);
+      out.Printf("\",\"Dimensions\":%u,\"Elements\":%u,"
+                 "\"IsTraceable\":%s,\"IsForcable\":%s,\"HasChildren\":false}",
+                 d, el, tr ? "true" : "false", fo ? "true" : "false");
+      count++;
+    }
+  }
+
+  // GAM input signals
+  if (gam != NULL_PTR(GAM *)) {
+    uint32 nIn = gam->GetNumberOfInputSignals();
+    for (uint32 j = 0u; j < nIn; j++) {
+      StreamString sn;
+      (void)gam->GetSignalName(InputSignals, j, sn);
+      const char8 *st = TypeDescriptor::GetTypeNameFromTypeDescriptor(
+          gam->GetSignalType(InputSignals, j));
+      uint32 d = 0u;
+      (void)gam->GetSignalNumberOfDimensions(InputSignals, j, d);
+      uint32 el = 0u;
+      (void)gam->GetSignalNumberOfElements(InputSignals, j, el);
+      StreamString sfp;
+      sfp.Printf("%s.In.%s", path, sn.Buffer());
+      bool tr = false, fo = false;
+      (void)IsInstrumented(sfp.Buffer(), tr, fo);
+
+      if (count > 0u)
+        out += ",\n";
+      out += "{\"Name\":\"In.";
+      EscapeJson(sn.Buffer(), out);
+      out += "\",\"Class\":\"InputSignal\",\"Type\":\"";
+      EscapeJson(st ? st : "Unknown", out);
+      out.Printf("\",\"Dimensions\":%u,\"Elements\":%u,"
+                 "\"IsTraceable\":%s,\"IsForcable\":%s,\"HasChildren\":false}",
+                 d, el, tr ? "true" : "false", fo ? "true" : "false");
+      count++;
+    }
+
+    uint32 nOut = gam->GetNumberOfOutputSignals();
+    for (uint32 j = 0u; j < nOut; j++) {
+      StreamString sn;
+      (void)gam->GetSignalName(OutputSignals, j, sn);
+      const char8 *st = TypeDescriptor::GetTypeNameFromTypeDescriptor(
+          gam->GetSignalType(OutputSignals, j));
+      uint32 d = 0u;
+      (void)gam->GetSignalNumberOfDimensions(OutputSignals, j, d);
+      uint32 el = 0u;
+      (void)gam->GetSignalNumberOfElements(OutputSignals, j, el);
+      StreamString sfp;
+      sfp.Printf("%s.Out.%s", path, sn.Buffer());
+      bool tr = false, fo = false;
+      (void)IsInstrumented(sfp.Buffer(), tr, fo);
+
+      if (count > 0u)
+        out += ",\n";
+      out += "{\"Name\":\"Out.";
+      EscapeJson(sn.Buffer(), out);
+      out += "\",\"Class\":\"OutputSignal\",\"Type\":\"";
+      EscapeJson(st ? st : "Unknown", out);
+      out.Printf("\",\"Dimensions\":%u,\"Elements\":%u,"
+                 "\"IsTraceable\":%s,\"IsForcable\":%s,\"HasChildren\":false}",
+                 d, el, tr ? "true" : "false", fo ? "true" : "false");
+      count++;
+    }
+  }
+
+  out += "\n]}\nOK TREE\n";
 }
 
 void DebugServiceBase::InfoNode(const char8 *path, StreamString &out) {
@@ -857,8 +1104,7 @@ void DebugServiceBase::InfoNode(const char8 *path, StreamString &out) {
     mutex.FastLock();
     bool found = false;
     for (uint32 i = 0u; i < aliases.GetNumberOfElements(); i++) {
-      if (aliases[i].name == path ||
-          SuffixMatch(aliases[i].name.Buffer(), path)) {
+      if (AliasMatch(aliases[i].name.Buffer(), path)) {
         DebugSignalInfo *s = signals[aliases[i].signalIndex];
         const char8 *tn =
             TypeDescriptor::GetTypeNameFromTypeDescriptor(s->type);
@@ -922,7 +1168,6 @@ void DebugServiceBase::SetFullConfig(ConfigurationDatabase &config) {
   config.Copy(fullConfig);
   manualConfigSet = true;
   BuildDiscoverCache();
-  BuildTreeCache();
 }
 
 void DebugServiceBase::RebuildConfigFromRegistry() {
@@ -1289,9 +1534,10 @@ void DebugServiceBase::HandleCommand(const StreamString &cmdIn,
   } else if (token == "DISCOVER") {
     Discover(out);
   } else if (token == "TREE") {
-    if (!treeCacheValid)
-      BuildTreeCache();
-    out += treeCache;
+    StreamString path;
+    (void)cmd.GetToken(path, delims, term);
+    ExportTreeNode(path.Size() > 0u ? path.Buffer() : NULL_PTR(const char8 *),
+                   out);
   } else if (token == "INFO") {
     StreamString path;
     if (cmd.GetToken(path, delims, term))
diff --git a/Source/Components/Interfaces/DebugService/DebugServiceBase.h b/Source/Components/Interfaces/DebugService/DebugServiceBase.h
index 6f08b9f..3b1dd2d 100644
--- a/Source/Components/Interfaces/DebugService/DebugServiceBase.h
+++ b/Source/Components/Interfaces/DebugService/DebugServiceBase.h
@@ -176,6 +176,7 @@ protected:
 
     uint32 ExportTree(ReferenceContainer *container, StreamString &json,
                       const char8 *pathPrefix);
+    void   ExportTreeNode(const char8 *path, StreamString &out);
     void   EnrichWithConfig(const char8 *path, StreamString &json);
     static void JsonifyDatabase(ConfigurationDatabase &db, StreamString &json);
 
diff --git a/Tools/go_web_client/marte2-web-client b/Tools/go_web_client/marte2-web-client
index 0ac5c7f..203c4b3 100755
Binary files a/Tools/go_web_client/marte2-web-client and b/Tools/go_web_client/marte2-web-client differ
diff --git a/Tools/go_web_client/marte2.go b/Tools/go_web_client/marte2.go
index eab5229..aa50ddf 100644
--- a/Tools/go_web_client/marte2.go
+++ b/Tools/go_web_client/marte2.go
@@ -347,9 +347,11 @@ func (m *MarteClient) handleJSONResponse(tag, data string) {
 		return
 
 	case "TREE":
-		// Parse server-side and stream pre-digested flat-node batches to the
-		// browser so it never has to JSON.parse a multi-MB string.
-		go m.sendTreeBatches(data)
+		// Per-node response — forward to browser as-is.
+		broadcast(m.hub, map[string]any{
+			"type": "tree_node",
+			"data": data,
+		})
 		return
 	}
 	broadcast(m.hub, map[string]any{
@@ -359,90 +361,6 @@ func (m *MarteClient) handleJSONResponse(tag, data string) {
 	})
 }
 
-// ---------------------------------------------------------------------------
-// TREE streaming
-// ---------------------------------------------------------------------------
-
-// TreeNode mirrors the DebugService TREE JSON structure.
-type TreeNode struct {
-	Name        string      `json:"Name"`
-	Class       string      `json:"Class"`
-	IsTraceable bool        `json:"IsTraceable"`
-	IsForcable  bool        `json:"IsForcable"`
-	Elements    uint32      `json:"Elements"`
-	Children    []*TreeNode `json:"Children"`
-}
-
-// FlatNode is a pre-digested, compact representation sent to the browser.
-type FlatNode struct {
-	Path   string `json:"p"`
-	Name   string `json:"n"`
-	Class  string `json:"c"`
-	Parent string `json:"par"`
-	Tr     bool   `json:"tr,omitempty"`
-	Fo     bool   `json:"fo,omitempty"`
-	El     uint32 `json:"el,omitempty"`
-	HasCh  bool   `json:"ch,omitempty"`
-}
-
-func flattenTree(node *TreeNode, parentPath string, out *[]FlatNode) {
-	path := node.Name
-	if parentPath != "" {
-		path = parentPath + "." + node.Name
-	}
-	hasCh := len(node.Children) > 0
-	*out = append(*out, FlatNode{
-		Path:  path,
-		Name:  node.Name,
-		Class: node.Class,
-		Parent: parentPath,
-		Tr:    node.IsTraceable,
-		Fo:    node.IsForcable,
-		El:    node.Elements,
-		HasCh: hasCh,
-	})
-	for _, c := range node.Children {
-		flattenTree(c, path, out)
-	}
-}
-
-// sendTreeBatches parses the raw TREE JSON and streams compact FlatNode
-// batches to all browsers. Each browser processes one batch per animation
-// frame, keeping the UI responsive during large tree loads.
-func (m *MarteClient) sendTreeBatches(raw string) {
-	var root TreeNode
-	if err := json.Unmarshal([]byte(raw), &root); err != nil {
-		log.Printf("[TREE] parse error: %v — falling back to raw JSON", err)
-		broadcast(m.hub, map[string]any{"type": "response", "tag": "TREE", "data": raw})
-		return
-	}
-
-	var nodes []FlatNode
-	if root.Name == "Root" && len(root.Children) > 0 {
-		for _, c := range root.Children {
-			flattenTree(c, "", &nodes)
-		}
-	} else {
-		flattenTree(&root, "", &nodes)
-	}
-
-	total := len(nodes)
-	log.Printf("[TREE] streaming %d flat nodes to browser", total)
-	broadcast(m.hub, map[string]any{"type": "tree_clear", "total": total})
-
-	const batchSize = 50
-	for i := 0; i < total; i += batchSize {
-		end := i + batchSize
-		if end > total {
-			end = total
-		}
-		broadcast(m.hub, map[string]any{
-			"type":  "tree_batch",
-			"nodes": nodes[i:end],
-			"done":  end == total,
-		})
-	}
-}
 
 func (m *MarteClient) handleTextLine(line string) {
 	if strings.HasPrefix(line, "OK SERVICE_INFO") {
diff --git a/Tools/go_web_client/static/app.js b/Tools/go_web_client/static/app.js
index 9d028c9..7f4fd01 100644
--- a/Tools/go_web_client/static/app.js
+++ b/Tools/go_web_client/static/app.js
@@ -5,7 +5,7 @@
 // State
 // ════════════════════════════════════════════════════════════════════
 
-const MAX_TRACE_PTS = 100000;
+const MAX_TRACE_PTS = 500000; // per-signal storage limit; LTTB downsamples for display
 const COLORS = [
   '#89b4fa','#f38ba8','#a6e3a1','#fab387','#f9e2af',
   '#cba6f7','#89dceb','#b4befe','#eba0ac','#94e2d5'
@@ -23,8 +23,10 @@ let signalsByName = {};
 let traceData = {};
 // Set of names currently being traced
 let tracedSet = new Set();
-// Forced: name → value string
+// Forced: name → value string (scalars and single-index array elements)
 let forcedSignals = {};
+// Forced array groups: baseName → {isAll, indices: Set<number>, elements, value, expanded}
+const forcedGroups = new Map();
 // Breakpoints: name → {op, threshold}
 let breakpoints = {};
 // Thread list from TREE
@@ -51,6 +53,19 @@ let unforceTarget = '';
 // UDP stats
 let udpPackets = 0, udpDropped = 0;
 
+// Grouped array traces: baseName → {indices: Set<number>, elements: number, expanded: boolean}
+// Created when user traces All/Range from the array dialog.
+const tracedGroups = new Map();
+
+// Sequential array series: baseName → {seqName, nEl, lastTs}
+const seqState = {};
+// Waterfall panels: wfId → wfObj
+const waterfalls = new Map();
+let wfSeq = 0;
+let wfRO = null;
+// Pending array-plot dialog state
+let _arrpPlotId = -1, _arrpName = '', _arrpElem = 0;
+
 // ════════════════════════════════════════════════════════════════════
 // WebSocket
 // ════════════════════════════════════════════════════════════════════
@@ -84,59 +99,113 @@ function handleMsg(msg) {
     case 'log':            onLog(msg); break;
     case 'service_config': onServiceConfig(msg); break;
     case 'udp_stats':      onUdpStats(msg); break;
-    case 'tree_clear':     onTreeClear(msg.total); break;
-    case 'tree_batch':     onTreeBatch(msg); break;
+    case 'tree_node':      try { onTreeNode(JSON.parse(msg.data)); } catch(e) {} break;
   }
 }
 
 // ════════════════════════════════════════════════════════════════════
-// Incremental tree rendering (server-side pre-processed batches)
+// Per-node lazy tree loading
 //
-// Batches are stored purely in memory — no DOM work during receipt.
-// DOM nodes are created lazily: only the top-level containers are
-// built immediately; everything inside a closed <details> is deferred
-// until the user opens it.  This keeps the initial render O(1) in the
-// number of signals regardless of tree size.
+// TREE (no arg) returns only the root-level children.
+// TREE <path> returns the immediate children of that node.
+// Each <details> element sends TREE <path> on first open to load
+// its children on demand, keeping initial render O(1).
 // ════════════════════════════════════════════════════════════════════
 
-let _treeBuild  = null;  // { threads:[], objects:[] } — null when idle
-let _flatNodes  = null;  // Map<path, FlatNode>
-let _childrenOf = null;  // Map<parentPath|'', FlatNode[]>
+// Called when a tree_node message arrives from the Go server.
+function onTreeNode(data) {
+  const path     = data.Path     || '';
+  const children = data.Children || [];
 
-function onTreeClear(total) {
-  _treeBuild  = { threads: [], objects: [] };
-  _flatNodes  = new Map();
-  _childrenOf = new Map();
-  document.getElementById('tree-body').innerHTML = '';
-  appendLog('sys', 'INFO', `Receiving tree (${total} nodes)…`);
+  if (path === '') {
+    // Root level: populate tree-body and mark tree ready.
+    const body = document.getElementById('tree-body');
+    body.innerHTML = '';
+    const frag = document.createDocumentFragment();
+    for (const child of children) {
+      frag.appendChild(_buildLazyNode(child, ''));
+    }
+    body.appendChild(frag);
+    _treeReady = true;
+    appendLog('sys', 'INFO', `Tree root loaded — ${children.length} top-level nodes`);
+    startStepPoll();
+  } else {
+    // Find the <details> element for this path and populate it.
+    const details = document.querySelector(`[data-tree-path="${CSS.escape(path)}"]`);
+    if (details) {
+      // Remove loading indicator.
+      const ld = details.querySelector('.tree-loading');
+      if (ld) ld.remove();
+      const childDiv = document.createElement('div');
+      childDiv.className = 'children';
+      const infoBtn = makeLeafButtons(path);
+      if (infoBtn) childDiv.appendChild(infoBtn);
+      const frag = document.createDocumentFragment();
+      for (const child of children) {
+        frag.appendChild(_buildLazyNode(child, path));
+      }
+      childDiv.appendChild(frag);
+      details.appendChild(childDiv);
+    }
+  }
+
+  // Collect metadata (threads, objects) from the received children.
+  for (const child of children) {
+    const fullPath = path ? path + '.' + child.Name : child.Name;
+    if (child.Class === 'RealTimeThread' && !threads.includes(child.Name)) {
+      threads.push(child.Name);
+    }
+    if (child.HasChildren) {
+      allObjects.push(fullPath);
+    }
+  }
+  _updateTreeMeta();
 }
 
-function onTreeBatch(msg) {
-  if (!_treeBuild) return;
-  // Pure memory work — no DOM touched here.
-  for (const node of (msg.nodes || [])) {
-    _flatNodes.set(node.p, node);
-    const pk = node.par || '';
-    let ch = _childrenOf.get(pk);
-    if (!ch) { ch = []; _childrenOf.set(pk, ch); }
-    ch.push(node);
-    if (node.c === 'RealTimeThread' && node.n) _treeBuild.threads.push(node.n);
-    if (node.c && node.c !== 'Signal' && node.n) _treeBuild.objects.push(node.p);
+// Build one lazy tree node DOM element.
+// Containers get a <details> that fires TREE <path> on first open.
+// Leaves are rendered immediately as signal rows.
+function _buildLazyNode(child, parentPath) {
+  const fullPath = parentPath ? parentPath + '.' + child.Name : child.Name;
+
+  if (child.HasChildren) {
+    const details = document.createElement('details');
+    details.setAttribute('data-tree-path', fullPath);
+    const summary = document.createElement('summary');
+    summary.innerHTML =
+      `<span class="tree-name">${esc(child.Name)}</span>` +
+      `<span class="tree-class">[${esc(child.Class)}]</span>`;
+    details.appendChild(summary);
+    details.addEventListener('toggle', function() {
+      if (!details.open || details._childrenBuilt) return;
+      details._childrenBuilt = true;
+      const ld = document.createElement('div');
+      ld.className = 'tree-loading';
+      ld.textContent = '⏳ Loading…';
+      details.appendChild(ld);
+      sendCmd('TREE ' + fullPath);
+    });
+    return details;
   }
 
-  if (!msg.done) return;
+  // Leaf node (signal).
+  const isSig = child.Class === 'Signal'  ||
+                child.Class === 'InputSignal' ||
+                child.Class === 'OutputSignal' ||
+                child.IsTraceable;
+  const item = {
+    Name: child.Name, Class: child.Class,
+    IsTraceable: child.IsTraceable, IsForcable: child.IsForcable,
+    Elements: child.Elements || 1
+  };
+  const row = document.createElement('div');
+  row.className = 'tree-node';
+  row.appendChild(makeLeafRow(fullPath, item, isSig));
+  return row;
+}
 
-  // All batches received — build only top-level nodes now.
-  const body = document.getElementById('tree-body');
-  const frag = document.createDocumentFragment();
-  for (const node of (_childrenOf.get('') || [])) {
-    frag.appendChild(_buildFlatNode(node));
-  }
-  body.appendChild(frag);
-
-  // Finalise autocompletes.
-  threads    = _treeBuild.threads;
-  allObjects = _treeBuild.objects;
+// Update thread selects and object autocomplete from current state.
+function _updateTreeMeta() {
   ['step-thread','step-thread-list','step-thread-inp'].forEach(id => {
     const el = document.getElementById(id);
     if (!el) return;
@@ -149,68 +218,6 @@ function onTreeBatch(msg) {
   });
   document.getElementById('msg-dest-list').innerHTML =
     allObjects.map(n => `<option value="${esc(n)}">`).join('');
-
-  _treeBuild = null;
-  _treeReady = true;
-  appendLog('sys', 'INFO', `Tree ready — ${allObjects.length} objects, ${threads.length} threads`);
-  startStepPoll();
-}
-
-// Build one flat node into a DOM element.  Containers install a toggle
-// listener that builds their children on first open (lazy load).
-function _buildFlatNode(node) {
-  if (node.ch) {
-    const details = document.createElement('details');
-    const summary = document.createElement('summary');
-    summary.innerHTML =
-      `<span class="tree-name">${esc(node.n)}</span>` +
-      `<span class="tree-class">[${esc(node.c)}]</span>`;
-    details.appendChild(summary);
-    details.addEventListener('toggle', function() {
-      if (!details.open || details._childrenBuilt) return;
-      details._childrenBuilt = true;
-      const childDiv = document.createElement('div');
-      childDiv.className = 'children';
-      const infoBtn = makeLeafButtons(node.p);
-      if (infoBtn) childDiv.appendChild(infoBtn);
-      const f = document.createDocumentFragment();
-      for (const child of (_childrenOf.get(node.p) || [])) {
-        f.appendChild(_buildFlatNode(child));
-      }
-      childDiv.appendChild(f);
-      details.appendChild(childDiv);
-    });
-    return details;
-  }
-
-  // Leaf node.
-  const isSig = node.c === 'Signal' || node.tr;
-  const item  = { Name: node.n, Class: node.c, IsTraceable: node.tr, IsForcable: node.fo };
-  const row   = document.createElement('div');
-  row.className = 'tree-node';
-  row.appendChild(makeLeafRow(node.p, item, isSig));
-  if (isSig && node.el > 1) {
-    const sub = document.createElement('div');
-    sub.style.paddingLeft = '14px';
-    for (let i = 0; i < node.el; i++) {
-      const en = `${node.p}[${i}]`;
-      sub.appendChild(makeLeafRow(en,
-        { Name:`[${i}]`, Class:'Signal', IsTraceable:true, IsForcable:node.fo }, true));
-    }
-    row.appendChild(sub);
-  }
-  return row;
-}
-
-// Force-build all lazy containers (used before a DOM-wide filter search).
-function _buildAllTreeNodes(root) {
-  let dirty = true;
-  while (dirty) {
-    dirty = false;
-    root.querySelectorAll('details').forEach(d => {
-      if (!d._childrenBuilt) { d.open = true; dirty = true; }
-    });
-  }
 }
 
 // ════════════════════════════════════════════════════════════════════
@@ -240,7 +247,10 @@ function sendOnce(cmd) {
 function _clearStartupState() {
   _cmdSent.clear();
   _treeReady = false;
-  stopStepPoll(); // always kill any running poll when state is reset
+  threads    = [];
+  allObjects = [];
+  stopStepPoll();
+  document.getElementById('tree-body').innerHTML = '';
 }
 
 function onMarteConnected() {
@@ -284,7 +294,7 @@ function onResponse(msg) {
           sendOnce('TREE');
         }
         break;
-      case 'TREE':         if (data) processTree(data); break; // fallback if Go parse fails
+      case 'TREE':         if (data) onTreeNode(data); break; // fallback if Go forwarding fails
       case 'INFO':         showInfo(msg.tag, msg.data); break;
       case 'CONFIG':       showInfo('CONFIG', msg.data); break;
       case 'SERVICE_INFO': showInfo('Service Info', msg.data); break;
@@ -369,6 +379,20 @@ function onTelemetry(msg) {
         }
       }
     }
+
+    // Sequential and waterfall — handled per base-signal-name
+    for (const nm of names) {
+      if (seqState[nm]) {
+        _processSequential(nm, s.ts, vals);
+        const seqName = seqState[nm].seqName;
+        for (const p of plots) {
+          if (p.series.some(sr => sr.name === seqName)) p.dirty = true;
+        }
+      }
+      for (const [, wf] of waterfalls) {
+        if (wf.name === nm) _wfAddRow(wf, vals);
+      }
+    }
   }
   updateTracedValues();
 }
@@ -382,12 +406,19 @@ function processDiscovery(sigs) {
   signalsByName = {};
   for (const s of sigs) {
     const el = s.elements || 1;
-    const meta = {id:s.id, name:s.name, type:s.type||'', elements:el, dimensions:s.dimensions||0, names:[s.name]};
+    // Go merges all aliases for the same signal ID into s.Names (capital N,
+    // no JSON tag → default Go serialisation key).  Fall back to [s.name] for
+    // older server builds that don't populate Names.
+    const allNames = (s.Names && s.Names.length > 0) ? s.Names : [s.name];
+    const meta = {id:s.id, name:s.name, type:s.type||'', elements:el,
+                  dimensions:s.dimensions||0, names: allNames};
     signalsById[s.id] = meta;
-    signalsByName[s.name] = meta;
-    // Array element names
-    if (el > 1) {
-      for (let i=0; i<el; i++) signalsByName[`${s.name}[${i}]`] = meta;
+    // Register every alias (canonical DataSource path + all GAM In/Out aliases)
+    for (const n of allNames) {
+      signalsByName[n] = meta;
+      if (el > 1) {
+        for (let i=0; i<el; i++) signalsByName[`${n}[${i}]`] = meta;
+      }
     }
   }
   updateSignalAutocomplete();
@@ -472,22 +503,10 @@ function buildTreeNode(item, parentPath) {
     return details;
   }
 
-  // Leaf node
+  // Leaf node — arrays are not expanded inline; use T/F/B dialog for element selection.
   const row = document.createElement('div');
   row.className = 'tree-node';
-  const leaf = makeLeafRow(path, item, isSig);
-  row.appendChild(leaf);
-
-  // Array expansion
-  if (isSig && item.Elements > 1) {
-    const sub = document.createElement('div');
-    sub.style.paddingLeft = '14px';
-    for (let i = 0; i < item.Elements; i++) {
-      const en = `${path}[${i}]`;
-      sub.appendChild(makeLeafRow(en, {Name:`[${i}]`, Class:'Signal', IsTraceable:true, IsForcable:item.IsForcable}, true));
-    }
-    row.appendChild(sub);
-  }
+  row.appendChild(makeLeafRow(path, item, isSig));
   return row;
 }
 
@@ -513,28 +532,175 @@ function makeLeafRow(path, item, isSig) {
   cls.textContent = `[${item.Class}]`;
   div.appendChild(cls);
 
+  // Array element-count badge
+  const nEl = item.Elements || 1;
+  const isArr = isSig && nEl > 1;
+  if (isArr) {
+    const badge = document.createElement('span');
+    badge.style.cssText = 'font-size:9px;color:#89b4fa;border:1px solid #45475a;border-radius:3px;padding:0 3px;flex-shrink:0;margin-left:2px';
+    badge.title = `${nEl} elements`;
+    badge.textContent = `×${nEl}`;
+    div.appendChild(badge);
+  }
+
   // Info
   const btnI = mkBtn('i', '', () => showNodeInfo(path));
   div.appendChild(btnI);
 
   if (isSig || item.IsTraceable) {
-    const btnT = mkBtn('T', 't', () => traceSignal(path, true));
-    btnT.title = 'Trace';
+    const btnT = mkBtn('T', 't', () => {
+      if (isArr) openArrayDialog(path, nEl, 'trace');
+      else traceSignal(path, true);
+    });
+    btnT.title = isArr ? 'Trace elements…' : 'Trace';
     div.appendChild(btnT);
   }
   if (item.IsForcable || isSig) {
-    const btnF = mkBtn('F', 'f', () => openForceDialogFor(path));
-    btnF.title = 'Force';
+    const btnF = mkBtn('F', 'f', () => {
+      if (isArr) openArrayDialog(path, nEl, 'force');
+      else openForceDialogFor(path);
+    });
+    btnF.title = isArr ? 'Force elements…' : 'Force';
     div.appendChild(btnF);
   }
   if (isSig || item.IsTraceable) {
-    const btnB = mkBtn('B', 'b', () => openBreakDialogFor(path));
-    btnB.title = 'Break';
+    const btnB = mkBtn('B', 'b', () => {
+      if (isArr) openArrayDialog(path, nEl, 'break');
+      else openBreakDialogFor(path);
+    });
+    btnB.title = isArr ? 'Break on element…' : 'Break';
     div.appendChild(btnB);
   }
   return div;
 }
 
+// ════════════════════════════════════════════════════════════════════
+// Array signal dialog (trace / force / break with index/range selection)
+// ════════════════════════════════════════════════════════════════════
+
+let _arrPath = '', _arrElem = 0, _arrAction = '', _arrSel = 'all';
+
+function setArrSel(s) {
+  _arrSel = s;
+  ['all','idx','rng'].forEach(id => {
+    const btn = document.getElementById(`arr-sel-${id}`);
+    if (btn) btn.className = (id === s) ? 'active' : '';
+  });
+  const idxSect = document.getElementById('arr-idx-sect');
+  const rngSect = document.getElementById('arr-rng-sect');
+  if (idxSect) idxSect.style.display = s === 'idx' ? '' : 'none';
+  if (rngSect) rngSect.style.display = s === 'rng' ? '' : 'none';
+}
+
+function openArrayDialog(path, elements, action) {
+  _arrPath   = path;
+  _arrElem   = elements;
+  _arrAction = action;
+  document.getElementById('arr-dlg-title').textContent =
+    action === 'trace' ? '📊 Trace Array' :
+    action === 'force' ? '⚡ Force Array' : '🔴 Break Array';
+  document.getElementById('arr-dlg-sig').textContent  = path;
+  document.getElementById('arr-dlg-n').textContent    = elements;
+  document.getElementById('arr-idx-max').textContent  = elements - 1;
+  document.getElementById('arr-idx').max  = elements - 1;
+  document.getElementById('arr-r0').max   = elements - 1;
+  document.getElementById('arr-r1').max   = elements - 1;
+  document.getElementById('arr-r1').value = elements - 1;
+  document.getElementById('arr-force-sect').style.display = action === 'force' ? '' : 'none';
+  document.getElementById('arr-break-sect').style.display = action === 'break' ? '' : 'none';
+  document.getElementById('arr-ok-btn').textContent =
+    action === 'trace' ? 'Trace' : action === 'force' ? 'Force' : 'Set Break';
+  setArrSel('all');
+  openDlg('dlg-array');
+}
+
+function _arrIndices() {
+  if (_arrSel === 'idx') {
+    const v = Math.min(Math.max(0, parseInt(document.getElementById('arr-idx').value)||0), _arrElem-1);
+    return [v];
+  }
+  if (_arrSel === 'rng') {
+    const s = Math.min(Math.max(0, parseInt(document.getElementById('arr-r0').value)||0), _arrElem-1);
+    const e = Math.min(Math.max(s, parseInt(document.getElementById('arr-r1').value)||0), _arrElem-1);
+    return Array.from({length: e-s+1}, (_,i) => s+i);
+  }
+  // 'all'
+  return Array.from({length: _arrElem}, (_,i) => i);
+}
+
+function doArrayOp() {
+  const indices = _arrIndices();
+  const isAll   = indices.length === _arrElem;
+
+  if (_arrAction === 'trace') {
+    // One TRACE command covers the whole array; browser filters per element.
+    sendCmd(`TRACE ${_arrPath} 1`);
+    for (const i of indices) {
+      const n = `${_arrPath}[${i}]`;
+      tracedSet.add(n);
+      if (!traceData[n]) traceData[n] = {ts:[], vals:[], lastVal:0, color: nextColor()};
+    }
+    // All / Range → group in the trace list (one collapsible row per base signal).
+    // Single-index → kept as an ungrouped individual entry.
+    if (_arrSel !== 'idx') {
+      const meta = signalsByName[_arrPath];
+      const nEl  = meta ? meta.elements : _arrElem;
+      const grp  = tracedGroups.get(_arrPath);
+      if (grp) {
+        for (const i of indices) grp.indices.add(i);
+      } else {
+        tracedGroups.set(_arrPath, {indices: new Set(indices), elements: nEl, expanded: false});
+      }
+    }
+    renderTracedTab();
+
+  } else if (_arrAction === 'force') {
+    const val = document.getElementById('arr-force-val').value.trim();
+    if (!val) { closeDlg('dlg-array'); return; }
+    if (_arrSel === 'idx') {
+      // Single index — kept as an ungrouped individual entry.
+      const i = indices[0];
+      sendCmd(`FORCE ${_arrPath}[${i}] ${val}`);
+      forcedSignals[`${_arrPath}[${i}]`] = val;
+    } else {
+      // All / Range — grouped display (one collapsible row).
+      const meta = signalsByName[_arrPath];
+      const nEl  = meta ? meta.elements : _arrElem;
+      if (isAll) {
+        sendCmd(`FORCE ${_arrPath} ${val}`);
+      } else {
+        for (const i of indices) sendCmd(`FORCE ${_arrPath}[${i}] ${val}`);
+      }
+      const grp = forcedGroups.get(_arrPath);
+      if (grp) {
+        for (const i of indices) grp.indices.add(i);
+        grp.value = val;
+        grp.isAll = isAll || (grp.isAll && grp.indices.size === nEl);
+      } else {
+        forcedGroups.set(_arrPath, {isAll, indices: new Set(indices), elements: nEl, value: val, expanded: false});
+      }
+    }
+    renderForcedTab();
+
+  } else { // break
+    const op  = document.getElementById('arr-break-op').value;
+    const thr = document.getElementById('arr-break-thr').value.trim();
+    if (!thr) { closeDlg('dlg-array'); return; }
+    if (isAll) {
+      sendCmd(`BREAK ${_arrPath} ${op} ${thr}`);
+      breakpoints[_arrPath] = {op, threshold: thr};
+    } else {
+      for (const i of indices) {
+        const n = `${_arrPath}[${i}]`;
+        sendCmd(`BREAK ${n} ${op} ${thr}`);
+        breakpoints[n] = {op, threshold: thr};
+      }
+    }
+    renderBreaksTab();
+  }
+  closeDlg('dlg-array');
+}
+
 function makeLeafButtons(path) {
   // Returns a row of buttons for container nodes (no name/class display)
   const div = document.createElement('div');
@@ -556,9 +722,8 @@ function filterTree(q) {
   const body = document.getElementById('tree-body');
   q = q.toLowerCase();
   if (q) {
-    // Build all lazy nodes so the querySelectorAll below sees everything.
-    _buildAllTreeNodes(body);
-    body.querySelectorAll('details').forEach(d => d.open = true);
+    // Open already-loaded containers so their leaves are visible.
+    body.querySelectorAll('details').forEach(d => { if (d._childrenBuilt) d.open = true; });
   }
   body.querySelectorAll('.tree-leaf').forEach(el => {
     if (!q) { el.style.display = ''; return; }
@@ -572,52 +737,171 @@ function filterTree(q) {
 // ════════════════════════════════════════════════════════════════════
 
 function traceSignal(name, enable) {
+  // For element refs like "Signal[3]", the server only knows the base name.
+  const bracketMatch = name.match(/^(.+)\[\d+\]$/);
+  const baseName = bracketMatch ? bracketMatch[1] : name;
   if (enable) {
     tracedSet.add(name);
     if (!traceData[name]) traceData[name] = {ts:[], vals:[], lastVal:0, color: nextColor()};
-    sendCmd(`TRACE ${name} 1`);
+    sendCmd(`TRACE ${baseName} 1`);
   } else {
     tracedSet.delete(name);
-    sendCmd(`TRACE ${name} 0`);
+    // For element refs: only disable server tracing when no other elements remain.
+    if (bracketMatch) {
+      const anyLeft = tracedSet.has(baseName) ||
+                      [...tracedSet].some(n => n.startsWith(baseName + '['));
+      if (!anyLeft) sendCmd(`TRACE ${baseName} 0`);
+    } else {
+      sendCmd(`TRACE ${name} 0`);
+    }
   }
   renderTracedTab();
 }
 
+function untraceGroup(baseName) {
+  const grp = tracedGroups.get(baseName);
+  if (grp) {
+    for (const i of grp.indices) tracedSet.delete(`${baseName}[${i}]`);
+    tracedGroups.delete(baseName);
+  }
+  // Only send TRACE OFF if no ungrouped elements remain
+  const anyLeft = tracedSet.has(baseName) ||
+                  [...tracedSet].some(n => n.startsWith(baseName + '['));
+  if (!anyLeft) sendCmd(`TRACE ${baseName} 0`);
+  renderTracedTab();
+}
+
 function renderTracedTab() {
-  const tab = document.getElementById('tab-traced');
+  const tab  = document.getElementById('tab-traced');
   const hint = document.getElementById('no-traced-hint');
-  hint.style.display = tracedSet.size ? 'none' : 'block';
-  // Remove old sig-items
-  tab.querySelectorAll('.sig-item').forEach(e=>e.remove());
+  hint.style.display = (tracedSet.size === 0 && tracedGroups.size === 0) ? 'block' : 'none';
+  tab.querySelectorAll('.sig-item,.sig-group').forEach(e => e.remove());
+
+  // Build set of entries already covered by a group
+  const grouped = new Set();
+
+  // ── Grouped array signals ─────────────────────────────────────────
+  for (const [baseName, grp] of tracedGroups) {
+    const sortedIdx = [...grp.indices].sort((a, b) => a - b);
+    for (const i of sortedIdx) grouped.add(`${baseName}[${i}]`);
+
+    const firstN  = `${baseName}[${sortedIdx[0]}]`;
+    const firstTd = traceData[firstN];
+    const color   = firstTd?.color || COLORS[0];
+
+    // Header row (dragging it puts baseName so addSignalToPlot opens array mode)
+    const hdr = document.createElement('div');
+    hdr.className = 'sig-group';
+    hdr.draggable = true;
+    hdr.addEventListener('dragstart', e => {
+      e.dataTransfer.setData('text/plain', baseName);
+      e.dataTransfer.effectAllowed = 'copy';
+    });
+
+    const expBtn = document.createElement('span');
+    expBtn.className = 'sig-group-exp';
+    expBtn.textContent = grp.expanded ? '▾' : '▸';
+    expBtn.title = grp.expanded ? 'Collapse' : 'Expand elements';
+    expBtn.addEventListener('click', e => {
+      e.stopPropagation(); e.preventDefault();
+      grp.expanded = !grp.expanded;
+      renderTracedTab();
+    });
+
+    const dot = document.createElement('span');
+    dot.className = 'sig-dot'; dot.style.background = color; dot.draggable = false;
+
+    const nm = document.createElement('span');
+    nm.className = 'sig-name'; nm.title = baseName;
+    nm.textContent = shortName(baseName); nm.draggable = false;
+
+    const badge = document.createElement('span');
+    badge.style.cssText = 'font-size:9px;color:#89b4fa;border:1px solid #45475a;border-radius:3px;padding:0 3px;flex-shrink:0;margin-left:2px';
+    badge.title = `${grp.indices.size} element${grp.indices.size > 1 ? 's' : ''} traced`;
+    badge.textContent = `×${grp.indices.size}`;
+
+    const val = document.createElement('span');
+    val.className = 'sig-val';
+    val.textContent = firstTd ? fmtVal(firstTd.lastVal) : '—';
+    val.id = `tval-grp-${CSS.escape(baseName)}`;
+
+    const btnR = mkBtn('×', 'danger', () => untraceGroup(baseName));
+    btnR.style.cssText = 'font-size:11px;padding:0 4px;border-color:#f38ba8;color:#f38ba8;background:transparent';
+    btnR.addEventListener('dragstart', e => e.preventDefault());
+
+    hdr.append(expBtn, dot, nm, badge, val, btnR);
+    tab.appendChild(hdr);
+
+    // Expanded: individual index sub-rows
+    if (grp.expanded) {
+      for (const i of sortedIdx) {
+        const n  = `${baseName}[${i}]`;
+        const td = traceData[n];
+
+        const sub = document.createElement('div');
+        sub.className = 'sig-item sig-item-sub';
+        sub.draggable = true;
+        sub.addEventListener('dragstart', e => {
+          e.dataTransfer.setData('text/plain', n);
+          e.dataTransfer.effectAllowed = 'copy';
+        });
+
+        const sdot = document.createElement('span');
+        sdot.className = 'sig-dot'; sdot.style.background = td?.color || color; sdot.draggable = false;
+
+        const snm = document.createElement('span');
+        snm.className = 'sig-name'; snm.title = n;
+        snm.textContent = `[${i}]`; snm.draggable = false;
+
+        const sval = document.createElement('span');
+        sval.className = 'sig-val';
+        sval.textContent = td ? fmtVal(td.lastVal) : '—';
+        sval.id = `tval-${CSS.escape(n)}`; sval.draggable = false;
+
+        const sbtnR = mkBtn('×', 'danger', () => {
+          tracedSet.delete(n); grp.indices.delete(i);
+          if (grp.indices.size === 0) { tracedGroups.delete(baseName); sendCmd(`TRACE ${baseName} 0`); }
+          renderTracedTab();
+        });
+        sbtnR.style.cssText = 'font-size:11px;padding:0 4px;border-color:#f38ba8;color:#f38ba8;background:transparent';
+        sbtnR.addEventListener('dragstart', e => e.preventDefault());
+
+        sub.append(sdot, snm, sval, sbtnR);
+        tab.appendChild(sub);
+      }
+    }
+  }
+
+  // ── Individual (non-grouped) signals ────────────────────────────
   let colorIdx = 0;
   for (const name of tracedSet) {
-    const td = traceData[name];
+    if (grouped.has(name)) continue;
+    const td    = traceData[name];
     const color = td ? td.color : COLORS[colorIdx++ % COLORS.length];
+
     const div = document.createElement('div');
-    div.className = 'sig-item';
-    div.draggable = true;
+    div.className = 'sig-item'; div.draggable = true;
     div.addEventListener('dragstart', e => {
       e.dataTransfer.setData('text/plain', name);
       e.dataTransfer.effectAllowed = 'copy';
     });
+
     const dot = document.createElement('span');
-    dot.className = 'sig-dot';
-    dot.style.background = color;
-    dot.draggable = false;
+    dot.className = 'sig-dot'; dot.style.background = color; dot.draggable = false;
+
     const nm = document.createElement('span');
-    nm.className = 'sig-name';
-    nm.title = name;
-    nm.textContent = shortName(name);
-    nm.draggable = false;
+    nm.className = 'sig-name'; nm.title = name;
+    nm.textContent = shortName(name); nm.draggable = false;
+
     const val = document.createElement('span');
     val.className = 'sig-val';
     val.textContent = td ? fmtVal(td.lastVal) : '—';
-    val.id = `tval-${CSS.escape(name)}`;
-    val.draggable = false;
+    val.id = `tval-${CSS.escape(name)}`; val.draggable = false;
+
     const btnR = mkBtn('×', 'danger', () => traceSignal(name, false));
     btnR.style.cssText = 'font-size:11px;padding:0 4px;border-color:#f38ba8;color:#f38ba8;background:transparent';
-    // Stop drag from starting when clicking the button
     btnR.addEventListener('dragstart', e => e.preventDefault());
+
     div.append(dot, nm, val, btnR);
     tab.appendChild(div);
   }
@@ -632,6 +916,15 @@ function updateTracedValues() {
     const el = document.getElementById(`tval-${CSS.escape(name)}`);
     if (el) el.textContent = fmtVal(td.lastVal);
   }
+  // Update group header values (shows lowest-index element's current value).
+  for (const [baseName, grp] of tracedGroups) {
+    const el = document.getElementById(`tval-grp-${CSS.escape(baseName)}`);
+    if (!el) continue;
+    const sortedIdx = [...grp.indices].sort((a, b) => a - b);
+    if (sortedIdx.length === 0) continue;
+    const td = traceData[`${baseName}[${sortedIdx[0]}]`];
+    if (td) el.textContent = fmtVal(td.lastVal);
+  }
 }
 
 // ════════════════════════════════════════════════════════════════════
@@ -666,22 +959,109 @@ function confirmUnforce(name) {
   document.getElementById('unforce-msg').textContent = `Remove force on "${name}"?`;
   openDlg('dlg-unforce');
 }
+function unforceGroup(baseName) {
+  const grp = forcedGroups.get(baseName);
+  if (!grp) return;
+  if (grp.isAll) {
+    sendCmd(`UNFORCE ${baseName}`);
+  } else {
+    for (const i of grp.indices) sendCmd(`UNFORCE ${baseName}[${i}]`);
+  }
+  forcedGroups.delete(baseName);
+  renderForcedTab();
+}
+
 function renderForcedTab() {
   const tab = document.getElementById('tab-forced');
-  tab.querySelectorAll('.sig-item').forEach(e=>e.remove());
+  tab.querySelectorAll('.sig-item,.sig-group').forEach(e => e.remove());
   const hint = document.getElementById('no-forced-hint');
-  const keys = Object.keys(forcedSignals);
-  hint.style.display = keys.length ? 'none' : 'block';
-  for (const name of keys) {
+  hint.style.display = (Object.keys(forcedSignals).length === 0 && forcedGroups.size === 0) ? 'block' : 'none';
+
+  // ── Grouped array forces ─────────────────────────────────────────
+  for (const [baseName, grp] of forcedGroups) {
+    const sortedIdx = [...grp.indices].sort((a, b) => a - b);
+
+    const hdr = document.createElement('div');
+    hdr.className = 'sig-group';
+
+    const expBtn = document.createElement('span');
+    expBtn.className = 'sig-group-exp';
+    expBtn.textContent = grp.expanded ? '▾' : '▸';
+    expBtn.title = grp.expanded ? 'Collapse' : 'Expand elements';
+    expBtn.addEventListener('click', e => {
+      e.stopPropagation(); e.preventDefault();
+      grp.expanded = !grp.expanded;
+      renderForcedTab();
+    });
+
+    const nm = document.createElement('span');
+    nm.className = 'sig-name'; nm.title = baseName;
+    nm.textContent = shortName(baseName); nm.draggable = false;
+
+    const badge = document.createElement('span');
+    badge.style.cssText = 'font-size:9px;color:#89b4fa;border:1px solid #45475a;border-radius:3px;padding:0 3px;flex-shrink:0;margin-left:2px';
+    badge.title = grp.isAll ? 'all elements forced' : `${grp.indices.size} element${grp.indices.size > 1 ? 's' : ''} forced`;
+    badge.textContent = grp.isAll ? '×all' : `×${grp.indices.size}`;
+
+    const val = document.createElement('span');
+    val.className = 'sig-val'; val.style.color = '#f9e2af';
+    val.textContent = grp.value;
+
+    const btnR = mkBtn('×', 'danger', () => unforceGroup(baseName));
+    btnR.style.cssText = 'font-size:11px;padding:0 4px;border-color:#f38ba8;color:#f38ba8;background:transparent';
+
+    hdr.append(expBtn, nm, badge, val, btnR);
+    tab.appendChild(hdr);
+
+    if (grp.expanded) {
+      const dispIdx = grp.isAll ? Array.from({length: grp.elements}, (_, i) => i) : sortedIdx;
+      for (const i of dispIdx) {
+        const sub = document.createElement('div');
+        sub.className = 'sig-item sig-item-sub';
+
+        const snm = document.createElement('span');
+        snm.className = 'sig-name'; snm.title = `${baseName}[${i}]`;
+        snm.textContent = `[${i}]`; snm.draggable = false;
+
+        const sval = document.createElement('span');
+        sval.className = 'sig-val'; sval.style.color = '#f9e2af';
+        sval.textContent = grp.value; sval.draggable = false;
+
+        const sbtnR = mkBtn('×', 'danger', () => {
+          if (grp.isAll) {
+            // Re-force all other elements individually, then drop the group.
+            forcedGroups.delete(baseName);
+            sendCmd(`UNFORCE ${baseName}`);
+            for (const j of dispIdx) {
+              if (j !== i) {
+                sendCmd(`FORCE ${baseName}[${j}] ${grp.value}`);
+                forcedSignals[`${baseName}[${j}]`] = grp.value;
+              }
+            }
+          } else {
+            sendCmd(`UNFORCE ${baseName}[${i}]`);
+            grp.indices.delete(i);
+            if (grp.indices.size === 0) forcedGroups.delete(baseName);
+          }
+          renderForcedTab();
+        });
+        sbtnR.style.cssText = 'font-size:11px;padding:0 4px;border-color:#f38ba8;color:#f38ba8;background:transparent';
+
+        sub.append(snm, sval, sbtnR);
+        tab.appendChild(sub);
+      }
+    }
+  }
+
+  // ── Individual (scalar / single-index) forces ────────────────────
+  for (const name of Object.keys(forcedSignals)) {
     const div = document.createElement('div');
     div.className = 'sig-item';
     const nm = document.createElement('span');
-    nm.className = 'sig-name';
-    nm.title = name;
+    nm.className = 'sig-name'; nm.title = name;
     nm.textContent = shortName(name);
     const val = document.createElement('span');
-    val.className = 'sig-val';
-    val.style.color = '#f9e2af';
+    val.className = 'sig-val'; val.style.color = '#f9e2af';
     val.textContent = forcedSignals[name];
     const btnR = mkBtn('×', '', () => confirmUnforce(name));
     btnR.style.cssText = 'font-size:11px;padding:0 4px;border-color:#f38ba8;color:#f38ba8;background:transparent';
@@ -983,7 +1363,7 @@ function deletePlot(id) {
   const idx = plots.findIndex(p=>p.id===id);
   if (idx>=0) { plots.splice(idx,1); }
   document.getElementById(`plot-card-${id}`)?.remove();
-  if (plots.length === 0) document.getElementById('no-plots-hint').style.display = 'block';
+  if (plots.length === 0 && waterfalls.size === 0) document.getElementById('no-plots-hint').style.display = 'block';
 }
 
 function setMaxPts(id, v) { const p = findPlot(id); if(p) p.maxPts = parseInt(v)||50000; }
@@ -993,6 +1373,15 @@ function fitPlot(id) { const p = findPlot(id); if(p&&p.chart) p.chart.setScale('
 function addSignalToPlot(id, name) {
   const p = findPlot(id);
   if (!p) return;
+
+  // Array signal (whole array, not a specific element like name[i]): show mode dialog
+  const meta = signalsByName[name];
+  const isElementRef = /\[\d+\]$/.test(name);
+  if (meta && meta.elements > 1 && !isElementRef) {
+    openArrayPlotDialog(id, name, meta.elements);
+    return;
+  }
+
   if (p.series.find(s=>s.name===name)) return; // already added
 
   // Ensure tracing
@@ -1010,6 +1399,12 @@ function removeSignalFromPlot(id, name) {
   const p = findPlot(id);
   if (!p) return;
   p.series = p.series.filter(s=>s.name!==name);
+  // Clean up sequential state if no plot uses this seq series any more
+  if (name.endsWith('#seq')) {
+    const baseName = name.slice(0, -4);
+    const stillUsed = plots.some(pl => pl.series.some(s => s.name === name));
+    if (!stillUsed) delete seqState[baseName];
+  }
   updateSeriesBar(p);
   rebuildChart(p);
 }
@@ -1019,11 +1414,12 @@ function updateSeriesBar(p) {
   if (!bar) return;
   bar.innerHTML = '';
   for (const s of p.series) {
+    const dispName = s.displayName || s.name;
     const chip = document.createElement('span');
     chip.className = 'series-chip';
     chip.innerHTML =
       `<span class="series-chip-dot" style="background:${s.color}"></span>` +
-      `<span class="series-chip-name" title="${esc(s.name)}">${esc(shortName(s.name))}</span>` +
+      `<span class="series-chip-name" title="${esc(s.name)}">${esc(shortName(dispName))}</span>` +
       `<button class="series-chip-rm" title="Remove signal">×</button>`;
     chip.querySelector('.series-chip-rm').addEventListener('click', () => removeSignalFromPlot(p.id, s.name));
     bar.appendChild(chip);
@@ -1114,48 +1510,339 @@ function rebuildChart(p) {
   });
 }
 
+// ════════════════════════════════════════════════════════════════════
+// LTTB (Largest-Triangle-Three-Buckets) downsampling
+//
+// Returns { xs, ys, indices } where indices[i] is the original array
+// position chosen for output point i.  Using indices lets us apply the
+// same selection to co-plotted series without running LTTB on each one.
+// ════════════════════════════════════════════════════════════════════
+
+function lttbWithIndices(xs, ys, threshold) {
+  const n = xs.length;
+  if (n <= threshold) {
+    const idx = Array.from({length: n}, (_, i) => i);
+    return {xs, ys, indices: idx};
+  }
+
+  const outX = new Array(threshold);
+  const outY = new Array(threshold);
+  const outI = new Array(threshold);
+
+  outX[0] = xs[0]; outY[0] = ys[0]; outI[0] = 0;
+  outX[threshold - 1] = xs[n - 1];
+  outY[threshold - 1] = ys[n - 1];
+  outI[threshold - 1] = n - 1;
+
+  const bucketSize = (n - 2) / (threshold - 2);
+  let aIdx = 0;
+
+  for (let i = 0; i < threshold - 2; i++) {
+    // Average of the next bucket (used as the "future" anchor point).
+    const nextFrom = Math.floor((i + 1) * bucketSize) + 1;
+    const nextTo   = Math.min(Math.floor((i + 2) * bucketSize) + 1, n);
+    let avgX = 0, avgY = 0;
+    for (let j = nextFrom; j < nextTo; j++) { avgX += xs[j]; avgY += ys[j]; }
+    const cnt = nextTo - nextFrom;
+    avgX /= cnt; avgY /= cnt;
+
+    // Pick the point in the current bucket that forms the largest triangle
+    // with point a (last selected) and the next-bucket average.
+    const from = Math.floor(i * bucketSize) + 1;
+    const to   = Math.min(Math.floor((i + 1) * bucketSize) + 1, n);
+    const ax = xs[aIdx], ay = ys[aIdx];
+    let maxArea = -1, maxIdx = from;
+    for (let j = from; j < to; j++) {
+      const area = Math.abs((ax - avgX) * (ys[j] - ay) - (ax - xs[j]) * (avgY - ay));
+      if (area > maxArea) { maxArea = area; maxIdx = j; }
+    }
+
+    outX[i + 1] = xs[maxIdx];
+    outY[i + 1] = ys[maxIdx];
+    outI[i + 1] = maxIdx;
+    aIdx = maxIdx;
+  }
+
+  return {xs: outX, ys: outY, indices: outI};
+}
+
 function buildPlotData(p) {
   const maxPts = p.maxPts;
-  // Find common time range: union of all series timestamps
-  // uPlot requires aligned data — we use each series' own timestamps
-  // For simplicity use the first non-empty series timestamps as X axis,
-  // and for other series linearly interpolate.
-  // Simpler approach: collect all unique timestamps (sorted) and use NaN for missing.
 
-  // Per-series data
-  const seriesTs = p.series.map(s => {
+  // Step 1: LTTB each series independently so every series keeps its own
+  // timestamps.  Sharing LTTB indices across series is only valid when all
+  // series share the same time base, which is not the case for signals from
+  // different RT threads running at different rates.
+  const dsTs = [];
+  const dsVs = [];
+  for (const s of p.series) {
     const td = traceData[s.name];
-    return td ? td.ts : [];
-  });
-  const seriesVs = p.series.map(s => {
-    const td = traceData[s.name];
-    if (!td) return [];
-    return td.vals.map(v => v * s.gain + s.offset);
-  });
+    const rawTs = td ? td.ts : [];
+    if (rawTs.length === 0) { dsTs.push([]); dsVs.push([]); continue; }
+    const scaled = td.vals.map(v => v * s.gain + s.offset);
+    if (rawTs.length > maxPts) {
+      const r = lttbWithIndices(rawTs, scaled, maxPts);
+      dsTs.push(r.xs);
+      dsVs.push(r.ys);
+    } else {
+      dsTs.push(rawTs.slice());
+      dsVs.push(scaled);
+    }
+  }
 
-  // Use first series with data as the X reference, or merge all
-  let xRef = [];
-  for (const ts of seriesTs) if (ts.length > 0) { xRef = ts; break; }
-  if (xRef.length === 0) return [[]];
-
-  // Trim to maxPts
-  const start = Math.max(0, xRef.length - maxPts);
-  const times = xRef.slice(start);
+  // Step 2: Build a sorted merged time axis from all downsampled series.
+  const allTsSet = new Set();
+  for (const ts of dsTs) for (const t of ts) allTsSet.add(t);
+  if (allTsSet.size === 0) return [[]];
+  const times = [...allTsSet].sort((a, b) => a - b);
 
+  // Step 3: For each series, place values only at the timestamps that belong
+  // to that series; all other merged times stay NaN.  uPlot then draws straight
+  // lines between consecutive known points — no staircase artefact for signals
+  // at different sample rates (e.g. a 1 Hz scalar alongside a 100-pt/s
+  // sequential array series).
   const data = [times];
   for (let i = 0; i < p.series.length; i++) {
-    const ts = seriesTs[i];
-    const vs = seriesVs[i];
-    if (ts.length === 0) {
-      data.push(new Array(times.length).fill(NaN));
-      continue;
-    }
-    const s = Math.max(0, ts.length - maxPts);
-    data.push(vs.slice(s));
+    const ts = dsTs[i];
+    const vs = dsVs[i];
+    if (ts.length === 0) { data.push(new Array(times.length).fill(NaN)); continue; }
+    const tsMap = new Map();
+    for (let j = 0; j < ts.length; j++) tsMap.set(ts[j], vs[j]);
+    data.push(times.map(t => { const v = tsMap.get(t); return v !== undefined ? v : NaN; }));
   }
   return data;
 }
 
+// ════════════════════════════════════════════════════════════════════
+// Array → plot: dialog + sequential + waterfall
+// ════════════════════════════════════════════════════════════════════
+
+const _arrpDescs = {
+  sequential: 'Unroll elements as a dense time series — timestamps interpolated between consecutive samples.',
+  waterfall:  '2D heatmap (index × time) — array index on X-axis, newest sample at bottom.',
+};
+let _arrpMode = 'sequential';
+
+function setArrpMode(mode) {
+  _arrpMode = mode;
+  ['sequential', 'waterfall'].forEach(id => {
+    const btn = document.getElementById(`arrp-sel-${id}`);
+    if (btn) btn.className = (id === mode) ? 'active' : '';
+  });
+  const desc = document.getElementById('arrp-desc');
+  if (desc) desc.textContent = _arrpDescs[mode] || '';
+}
+
+function openArrayPlotDialog(plotId, name, nEl) {
+  _arrpPlotId = plotId;
+  _arrpName   = name;
+  _arrpElem   = nEl;
+  document.getElementById('arrp-name').textContent = name;
+  document.getElementById('arrp-n').textContent    = nEl;
+  setArrpMode('sequential');
+  document.getElementById('dlg-arr-plot').style.display = 'flex';
+}
+
+function doArrayPlotMode() {
+  closeDlg('dlg-arr-plot');
+  if (_arrpMode === 'sequential') {
+    _addSequentialToPlot(_arrpPlotId, _arrpName, _arrpElem);
+  } else {
+    _addWaterfall(_arrpName, _arrpElem);
+  }
+}
+
+// ── Sequential ──────────────────────────────────────────────────────
+
+function _addSequentialToPlot(plotId, name, nEl) {
+  const p = findPlot(plotId);
+  if (!p) return;
+  const seqName = name + '#seq';
+  if (p.series.find(s => s.name === seqName)) return;
+
+  // Ensure base signal is traced (we receive all elements as a bundle)
+  sendCmd(`TRACE ${name} 1`);
+  tracedSet.add(name);
+  if (!traceData[seqName]) traceData[seqName] = {ts:[], vals:[], lastVal:0, color: nextColor()};
+  if (!seqState[name]) seqState[name] = {seqName, nEl, lastTs: null};
+
+  const color = traceData[seqName].color;
+  // displayName shown in the series chip
+  p.series.push({name: seqName, color, gain:1, offset:0,
+                 displayName: shortName(name) + ' [seq]'});
+  updateSeriesBar(p);
+  rebuildChart(p);
+  p.dirty = true;
+}
+
+function _processSequential(baseName, ts, vals) {
+  const st = seqState[baseName];
+  if (!st) return;
+  const td = traceData[st.seqName];
+  if (!td) return;
+  const prevTs = st.lastTs;
+  if (prevTs !== null) {
+    const n  = Math.min(st.nEl, vals.length);
+    const dt = ts - prevTs;
+    for (let e = 0; e < n; e++) {
+      td.ts.push(prevTs + (e + 1) / n * dt);
+      td.vals.push(vals[e]);
+    }
+    td.lastVal = vals[n - 1];
+    if (td.ts.length > MAX_TRACE_PTS) {
+      const trim = td.ts.length - MAX_TRACE_PTS;
+      td.ts.splice(0, trim);
+      td.vals.splice(0, trim);
+    }
+  }
+  st.lastTs = ts;
+}
+
+// ── Waterfall ───────────────────────────────────────────────────────
+
+function _wfViridis(t) {
+  const stops = [[68,1,84],[58,82,139],[32,144,141],[94,201,98],[253,231,37]];
+  t = Math.max(0, Math.min(1, t));
+  const i  = t * (stops.length - 1);
+  const lo = Math.floor(i);
+  const hi = Math.min(lo + 1, stops.length - 1);
+  const f  = i - lo;
+  return [
+    (stops[lo][0] + (stops[hi][0] - stops[lo][0]) * f) | 0,
+    (stops[lo][1] + (stops[hi][1] - stops[lo][1]) * f) | 0,
+    (stops[lo][2] + (stops[hi][2] - stops[lo][2]) * f) | 0,
+  ];
+}
+
+function _addWaterfall(name, nEl) {
+  wfSeq++;
+  const id   = wfSeq;
+  const nRows = 200;
+
+  const card = document.createElement('div');
+  card.className = 'plot-card';
+  card.id = `wf-card-${id}`;
+  card.innerHTML =
+    `<div class="plot-header">` +
+      `<span class="plot-title">Waterfall: ${esc(shortName(name))}</span>` +
+      `<span style="display:flex;align-items:center;gap:6px;font-size:10px;color:#a6adc8">` +
+        `Min:<input type="number" id="wf-min-${id}" value="0" style="width:56px" onchange="setWfRange(${id})">` +
+        `Max:<input type="number" id="wf-max-${id}" value="1" style="width:56px" onchange="setWfRange(${id})">` +
+        `<label style="display:flex;align-items:center;gap:4px">` +
+          `<input type="checkbox" id="wf-auto-${id}" checked onchange="setWfRange(${id})"> Auto` +
+        `</label>` +
+      `</span>` +
+      `<button onclick="deleteWaterfall(${id})" style="font-size:10px;padding:1px 6px;color:#f38ba8;border-color:#f38ba8">✕</button>` +
+    `</div>` +
+    `<div id="wf-wrap-${id}" style="flex:1;min-height:0;overflow:hidden">` +
+      `<canvas id="wf-canvas-${id}" style="width:100%;height:100%;display:block;image-rendering:pixelated"></canvas>` +
+    `</div>`;
+
+  document.getElementById('center-panel').appendChild(card);
+  document.getElementById('no-plots-hint').style.display = 'none';
+
+  const canvas = document.getElementById(`wf-canvas-${id}`);
+  const ctx    = canvas.getContext('2d');
+
+  // Circular row buffer
+  const rows   = [];
+  const rowMin = [];
+  const rowMax = [];
+  for (let r = 0; r < nRows; r++) {
+    rows.push(new Float32Array(nEl));
+    rowMin.push(0); rowMax.push(0);
+  }
+
+  const wf = {id, card, canvas, ctx, name, nEl, nRows,
+              rows, rowMin, rowMax,
+              colorMin: 0, colorMax: 1, autoRange: true, dirty: false};
+  waterfalls.set(id, wf);
+
+  _wfResize(wf);
+
+  // Lazy-init the shared ResizeObserver
+  if (!wfRO) {
+    wfRO = new ResizeObserver(entries => {
+      for (const en of entries) {
+        const m = en.target.id.match(/^wf-wrap-(\d+)$/);
+        if (m) { const w = waterfalls.get(parseInt(m[1])); if (w) _wfResize(w); }
+      }
+    });
+  }
+  wfRO.observe(document.getElementById(`wf-wrap-${id}`));
+
+  // Ensure base signal is traced (all elements in each packet)
+  sendCmd(`TRACE ${name} 1`);
+  tracedSet.add(name);
+}
+
+function _wfResize(wf) {
+  const wrap = document.getElementById(`wf-wrap-${wf.id}`);
+  if (!wrap) return;
+  wf.canvas.width  = wf.nEl;
+  wf.canvas.height = wf.nRows;
+  _wfRedraw(wf);
+}
+
+function _wfRedraw(wf) {
+  const {ctx, nEl, nRows, rows, rowMin, rowMax} = wf;
+  let mn = wf.colorMin, mx = wf.colorMax;
+  if (wf.autoRange) {
+    mn = Infinity; mx = -Infinity;
+    for (let r = 0; r < nRows; r++) { if (rowMin[r] < mn) mn = rowMin[r]; if (rowMax[r] > mx) mx = rowMax[r]; }
+    if (!isFinite(mn) || mn === mx) { mn = 0; mx = 1; }
+  }
+  const img = ctx.createImageData(nEl, nRows);
+  const d   = img.data;
+  const rng = mx - mn || 1;
+  for (let r = 0; r < nRows; r++) {
+    const row = rows[r];
+    for (let c = 0; c < nEl; c++) {
+      const t = (row[c] - mn) / rng;
+      const [R, G, B] = _wfViridis(t);
+      const i = (r * nEl + c) * 4;
+      d[i] = R; d[i+1] = G; d[i+2] = B; d[i+3] = 255;
+    }
+  }
+  ctx.putImageData(img, 0, 0);
+}
+
+function _wfAddRow(wf, vals) {
+  // Shift rows up, append new row at bottom
+  wf.rows.shift(); wf.rowMin.shift(); wf.rowMax.shift();
+  const row = new Float32Array(wf.nEl);
+  let mn = Infinity, mx = -Infinity;
+  const n = Math.min(wf.nEl, vals.length);
+  for (let c = 0; c < n; c++) {
+    row[c] = vals[c];
+    if (vals[c] < mn) mn = vals[c];
+    if (vals[c] > mx) mx = vals[c];
+  }
+  wf.rows.push(row); wf.rowMin.push(mn); wf.rowMax.push(mx);
+  wf.dirty = true;
+}
+
+function setWfRange(id) {
+  const wf = waterfalls.get(id);
+  if (!wf) return;
+  wf.autoRange = document.getElementById(`wf-auto-${id}`).checked;
+  if (!wf.autoRange) {
+    wf.colorMin = parseFloat(document.getElementById(`wf-min-${id}`).value) || 0;
+    wf.colorMax = parseFloat(document.getElementById(`wf-max-${id}`).value) || 1;
+  }
+  _wfRedraw(wf);
+}
+
+function deleteWaterfall(id) {
+  const wf = waterfalls.get(id);
+  if (!wf) return;
+  if (wfRO) { const w = document.getElementById(`wf-wrap-${id}`); if (w) wfRO.unobserve(w); }
+  waterfalls.delete(id);
+  wf.card.remove();
+  if (plots.length === 0 && waterfalls.size === 0)
+    document.getElementById('no-plots-hint').style.display = 'block';
+}
+
 // ════════════════════════════════════════════════════════════════════
 // Render loop
 // ════════════════════════════════════════════════════════════════════
@@ -1168,6 +1855,9 @@ function renderLoop() {
       p.dirty = false;
     }
   }
+  for (const [, wf] of waterfalls) {
+    if (wf.dirty) { _wfRedraw(wf); wf.dirty = false; }
+  }
   if (logDirty) { flushLogs(); logDirty = false; }
   requestAnimationFrame(renderLoop);
 }
diff --git a/Tools/go_web_client/static/index.html b/Tools/go_web_client/static/index.html
index 3493bcf..309b20b 100644
--- a/Tools/go_web_client/static/index.html
+++ b/Tools/go_web_client/static/index.html
@@ -81,6 +81,7 @@ details>summary:hover{background:#313244}
 details>summary::before{content:'▶';font-size:9px;color:#585b70;width:10px;flex-shrink:0}
 details[open]>summary::before{content:'▼'}
 details>.children{padding-left:14px}
+.tree-loading{padding:2px 4px;color:#585b70;font-size:10px;font-style:italic}
 .tree-btn{background:transparent;border:1px solid #45475a;color:#a6adc8;padding:0 4px;border-radius:3px;cursor:pointer;font-size:10px;line-height:14px}
 .tree-btn:hover{background:#45475a;color:#cdd6f4}
 .tree-btn.t{border-color:#89b4fa;color:#89b4fa}
@@ -156,6 +157,21 @@ details>.children{padding-left:14px}
 ::-webkit-scrollbar-thumb{background:#45475a;border-radius:3px}
 ::-webkit-scrollbar-thumb:hover{background:#585b70}
 
+/* ── grouped array signal in trace list ── */
+.sig-group{display:flex;align-items:center;gap:4px;padding:3px 6px;border-bottom:1px solid #1e1e2e;user-select:none;cursor:grab}
+.sig-group:hover{background:#313244}
+.sig-group-exp{color:#585b70;font-size:10px;width:14px;text-align:center;flex-shrink:0;cursor:pointer}
+.sig-group-exp:hover{color:#89b4fa}
+.sig-item-sub{padding-left:24px;background:#11111b;border-left:2px solid #313244;margin-left:2px}
+.sig-item-sub:hover{background:#1e1e2e}
+
+/* ── array selection toggle ── */
+.arr-seg{display:flex;gap:0;margin-bottom:12px;border-radius:4px;overflow:hidden;border:1px solid #45475a}
+.arr-seg button{flex:1;border:none;border-radius:0;border-right:1px solid #45475a;color:#a6adc8;background:#313244;padding:4px 0;font-size:11px}
+.arr-seg button:last-child{border-right:none}
+.arr-seg button.active{background:#89b4fa;color:#1e1e2e}
+.arr-seg button:hover:not(.active){background:#45475a;color:#cdd6f4}
+
 /* ── misc ── */
 .empty-hint{padding:16px;color:#45475a;text-align:center}
 .break-item{padding:3px 6px;border-bottom:1px solid #181825;display:flex;align-items:center;gap:4px;font-size:11px}
@@ -276,7 +292,7 @@ select{background:#313244;border:1px solid #45475a;color:#cdd6f4;padding:2px 4px
         <div id="log-toolbar">
           <button class="panel-toggle" title="Collapse logs" onclick="togglePanel('log-panel','▼','▲',this)" id="log-toggle-btn">▼</button>
           <span style="font-weight:600;color:#89b4fa">Logs</span>
-          <label><input type="checkbox" id="lf-service" checked onchange="renderLogs()">
+          <label><input type="checkbox" id="lf-service" onchange="renderLogs()">
             Service</label>
           <label><input type="checkbox" id="lf-debug" checked onchange="renderLogs()">
             Debug</label>
@@ -369,6 +385,87 @@ select{background:#313244;border:1px solid #45475a;color:#cdd6f4;padding:2px 4px
         </div>
       </div>
     </div>
+    <!-- Array signal dialog (Trace / Force / Break with index/range selection) -->
+    <div class="dialog-overlay" id="dlg-array" style="display:none" onclick="if(event.target===this)closeDlg('dlg-array')">
+      <div class="dialog" style="min-width:360px">
+        <h3 id="arr-dlg-title">Array Signal</h3>
+        <p style="font-size:11px;color:#a6adc8;margin-bottom:14px">
+          <b id="arr-dlg-sig" style="color:#cdd6f4"></b>
+          &nbsp;·&nbsp;<span id="arr-dlg-n" style="color:#89b4fa"></span> elements
+        </p>
+        <!-- Segmented selection toggle -->
+        <label style="margin-bottom:6px">Apply to</label>
+        <div class="arr-seg">
+          <button id="arr-sel-all" class="active" onclick="setArrSel('all')">All</button>
+          <button id="arr-sel-idx"              onclick="setArrSel('idx')">Index</button>
+          <button id="arr-sel-rng"              onclick="setArrSel('rng')">Range</button>
+        </div>
+        <!-- Index mode: single number input -->
+        <div id="arr-idx-sect" style="display:none">
+          <label>Element index &nbsp;<span style="color:#585b70;font-weight:normal">(0 – <span id="arr-idx-max"></span>)</span></label>
+          <input id="arr-idx" type="number" min="0" value="0">
+        </div>
+        <!-- Range mode: start / end -->
+        <div id="arr-rng-sect" style="display:none">
+          <div class="form-row">
+            <div>
+              <label>From index</label>
+              <input id="arr-r0" type="number" min="0" value="0">
+            </div>
+            <div>
+              <label>To index <span style="color:#585b70;font-weight:normal">inclusive</span></label>
+              <input id="arr-r1" type="number" min="0" value="0">
+            </div>
+          </div>
+        </div>
+        <!-- Force value (shown only for Force action) -->
+        <div id="arr-force-sect" style="display:none">
+          <label>Force value</label>
+          <input id="arr-force-val" placeholder="e.g. 0">
+        </div>
+        <!-- Break condition (shown only for Break action) -->
+        <div id="arr-break-sect" style="display:none">
+          <div class="form-row">
+            <div>
+              <label>Condition</label>
+              <select id="arr-break-op">
+                <option>></option><option>>=</option>
+                <option>&lt;</option><option>&lt;=</option>
+                <option>==</option><option>!=</option>
+              </select>
+            </div>
+            <div>
+              <label>Threshold</label>
+              <input id="arr-break-thr" placeholder="0">
+            </div>
+          </div>
+        </div>
+        <div class="btns">
+          <button onclick="closeDlg('dlg-array')">Cancel</button>
+          <button id="arr-ok-btn" class="active" onclick="doArrayOp()">Apply</button>
+        </div>
+      </div>
+    </div>
+    <!-- Array → plot mode dialog (Sequential / Waterfall) -->
+    <div class="dialog-overlay" id="dlg-arr-plot" style="display:none" onclick="if(event.target===this)closeDlg('dlg-arr-plot')">
+      <div class="dialog" style="min-width:360px">
+        <h3>Plot Array Signal</h3>
+        <p style="font-size:11px;color:#a6adc8;margin-bottom:14px">
+          <b id="arrp-name" style="color:#cdd6f4"></b>
+           &nbsp;·&nbsp;<span id="arrp-n" style="color:#89b4fa"></span>
+          elements
+        </p>
+        <div class="arr-seg" style="margin-bottom:8px">
+          <button id="arrp-sel-sequential" class="active" onclick="setArrpMode('sequential')">Sequential</button>
+          <button id="arrp-sel-waterfall"               onclick="setArrpMode('waterfall')">Waterfall</button>
+        </div>
+        <p id="arrp-desc" style="font-size:10px;color:#a6adc8;margin-bottom:16px;min-height:28px"></p>
+        <div class="btns">
+          <button onclick="closeDlg('dlg-arr-plot')">Cancel</button>
+          <button class="active" onclick="doArrayPlotMode()">Add</button>
+        </div>
+      </div>
+    </div>
     <!-- Info dialog -->
     <div class="dialog-overlay" id="dlg-info" style="display:none" onclick="if(event.target===this)closeDlg('dlg-info')">
       <div class="dialog" style="max-width:600px;width:90vw">