feat: OperationRegistry extensibility and ContainerSnippet constant

- Add NewWidgetRegistryWithOps(extraOps) for extending known operations
- Move knownOperations from package-level var to WidgetRegistry field
  to eliminate global mutable state race
- Convert validateDefinitionOperations and validateMappings to
  WidgetRegistry methods
- Use backend.ContainerSnippet constant in SetLayout check

Author: retran

mdl/backend/mpr/page_mutator.go

@@ -254,7 +254,7 @@ func (m *mprPageMutator) DropVariable(name string) error {
 }
 
 func (m *mprPageMutator) SetLayout(newLayout string, paramMappings map[string]string) error {
-	if m.containerType == "snippet" {
+	if m.containerType == backend.ContainerSnippet {
 		return fmt.Errorf("SET Layout is not supported for snippets")
 	}
 

mdl/executor/widget_registry.go

@@ -16,12 +16,13 @@ import (
 
 // WidgetRegistry holds loaded widget definitions keyed by uppercase MDL name.
 type WidgetRegistry struct {
-	byMDLName  map[string]*WidgetDefinition // keyed by uppercase MDLName
-	byWidgetID map[string]*WidgetDefinition // keyed by widgetId
+	byMDLName      map[string]*WidgetDefinition // keyed by uppercase MDLName
+	byWidgetID     map[string]*WidgetDefinition // keyed by widgetId
+	knownOperations map[string]bool              // operations accepted during validation
 }
 
-// knownOperations is the set of operation names supported by the widget engine.
-var knownOperations = map[string]bool{
+// defaultKnownOperations is the set of operation names supported by the widget engine.
+var defaultKnownOperations = map[string]bool{
 	"attribute":        true,
 	"association":      true,
 	"primitive":        true,
@@ -34,11 +35,37 @@ var knownOperations = map[string]bool{
 	"attributeObjects": true,
 }
 
+// knownOperations is the active set used for validation, initialized from
+// defaultKnownOperations and now stored per-registry to avoid global mutable state.
+
+func copyOps(src map[string]bool) map[string]bool {
+	dst := make(map[string]bool, len(src))
+	for k, v := range src {
+		dst[k] = v
+	}
+	return dst
+}
+
 // NewWidgetRegistry creates a registry pre-loaded with embedded definitions.
+// Uses the default set of known operations for validation.
 func NewWidgetRegistry() (*WidgetRegistry, error) {
+	return NewWidgetRegistryWithOps(nil)
+}
+
+// NewWidgetRegistryWithOps creates a registry pre-loaded with embedded definitions,
+// extending the default known operations with extraOps for validation.
+// This allows user-defined widgets to declare custom operations that would otherwise
+// fail validation. Pass nil for the default set.
+func NewWidgetRegistryWithOps(extraOps map[string]bool) (*WidgetRegistry, error) {
+	ops := copyOps(defaultKnownOperations)
+	for op := range extraOps {
+		ops[op] = true
+	}
+
 	reg := &WidgetRegistry{
-		byMDLName:  make(map[string]*WidgetDefinition),
-		byWidgetID: make(map[string]*WidgetDefinition),
+		byMDLName:       make(map[string]*WidgetDefinition),
+		byWidgetID:      make(map[string]*WidgetDefinition),
+		knownOperations: ops,
 	}
 
 	entries, err := definitions.EmbeddedFS.ReadDir(".")
@@ -61,7 +88,7 @@ func NewWidgetRegistry() (*WidgetRegistry, error) {
 			return nil, mdlerrors.NewBackend(fmt.Sprintf("parse definition %s", entry.Name()), err)
 		}
 
-		if err := validateDefinitionOperations(&def, entry.Name()); err != nil {
+		if err := reg.validateDefinitionOperations(&def, entry.Name()); err != nil {
 			return nil, err
 		}
 
@@ -156,7 +183,7 @@ func (r *WidgetRegistry) loadDefinitionsFromDir(dir string) error {
 			return mdlerrors.NewValidationf("invalid definition %s: widgetId and mdlName are required", entry.Name())
 		}
 
-		if err := validateDefinitionOperations(&def, entry.Name()); err != nil {
+		if err := r.validateDefinitionOperations(&def, entry.Name()); err != nil {
 			return err
 		}
 
@@ -180,22 +207,22 @@ func (r *WidgetRegistry) loadDefinitionsFromDir(dir string) error {
 // validateDefinitionOperations checks that all operation names in a definition
 // are recognized by the known operations set, and validates source/operation
 // compatibility and mapping order dependencies.
-func validateDefinitionOperations(def *WidgetDefinition, source string) error {
-	if err := validateMappings(def.PropertyMappings, source, ""); err != nil {
+func (r *WidgetRegistry) validateDefinitionOperations(def *WidgetDefinition, source string) error {
+	if err := r.validateMappings(def.PropertyMappings, source, ""); err != nil {
 		return err
 	}
 	for _, s := range def.ChildSlots {
-		if !knownOperations[s.Operation] {
+		if !r.knownOperations[s.Operation] {
 			return mdlerrors.NewValidationf("%s: unknown operation %q in childSlots for key %q", source, s.Operation, s.PropertyKey)
 		}
 	}
 	for _, mode := range def.Modes {
 		ctx := fmt.Sprintf("mode %q ", mode.Name)
-		if err := validateMappings(mode.PropertyMappings, source, ctx); err != nil {
+		if err := r.validateMappings(mode.PropertyMappings, source, ctx); err != nil {
 			return err
 		}
 		for _, s := range mode.ChildSlots {
-			if !knownOperations[s.Operation] {
+			if !r.knownOperations[s.Operation] {
 				return mdlerrors.NewValidationf("%s: unknown operation %q in %schildSlots for key %q", source, s.Operation, ctx, s.PropertyKey)
 			}
 		}
@@ -213,10 +240,10 @@ var incompatibleSourceOps = map[string]map[string]bool{
 
 // validateMappings validates a slice of property mappings for operation existence,
 // source/operation compatibility, and mapping order (Association requires prior DataSource).
-func validateMappings(mappings []PropertyMapping, source, modeCtx string) error {
+func (r *WidgetRegistry) validateMappings(mappings []PropertyMapping, source, modeCtx string) error {
 	hasDataSource := false
 	for _, m := range mappings {
-		if !knownOperations[m.Operation] {
+		if !r.knownOperations[m.Operation] {
 			return mdlerrors.NewValidationf("%s: unknown operation %q in %spropertyMappings for key %q", source, m.Operation, modeCtx, m.PropertyKey)
 		}
 		// Check source/operation compatibility

mdl/executor/widget_registry_test.go

@@ -189,7 +189,41 @@ func TestRegistryLoadUserDefinitions(t *testing.T) {
 	}
 }
 
+func TestNewWidgetRegistryWithOps_ExtendsKnownOperations(t *testing.T) {
+	// A definition with a custom operation should fail with default ops
+	customDef := &WidgetDefinition{
+		WidgetID: "com.example.Custom",
+		MDLName:  "CUSTOM",
+		PropertyMappings: []PropertyMapping{
+			{PropertyKey: "prop", Source: "Attribute", Operation: "customOp"},
+		},
+	}
+
+	// Default registry should reject custom operation
+	defaultReg, err := NewWidgetRegistry()
+	if err != nil {
+		t.Fatalf("NewWidgetRegistry() error: %v", err)
+	}
+	if err := defaultReg.validateDefinitionOperations(customDef, "custom.def.json"); err == nil {
+		t.Error("expected error for unknown operation 'customOp' with default ops, got nil")
+	}
+
+	// Extended registry should accept custom operation
+	extReg, err := NewWidgetRegistryWithOps(map[string]bool{"customOp": true})
+	if err != nil {
+		t.Fatalf("NewWidgetRegistryWithOps() error: %v", err)
+	}
+	if err := extReg.validateDefinitionOperations(customDef, "custom.def.json"); err != nil {
+		t.Errorf("unexpected error with extended ops: %v", err)
+	}
+}
+
 func TestValidateDefinitionOperations_MappingOrderDependency(t *testing.T) {
+	reg, err := NewWidgetRegistry()
+	if err != nil {
+		t.Fatalf("NewWidgetRegistry() error: %v", err)
+	}
+
 	// Association before DataSource should fail validation
 	badDef := &WidgetDefinition{
 		WidgetID: "com.example.Bad",
@@ -199,7 +233,7 @@ func TestValidateDefinitionOperations_MappingOrderDependency(t *testing.T) {
 			{PropertyKey: "dsProp", Source: "DataSource", Operation: "datasource"},
 		},
 	}
-	if err := validateDefinitionOperations(badDef, "bad.def.json"); err == nil {
+	if err := reg.validateDefinitionOperations(badDef, "bad.def.json"); err == nil {
 		t.Error("expected error for Association before DataSource, got nil")
 	}
 
@@ -212,7 +246,7 @@ func TestValidateDefinitionOperations_MappingOrderDependency(t *testing.T) {
 			{PropertyKey: "assocProp", Source: "Association", Operation: "association"},
 		},
 	}
-	if err := validateDefinitionOperations(goodDef, "good.def.json"); err != nil {
+	if err := reg.validateDefinitionOperations(goodDef, "good.def.json"); err != nil {
 		t.Errorf("unexpected error for DataSource before Association: %v", err)
 	}
 
@@ -230,12 +264,17 @@ func TestValidateDefinitionOperations_MappingOrderDependency(t *testing.T) {
 			},
 		},
 	}
-	if err := validateDefinitionOperations(modeDef, "mode.def.json"); err == nil {
+	if err := reg.validateDefinitionOperations(modeDef, "mode.def.json"); err == nil {
 		t.Error("expected error for Association before DataSource in mode, got nil")
 	}
 }
 
 func TestValidateDefinitionOperations_SourceOperationCompatibility(t *testing.T) {
+	reg, err := NewWidgetRegistry()
+	if err != nil {
+		t.Fatalf("NewWidgetRegistry() error: %v", err)
+	}
+
 	// Source "Attribute" with Operation "association" should fail
 	badDef := &WidgetDefinition{
 		WidgetID: "com.example.Bad",
@@ -244,7 +283,7 @@ func TestValidateDefinitionOperations_SourceOperationCompatibility(t *testing.T)
 			{PropertyKey: "prop", Source: "Attribute", Operation: "association"},
 		},
 	}
-	if err := validateDefinitionOperations(badDef, "bad.def.json"); err == nil {
+	if err := reg.validateDefinitionOperations(badDef, "bad.def.json"); err == nil {
 		t.Error("expected error for Source='Attribute' with Operation='association', got nil")
 	}
 
@@ -256,7 +295,7 @@ func TestValidateDefinitionOperations_SourceOperationCompatibility(t *testing.T)
 			{PropertyKey: "prop", Source: "Association", Operation: "attribute"},
 		},
 	}
-	if err := validateDefinitionOperations(badDef2, "bad2.def.json"); err == nil {
+	if err := reg.validateDefinitionOperations(badDef2, "bad2.def.json"); err == nil {
 		t.Error("expected error for Source='Association' with Operation='attribute', got nil")
 	}
 }