feat(lsp): widget property typos surface as real-time diagnostics

Wires widget property validation into the LSP's on-keystroke diagnostic
publisher so unknown property keys on pluggable widgets appear as
squiggles while the author types — not only when they save and trigger
`mxcli check`.

Implementation:
- `ValidateWidgetPropertiesForStatement(stmt, registry)` exposed as a
  per-statement entry so the LSP can attach per-statement line numbers
  (instead of dumping all violations at line 0).
- `LoadWidgetRegistry(projectPath)` extracted so callers can manage
  registry lifetime — the LSP loads once via `ensureWidgetRegistry()`
  rather than rebuilding it per keystroke.
- `runSemanticValidation` promoted to a method on `*mdlServer` so it
  can reuse `s.widgetRegistry`. Nil-safe — widget checks are skipped
  when the registry hasn't loaded (e.g. no project context).
- Consolidated the two duplicate `widgetCompletionsOnce.Do` blocks in
  lsp_completion.go into a single `ensureWidgetRegistry()` helper.
  Fixes a latent bug where `s.widgetRegistry` was nil if the first
  Once caller was the completion path (only the second block set it).

Tests:
- `TestWidgetPropertyDiagnostics` covers create-page, alter-page-insert,
  and the happy path (no false positives on valid properties).

Verified end-to-end against test5-app: `combobox cb1
(optionsSourcType: 'enumeration')` produces
`MDL-WIDGET01: widget cb1 (combobox) has no property optionsSourcType —
did you mean optionsSourceType?` through the same code path the LSP
now fires inline.

Issue: #540

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Author: ako

cmd/mxcli/lsp_completion.go

