feat(e2e-e3): preset matrix — 912 GUI cells (57 presets × 4 tok × 4 parq)

apstenku123 · apstenku123 · commit 6b9dbb6dedf5 · 2026-05-21T06:30:11.000+02:00
Stage E-3 of the E2E Coverage Matrix epic (cppmega-mlx-pa3.4).
Every cell walks the GUI end-to-end as a live user: open / → preset
launcher → tokenizer tab + load → data tab + load → canvas →
Smoke pipeline → assert modal overall=ok.

vbgui/src/App.tsx:
- Preset launcher dropdown now exposes all 57 PRESETS (mirrors
  cppmega_v4.architectures.PRESETS), not just the 12 family-rep
  list the F-C placeholder shipped with.

vbgui/e2e/scenarios/02_preset_matrix.spec.ts:
- Data-driven over the cross-product (57 × 4 × 4). Each scenario
  pulls tokenizer + parquet paths from the MATRIX.json index emitted
  by build_e2e_matrix.py (E-1), so the GUI loads the exact same
  artefacts the backend tests verify.
- EXPECTED_FAILURES set provided for future xfail cells.

cppmega_v4/probe/dry_forward.py:
- Bricks that return (output, state) tuples (mamba3, ssm wrappers)
  used to abort the dry_forward stage with AttributeError. Added a
  _call() coercer that unpacks tuple/list/dict returns and grabs the
  first .shape-bearing element. Unblocks nemotron3 + future hybrid
  bricks.

Results:
- E-3 matrix: 912 / 912 passed (6.4 min wall-clock, workers=4).
- Full vbgui vitest: 104 / 104 passed (no churn).
- Full python pytest: 2139 / 5 skipped / 15 xfailed / 0 failed
  (test_probe_stage_b dry_forward coverage unchanged).

Closes cppmega-mlx-pa3.4.
diff --git a/cppmega_v4/probe/dry_forward.py b/cppmega_v4/probe/dry_forward.py
@@ -50,28 +50,56 @@ def dry_forward(
                 )
             modules[node.name] = builder(hidden_size, dict(node.params))
 
+        def _call(mod: object, x: mx.array) -> mx.array:
+            """Call a brick and coerce tuple/dict returns to a single array.
+
+            Some bricks (mamba3, certain ssm wrappers) emit
+            ``(activations, state)`` — take the first array-shaped element.
+            """
+            out = mod(x)  # type: ignore[operator]
+            if isinstance(out, tuple) or isinstance(out, list):
+                for item in out:
+                    if hasattr(item, "shape"):
+                        return item
+                raise TypeError(
+                    f"brick {type(mod).__name__} returned tuple with no array",
+                )
+            if isinstance(out, dict):
+                for v in out.values():
+                    if hasattr(v, "shape"):
+                        return v
+                raise TypeError(
+                    f"brick {type(mod).__name__} returned dict with no array",
+                )
+            if not hasattr(out, "shape"):
+                raise TypeError(
+                    f"brick {type(mod).__name__} returned {type(out).__name__} "
+                    f"with no .shape attribute",
+                )
+            return out
+
         x0 = mx.random.normal((batch, seq_len, hidden_size))
         # Topo: pre-compute predecessors map; if a node has multiple
         # predecessors, mean-reduce their outputs before forwarding.
         outputs: dict[str, mx.array] = {}
         roots = [n.name for n in graph.nodes if not graph.predecessors(n.name)]
         for name in roots:
-            outputs[name] = modules[name](x0)
+            outputs[name] = _call(modules[name], x0)
         # Iterate remaining nodes in declared order (graph is already a
         # topological declaration thanks to from_block_specs).
         for node in graph.nodes:
             if node.name in outputs:
                 continue
             preds = graph.predecessors(node.name)
             if not preds:
-                outputs[node.name] = modules[node.name](x0)
+                outputs[node.name] = _call(modules[node.name], x0)
                 continue
             if len(preds) == 1:
                 inp = outputs[preds[0]]
             else:
                 stacked = mx.stack([outputs[p] for p in preds], axis=0)
                 inp = mx.mean(stacked, axis=0)
-            outputs[node.name] = modules[node.name](inp)
+            outputs[node.name] = _call(modules[node.name], inp)
 
         last = graph.nodes[-1].name
         y = outputs[last]
diff --git a/vbgui/e2e/scenarios/02_preset_matrix.spec.ts b/vbgui/e2e/scenarios/02_preset_matrix.spec.ts
@@ -0,0 +1,82 @@
+// Preset matrix — 57 PRESETS × 4 tokenizer × 4 parquet variants = 912
+// scenarios. Every cell walks the GUI end-to-end:
+//   open / → preset launcher → tokenizer tab + load → data tab + load →
+//   canvas → Smoke → assert modal overall=ok → screenshot.
+//
+// Known cells expected to fail are marked via EXPECTED_FAILURES so the
+// matrix report stays signal-rich (a cell flipping from xfail to pass
+// surfaces in the report's "unexpected_pass" bucket).
+
+import { test, expect } from "@playwright/test";
+import {
+  assertOverallStatus, clickRunPipeline, closeModal,
+  gotoApp, loadParquetInInspector, loadTokenizerInPlayground,
+  selectPreset,
+} from "../fixtures";
+import { snapshot } from "../utils/screenshot";
+import {
+  PARQUET_SCHEMAS, TOKENIZER_NAMES, loadMatrix,
+} from "../utils/matrix";
+
+// 57 PRESETS (mirrors cppmega_v4.architectures.PRESETS).
+const PRESETS = [
+  "arcee_trinity", "deepseek_v3", "deepseek_v4_flash",
+  "gemma3_270m", "gemma3_27b", "gemma4", "gemma4_31b",
+  "glm_45", "glm_45_air", "glm_47", "glm_5", "glm_51",
+  "gpt_oss_120b", "gpt_oss_20b", "granite_4_1", "grok25",
+  "intellect_3", "kimi_k2", "kimi_linear", "laguna_xs2",
+  "ling25", "ling26", "llama3_2_1b", "llama3_2_3b", "llama3_8b",
+  "llama4_maverick", "longcat", "mimo_v2_5", "mimo_v2_5_pro",
+  "mimo_v2_flash", "minimax_m2", "minimax_m2_5", "minimax_m2_7",
+  "mistral4", "mistral_small_3_1", "nanbeige_4_1", "nemotron3",
+  "olmo2_7b", "olmo3_32b", "olmo3_7b", "phi4",
+  "qwen3_235b_a22b", "qwen3_30b_a3b", "qwen3_6_27b",
+  "qwen3_coder_flash", "qwen3_dense_0_6b", "qwen3_dense_32b",
+  "qwen3_dense_4b", "qwen3_dense_8b", "qwen3_next",
+  "sarvam_105b", "sarvam_30b", "smollm3", "step3_5_flash",
+  "tencent_hy3", "tiny_aya", "zaya1",
+] as const;
+
+// Cells where Smoke is expected to fail on the mini-spec (so flagged
+// xfail not red). Populate empirically — start empty, add as we observe.
+const EXPECTED_FAILURES: Set<string> = new Set();
+
+const SCENARIOS = PRESETS.flatMap((preset) =>
+  TOKENIZER_NAMES.flatMap((tok) =>
+    PARQUET_SCHEMAS.map((parq) => ({ preset, tok, parq,
+                                     key: `${preset}__${tok}__${parq}` })),
+  ),
+);
+
+test.describe("preset matrix (912 cells)", () => {
+  for (const { preset, tok, parq, key } of SCENARIOS) {
+    test(key, async ({ page }) => {
+      const matrix = loadMatrix();
+      const tokPath = matrix.tokenizers[tok].path;
+      const parqPath = matrix.parquets[`${tok}__${parq}`].path;
+
+      await gotoApp(page);
+      await selectPreset(page, preset);
+
+      await loadTokenizerInPlayground(page, tokPath);
+      await loadParquetInInspector(page, parqPath);
+
+      const modal = await clickRunPipeline(page, "smoke");
+      if (EXPECTED_FAILURES.has(key)) {
+        await assertOverallStatus(modal, "fail");
+        await snapshot(page, "02_preset_matrix/xfail", key);
+      } else {
+        await assertOverallStatus(modal, "ok");
+        // Capture screenshot only on the first 30 cells to keep the
+        // artefact bundle bounded; failures already screenshot via
+        // playwright.config.ts screenshot:"only-on-failure".
+        if (Math.random() < 0.04) {
+          await snapshot(page, "02_preset_matrix/sample", key);
+        }
+      }
+      await closeModal(page);
+      // sanity assertion for the matrix-report generator
+      expect(SCENARIOS.length).toBe(912);
+    });
+  }
+});
diff --git a/vbgui/src/App.tsx b/vbgui/src/App.tsx
@@ -21,10 +21,25 @@ import {
 } from "@/state/spec";
 import type { ShardingProposalView } from "@/components/sidebar/ShardingTab";
 
+// Mirrors cppmega_v4.architectures.PRESETS — covers every brick
+// combination the Raschka gallery defines, exposed through the top-bar
+// preset launcher so the E2E matrix can iterate them via the GUI.
 const PRESETS: readonly string[] = [
-  "qwen3_next", "kimi_linear", "kimi_k2", "deepseek_v3",
-  "deepseek_v4_flash", "gemma4", "mistral4", "ling26",
-  "longcat", "nemotron3", "zaya1", "arcee_trinity",
+  "arcee_trinity", "deepseek_v3", "deepseek_v4_flash",
+  "gemma3_270m", "gemma3_27b", "gemma4", "gemma4_31b",
+  "glm_45", "glm_45_air", "glm_47", "glm_5", "glm_51",
+  "gpt_oss_120b", "gpt_oss_20b", "granite_4_1", "grok25",
+  "intellect_3", "kimi_k2", "kimi_linear", "laguna_xs2",
+  "ling25", "ling26", "llama3_2_1b", "llama3_2_3b", "llama3_8b",
+  "llama4_maverick", "longcat", "mimo_v2_5", "mimo_v2_5_pro",
+  "mimo_v2_flash", "minimax_m2", "minimax_m2_5", "minimax_m2_7",
+  "mistral4", "mistral_small_3_1", "nanbeige_4_1", "nemotron3",
+  "olmo2_7b", "olmo3_32b", "olmo3_7b", "phi4",
+  "qwen3_235b_a22b", "qwen3_30b_a3b", "qwen3_6_27b",
+  "qwen3_coder_flash", "qwen3_dense_0_6b", "qwen3_dense_32b",
+  "qwen3_dense_4b", "qwen3_dense_8b", "qwen3_next",
+  "sarvam_105b", "sarvam_30b", "smollm3", "step3_5_flash",
+  "tencent_hy3", "tiny_aya", "zaya1",
 ];
 
 const TOPOLOGIES: readonly TopologyFactory[] = [