@@ -105,6 +105,16 @@ func (s *mdlServer) mdlCompletionItems(linePrefixUpper string) []protocol.Comple
 // NOTE: Cached via sync.Once — new .def.json files added while the LSP server is
 // running will not appear until the server is restarted.
 func (s *mdlServer) widgetRegistryCompletions() []protocol.CompletionItem {
+	s.ensureWidgetRegistry()
+	return s.widgetCompletionItems
+}
+
+// ensureWidgetRegistry loads the widget registry once per server lifetime,
+// caching the result on s.widgetRegistry and s.widgetCompletionItems.
+// Safe to call from any goroutine.
+// NOTE: new .def.json files added while the LSP server is running will not
+// appear until the server is restarted.
+func (s *mdlServer) ensureWidgetRegistry() {
 	s.widgetCompletionsOnce.Do(func() {
 		registry, err := executor.NewWidgetRegistry()
 		if err != nil {
@@ -113,6 +123,7 @@ func (s *mdlServer) widgetRegistryCompletions() []protocol.CompletionItem {
 		if err := registry.LoadUserDefinitions(s.mprPath); err != nil {
 			log.Printf("warning: loading user widget definitions for LSP: %v", err)
 		}
+		s.widgetRegistry = registry
 		for _, def := range registry.All() {
 			s.widgetCompletionItems = append(s.widgetCompletionItems, protocol.CompletionItem{
 				Label:  def.MDLName,
@@ -121,7 +132,6 @@ func (s *mdlServer) widgetRegistryCompletions() []protocol.CompletionItem {
 			})
 		}
 	})
-	return s.widgetCompletionItems
 }
 
 // mdlCreateContextKeywords are object types suggested after CREATE.
@@ -781,23 +791,7 @@ func scanEnclosingWidget(text string, cursorLine, cursorCol int, s *mdlServer) *
 	}
 
 	// Lazy-load the registry (re-use the widget-completions cache).
-	s.widgetCompletionsOnce.Do(func() {
-		registry, err := executor.NewWidgetRegistry()
-		if err != nil {
-			return
-		}
-		if err := registry.LoadUserDefinitions(s.mprPath); err != nil {
-			log.Printf("warning: loading user widget definitions for LSP: %v", err)
-		}
-		s.widgetRegistry = registry
-		for _, def := range registry.All() {
-			s.widgetCompletionItems = append(s.widgetCompletionItems, protocol.CompletionItem{
-				Label:  def.MDLName,
-				Kind:   protocol.CompletionItemKindClass,
-				Detail: "Pluggable widget: " + def.WidgetID,
-			})
-		}
-	})
+	s.ensureWidgetRegistry()
 	if s.widgetRegistry == nil {
 		return nil
 	}

cmd/mxcli/lsp_completion_test.go

@@ -262,6 +262,84 @@ func mapKeys(m map[string]bool) []string {
 	return out
 }
 
+// TestWidgetPropertyDiagnostics verifies that unknown property keys on a
+// pluggable widget surface as LSP diagnostics through runSemanticValidation
+// (the path that fires on every keystroke).
+func TestWidgetPropertyDiagnostics(t *testing.T) {
+	s := &mdlServer{}
+
+	tests := []struct {
+		name        string
+		text        string
+		wantRule    string   // RuleID expected in at least one diagnostic
+		wantInMsg   []string // substrings expected somewhere in the diagnostics
+		wantNoMatch bool     // when no widget diagnostic should fire
+	}{
+		{
+			name: "typo on combobox property surfaces MDL-WIDGET01",
+			text: "create page Mod.X (Title: 'T') {\n" +
+				"  combobox cb1 (\n" +
+				"    optionsSourcType: 'enumeration'\n" +
+				"  )\n" +
+				"}",
+			wantRule:  "MDL-WIDGET01",
+			wantInMsg: []string{"optionsSourcType", "combobox"},
+		},
+		{
+			name: "valid property — no widget diagnostic",
+			text: "create page Mod.X (Title: 'T') {\n" +
+				"  combobox cb1 (\n" +
+				"    optionsSourceType: 'enumeration'\n" +
+				"  )\n" +
+				"}",
+			wantNoMatch: true,
+		},
+		{
+			name: "alter page insert — typo flagged",
+			text: "ALTER PAGE Mod.X {\n" +
+				"  INSERT AFTER target1 {\n" +
+				"    combobox cb1 (badprop: 'x')\n" +
+				"  }\n" +
+				"};",
+			wantRule:  "MDL-WIDGET01",
+			wantInMsg: []string{"badprop"},
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			diags := s.runSemanticValidation(tt.text)
+			var widgetDiags []protocol.Diagnostic
+			for _, d := range diags {
+				if code, ok := d.Code.(string); ok && code == "MDL-WIDGET01" {
+					widgetDiags = append(widgetDiags, d)
+				}
+			}
+			if tt.wantNoMatch {
+				if len(widgetDiags) != 0 {
+					t.Errorf("expected no widget diagnostics, got: %v", widgetDiags)
+				}
+				return
+			}
+			if len(widgetDiags) == 0 {
+				t.Fatalf("expected at least one MDL-WIDGET01 diagnostic, got none (all diags: %v)", diags)
+			}
+			for _, sub := range tt.wantInMsg {
+				found := false
+				for _, d := range widgetDiags {
+					if strings.Contains(d.Message, sub) {
+						found = true
+						break
+					}
+				}
+				if !found {
+					t.Errorf("expected substring %q in a widget diagnostic; messages: %v", sub, widgetDiags)
+				}
+			}
+		})
+	}
+}
+
 // TestWidgetPropertyHover verifies LSP hover surfaces widget property
 // descriptions / type / default from the .def.json content.
 func TestWidgetPropertyHover(t *testing.T) {

cmd/mxcli/lsp_diagnostics.go

@@ -63,7 +63,7 @@ func (s *mdlServer) publishDiagnostics(ctx context.Context, docURI uri.URI, text
 	diags := parseMDLDiagnostics(text)
 	// If no parse errors, run semantic validation inline
 	if len(diags) == 0 {
-		diags = append(diags, runSemanticValidation(text)...)
+		diags = append(diags, s.runSemanticValidation(text)...)
 	}
 	if diags == nil {
 		diags = []protocol.Diagnostic{} // send empty array to clear diagnostics
@@ -250,14 +250,19 @@ func mapStatementLines(text string) []uint32 {
 
 // runSemanticValidation runs the same validators as cmd_check.go directly on parsed text,
 // returning LSP diagnostics with structured rule IDs.
-func runSemanticValidation(text string) []protocol.Diagnostic {
+func (s *mdlServer) runSemanticValidation(text string) []protocol.Diagnostic {
 	prog, errs := visitor.Build(text)
 	if len(errs) > 0 || prog == nil {
 		return nil
 	}
 
 	stmtLines := mapStatementLines(text)
 
+	// Widget validation reuses the LSP's cached widget registry so the
+	// filesystem isn't walked on every keystroke. Nil-safe: when the registry
+	// hasn't loaded (no project context, etc.) widget validation is skipped.
+	s.ensureWidgetRegistry()
+
 	var diags []protocol.Diagnostic
 	for i, stmt := range prog.Statements {
 		var violations []linter.Violation
@@ -276,6 +281,9 @@ func runSemanticValidation(text string) []protocol.Diagnostic {
 				violations = append(violations, executor.ValidateOQLTypes(viewStmt.Query.RawQuery, viewStmt.Attributes)...)
 			}
 		}
+		if s.widgetRegistry != nil {
+			violations = append(violations, executor.ValidateWidgetPropertiesForStatement(stmt, s.widgetRegistry)...)
+		}
 
 		lineNum := uint32(0)
 		if i < len(stmtLines) {

mdl/executor/validate_widgets.go

@@ -40,33 +40,58 @@ var universalWidgetProperties = map[string]bool{
 // project-installed widgets get validated too; otherwise only built-in
 // definitions are consulted.
 func ValidateWidgetProperties(prog *ast.Program, projectPath string) []linter.Violation {
+	registry := LoadWidgetRegistry(projectPath)
+	if registry == nil {
+		return nil
+	}
+	var violations []linter.Violation
+	for _, stmt := range prog.Statements {
+		violations = append(violations, ValidateWidgetPropertiesForStatement(stmt, registry)...)
+	}
+	return violations
+}
+
+// LoadWidgetRegistry returns a widget registry loaded with both the built-in
+// definitions and (when projectPath is non-empty) project-level .def.json
+// files. Returns nil if registry initialization fails. The LSP uses this to
+// load the registry once per session rather than per validation pass.
+func LoadWidgetRegistry(projectPath string) *WidgetRegistry {
 	registry, err := NewWidgetRegistry()
 	if err != nil || registry == nil {
 		return nil
 	}
 	if projectPath != "" {
 		_ = registry.LoadUserDefinitions(projectPath)
 	}
+	return registry
+}
 
-	var violations []linter.Violation
-	for _, stmt := range prog.Statements {
-		switch s := stmt.(type) {
-		case *ast.CreatePageStmtV3:
-			violations = append(violations, validateWidgetTree(s.Widgets, registry, "page "+s.Name.String())...)
-		case *ast.CreateSnippetStmtV3:
-			violations = append(violations, validateWidgetTree(s.Widgets, registry, "snippet "+s.Name.String())...)
-		case *ast.AlterPageStmt:
-			for _, op := range s.Operations {
-				switch o := op.(type) {
-				case *ast.InsertWidgetOp:
-					violations = append(violations, validateWidgetTree(o.Widgets, registry, "alter "+s.PageName.String())...)
-				case *ast.ReplaceWidgetOp:
-					violations = append(violations, validateWidgetTree(o.NewWidgets, registry, "alter "+s.PageName.String())...)
-				}
+// ValidateWidgetPropertiesForStatement runs widget property validation on a
+// single statement using a pre-loaded registry. Returns no violations for
+// statements that don't carry pluggable widgets (everything except
+// CreatePageStmtV3, CreateSnippetStmtV3, AlterPageStmt).
+func ValidateWidgetPropertiesForStatement(stmt ast.Statement, registry *WidgetRegistry) []linter.Violation {
+	if registry == nil {
+		return nil
+	}
+	switch s := stmt.(type) {
+	case *ast.CreatePageStmtV3:
+		return validateWidgetTree(s.Widgets, registry, "page "+s.Name.String())
+	case *ast.CreateSnippetStmtV3:
+		return validateWidgetTree(s.Widgets, registry, "snippet "+s.Name.String())
+	case *ast.AlterPageStmt:
+		var out []linter.Violation
+		for _, op := range s.Operations {
+			switch o := op.(type) {
+			case *ast.InsertWidgetOp:
+				out = append(out, validateWidgetTree(o.Widgets, registry, "alter "+s.PageName.String())...)
+			case *ast.ReplaceWidgetOp:
+				out = append(out, validateWidgetTree(o.NewWidgets, registry, "alter "+s.PageName.String())...)
 			}
 		}
+		return out
 	}
-	return violations
+	return nil
 }
 
 // validateWidgetTree recursively walks the AST widget tree and validates