fix: build low models from immutable YAML merge views

datamodel/low/arazzo/helpers.go

@@ -32,9 +32,8 @@ type arazzoBase struct {
 // It returns the resolved root node (after alias/merge processing) for further extraction.
 func initBuild(b *arazzoBase, ctx context.Context, keyNode, root *yaml.Node, idx *index.SpecIndex) *yaml.Node {
 	*b.KeyNode = keyNode
-	root = utils.NodeAlias(root)
+	root = utils.ResolveMergeNodes(root)
 	*b.RootNode = root
-	utils.CheckForMergeNodes(root)
 	*b.Reference = new(low.Reference)
 	b.NodeMap.Nodes = low.ExtractNodes(ctx, root)
 	ext := low.ExtractExtensions(root)

datamodel/low/base/contact.go

@@ -11,6 +11,7 @@ import (
 	"github.com/pb33f/libopenapi/datamodel/low"
 	"github.com/pb33f/libopenapi/index"
 	"github.com/pb33f/libopenapi/orderedmap"
+	"github.com/pb33f/libopenapi/utils"
 )
 
 // Contact represents a low-level representation of the Contact definitions found at
@@ -34,6 +35,7 @@ type Contact struct {
 
 func (c *Contact) Build(ctx context.Context, keyNode, root *yaml.Node, idx *index.SpecIndex) error {
 	c.KeyNode = keyNode
+	root = utils.ResolveMergeNodes(root)
 	c.RootNode = root
 	c.reference = low.Reference{}
 	c.Reference = &c.reference

datamodel/low/base/discriminator.go

@@ -39,7 +39,7 @@ func ValidateDiscriminatorMappingValueNodes(discriminatorNode *yaml.Node) error
 	if discriminatorNode == nil || discriminatorNode.Kind != yaml.MappingNode {
 		return nil
 	}
-	utils.CheckForMergeNodes(discriminatorNode)
+	discriminatorNode = utils.ResolveMergeNodes(discriminatorNode)
 
 	for i := 0; i < len(discriminatorNode.Content); i += 2 {
 		keyNode := utils.NodeAlias(discriminatorNode.Content[i])
@@ -54,7 +54,7 @@ func ValidateDiscriminatorMappingValueNodes(discriminatorNode *yaml.Node) error
 		if mappingNode == nil || mappingNode.Kind != yaml.MappingNode {
 			return fmt.Errorf("discriminator.mapping must be an object")
 		}
-		utils.CheckForMergeNodes(mappingNode)
+		mappingNode = utils.ResolveMergeNodes(mappingNode)
 
 		for j := 0; j < len(mappingNode.Content); j += 2 {
 			keyNode := utils.NodeAlias(mappingNode.Content[j])

datamodel/low/base/example.go

@@ -93,9 +93,8 @@ func (ex *Example) Build(ctx context.Context, keyNode, root *yaml.Node, idx *ind
 	if ok, _, ref := utils.IsNodeRefValue(root); ok {
 		ex.SetReference(ref, root)
 	}
-	root = utils.NodeAlias(root)
+	root = utils.ResolveMergeNodes(root)
 	ex.RootNode = root
-	utils.CheckForMergeNodes(root)
 	ex.nodeStore = low.NodeLines{}
 	ex.Nodes = &ex.nodeStore
 	if len(root.Content) > 0 {

datamodel/low/base/external_doc.go

@@ -63,9 +63,8 @@ func (ex *ExternalDoc) Build(ctx context.Context, keyNode, root *yaml.Node, idx
 		ex.Extensions = nil
 		return nil
 	}
-	root = utils.NodeAlias(root)
+	root = utils.ResolveMergeNodes(root)
 	ex.RootNode = root
-	utils.CheckForMergeNodes(root)
 	if len(root.Content) > 0 {
 		ex.NodeMap.ExtractNodes(root, false)
 	} else {

datamodel/low/base/info.go

@@ -75,9 +75,8 @@ func (i *Info) Build(ctx context.Context, keyNode, root *yaml.Node, idx *index.S
 		i.Extensions = nil
 		return nil
 	}
-	root = utils.NodeAlias(root)
+	root = utils.ResolveMergeNodes(root)
 	i.RootNode = root
-	utils.CheckForMergeNodes(root)
 	if len(root.Content) > 0 {
 		i.NodeMap.ExtractNodes(root, false)
 	} else {

datamodel/low/base/license.go

@@ -47,9 +47,8 @@ func (l *License) Build(ctx context.Context, keyNode, root *yaml.Node, idx *inde
 		l.Extensions = nil
 		return nil
 	}
-	root = utils.NodeAlias(root)
+	root = utils.ResolveMergeNodes(root)
 	l.RootNode = root
-	utils.CheckForMergeNodes(root)
 	if len(root.Content) > 0 {
 		l.NodeMap.ExtractNodes(root, false)
 	} else {

datamodel/low/base/schema_build.go

@@ -43,8 +43,7 @@ func (s *Schema) Build(ctx context.Context, root *yaml.Node, idx *index.SpecInde
 	if root == nil {
 		return fmt.Errorf("cannot build schema from a nil node")
 	}
-	root = utils.NodeAlias(root)
-	utils.CheckForMergeNodes(root)
+	root = utils.ResolveMergeNodes(root)
 
 	s.reference = low.Reference{}
 	s.Reference = &s.reference
@@ -71,7 +70,7 @@ func (s *Schema) Build(ctx context.Context, root *yaml.Node, idx *index.SpecInde
 		if h, _, _ := utils.IsNodeRefValue(root); h {
 			ref, foundIdx, err, fctx := low.LocateRefNodeWithContext(ctx, root, idx)
 			if ref != nil {
-				root = ref
+				root = utils.ResolveMergeNodes(ref)
 				if fctx != nil {
 					ctx = fctx
 					s.context = ctx
@@ -278,21 +277,22 @@ func (s *Schema) Build(ctx context.Context, root *yaml.Node, idx *index.SpecInde
 		if err := ValidateDiscriminatorMappingValueNodes(discNode); err != nil {
 			return err
 		}
+		effective := utils.ResolveMergeNodes(discNode)
 		var discriminator Discriminator
-		_ = low.BuildModel(discNode, &discriminator)
+		_ = low.BuildModel(effective, &discriminator)
 		discriminator.KeyNode = discLabel
-		discriminator.RootNode = discNode
-		discriminator.Nodes = low.ExtractNodes(ctx, discNode)
+		discriminator.RootNode = effective
+		discriminator.Nodes = low.ExtractNodes(ctx, effective)
 		s.Discriminator = low.NodeReference[*Discriminator]{Value: &discriminator, KeyNode: discLabel, ValueNode: discNode}
-		low.AppendRecursiveNodes(&discriminator, discNode)
+		low.AppendRecursiveNodes(&discriminator, effective)
 	}
 
 	_, extDocLabel, extDocNode := utils.FindKeyNodeFullTop(ExternalDocsLabel, root.Content)
 	if extDocNode != nil {
 		var exDoc ExternalDoc
 		_ = low.BuildModel(extDocNode, &exDoc)
 		_ = exDoc.Build(ctx, extDocLabel, extDocNode, idx)
-		exDoc.Nodes = low.ExtractNodes(ctx, extDocNode)
+		exDoc.Nodes = low.ExtractNodes(ctx, exDoc.RootNode)
 		s.ExternalDocs = low.NodeReference[*ExternalDoc]{Value: &exDoc, KeyNode: extDocLabel, ValueNode: extDocNode}
 	}
 
@@ -301,7 +301,7 @@ func (s *Schema) Build(ctx context.Context, root *yaml.Node, idx *index.SpecInde
 		var xml XML
 		_ = low.BuildModel(xmlNode, &xml)
 		_ = xml.Build(xmlNode, idx)
-		xml.Nodes = low.ExtractNodes(ctx, xmlNode)
+		xml.Nodes = low.ExtractNodes(ctx, xml.RootNode)
 		s.XML = low.NodeReference[*XML]{Value: &xml, KeyNode: xmlLabel, ValueNode: xmlNode}
 	}
 

datamodel/low/base/schema_proxy.go

@@ -240,7 +240,6 @@ func (sp *SchemaProxy) Schema() *Schema {
 		}
 
 		schema := new(Schema)
-		utils.CheckForMergeNodes(buildNode)
 		err := schema.Build(sp.ctx, buildNode, sp.idx)
 		if err != nil {
 			sp.buildError = err

datamodel/low/base/security_requirement.go

@@ -64,9 +64,8 @@ func (s *SecurityRequirement) Build(ctx context.Context, keyNode, root *yaml.Nod
 		}
 		return nil
 	}
-	root = utils.NodeAlias(root)
+	root = utils.ResolveMergeNodes(root)
 	s.RootNode = root
-	utils.CheckForMergeNodes(root)
 	if len(root.Content) > 0 {
 		s.NodeMap.ExtractNodes(root, false)
 	} else {

datamodel/low/base/tag.go

@@ -65,9 +65,8 @@ func (t *Tag) GetKeyNode() *yaml.Node {
 // Build will extract extensions and external docs for the Tag.
 func (t *Tag) Build(ctx context.Context, keyNode, root *yaml.Node, idx *index.SpecIndex) error {
 	t.KeyNode = keyNode
-	root = utils.NodeAlias(root)
+	root = utils.ResolveMergeNodes(root)
 	t.RootNode = root
-	utils.CheckForMergeNodes(root)
 	t.Reference = new(low.Reference)
 	t.Nodes = low.ExtractNodes(ctx, root)
 	t.Extensions = low.ExtractExtensions(root)

datamodel/low/base/xml.go

@@ -52,8 +52,7 @@ func (x *XML) Build(root *yaml.Node, idx *index.SpecIndex) error {
 		x.Extensions = nil
 		return nil
 	}
-	root = utils.NodeAlias(root)
-	utils.CheckForMergeNodes(root)
+	root = utils.ResolveMergeNodes(root)
 	x.RootNode = root
 	if len(root.Content) > 0 {
 		x.NodeMap.ExtractNodes(root, false)

datamodel/low/extraction_functions.go

@@ -746,8 +746,7 @@ func ExtractMapNoLookupExtensions[PT Buildable[N], N any](
 ) (*orderedmap.Map[KeyReference[string], ValueReference[PT]], error) {
 	valueMap := orderedmap.New[KeyReference[string], ValueReference[PT]]()
 	var circError error
-	root = utils.NodeAlias(root)
-	utils.CheckForMergeNodes(root)
+	root = utils.ResolveMergeNodes(root)
 	if utils.IsNodeMap(root) {
 		var currentKey *yaml.Node
 		skip := false

datamodel/low/model_builder.go

@@ -71,8 +71,7 @@ func BuildModel(node *yaml.Node, model interface{}) error {
 	if node == nil {
 		return nil
 	}
-	node = utils.NodeAlias(node)
-	utils.CheckForMergeNodes(node)
+	node = utils.ResolveMergeNodes(node)
 
 	if reflect.ValueOf(model).Type().Kind() != reflect.Pointer {
 		return fmt.Errorf("cannot build model on non-pointer: %v", reflect.ValueOf(model).Type().Kind())
@@ -147,6 +146,13 @@ func SetField(field *reflect.Value, valueNode *yaml.Node, keyNode *yaml.Node) {
 		return
 	}
 
+	// Typed map fields read effective contents without rewriting the source
+	// mapping retained by NodeReference metadata or another model builder.
+	content := valueNode.Content
+	if utils.IsNodeMap(valueNode) {
+		content = utils.ResolveMergeNodes(valueNode).Content
+	}
+
 	switch field.Type() {
 
 	case setFieldMapStringNodeReferenceYAMLNodeType:
@@ -155,7 +161,7 @@ func SetField(field *reflect.Value, valueNode *yaml.Node, keyNode *yaml.Node) {
 			if field.CanSet() {
 				items := orderedmap.New[string, NodeReference[*yaml.Node]]()
 				var currentLabel string
-				for i, sliceItem := range valueNode.Content {
+				for i, sliceItem := range content {
 					if i%2 == 0 {
 						currentLabel = sliceItem.Value
 						continue
@@ -176,7 +182,7 @@ func SetField(field *reflect.Value, valueNode *yaml.Node, keyNode *yaml.Node) {
 			if field.CanSet() {
 				items := orderedmap.New[string, NodeReference[string]]()
 				var currentLabel string
-				for i, sliceItem := range valueNode.Content {
+				for i, sliceItem := range content {
 					if i%2 == 0 {
 						currentLabel = sliceItem.Value
 						continue
@@ -202,8 +208,8 @@ func SetField(field *reflect.Value, valueNode *yaml.Node, keyNode *yaml.Node) {
 
 		if utils.IsNodeArray(valueNode) {
 			if field.CanSet() {
-				items := make([]NodeReference[*yaml.Node], 0, len(valueNode.Content))
-				for _, sliceItem := range valueNode.Content {
+				items := make([]NodeReference[*yaml.Node], 0, len(content))
+				for _, sliceItem := range content {
 					items = append(items, NodeReference[*yaml.Node]{
 						Value:     sliceItem,
 						ValueNode: sliceItem,
@@ -309,8 +315,8 @@ func SetField(field *reflect.Value, valueNode *yaml.Node, keyNode *yaml.Node) {
 
 		if utils.IsNodeArray(valueNode) {
 			if field.CanSet() {
-				items := make([]NodeReference[string], 0, len(valueNode.Content))
-				for _, sliceItem := range valueNode.Content {
+				items := make([]NodeReference[string], 0, len(content))
+				for _, sliceItem := range content {
 					items = append(items, NodeReference[string]{
 						Value:     sliceItem.Value,
 						ValueNode: sliceItem,
@@ -325,8 +331,8 @@ func SetField(field *reflect.Value, valueNode *yaml.Node, keyNode *yaml.Node) {
 
 		if utils.IsNodeArray(valueNode) {
 			if field.CanSet() {
-				items := make([]NodeReference[float32], 0, len(valueNode.Content))
-				for _, sliceItem := range valueNode.Content {
+				items := make([]NodeReference[float32], 0, len(content))
+				for _, sliceItem := range content {
 					fv, _ := strconv.ParseFloat(sliceItem.Value, 32)
 					items = append(items, NodeReference[float32]{
 						Value:     float32(fv),
@@ -342,8 +348,8 @@ func SetField(field *reflect.Value, valueNode *yaml.Node, keyNode *yaml.Node) {
 
 		if utils.IsNodeArray(valueNode) {
 			if field.CanSet() {
-				items := make([]NodeReference[float64], 0, len(valueNode.Content))
-				for _, sliceItem := range valueNode.Content {
+				items := make([]NodeReference[float64], 0, len(content))
+				for _, sliceItem := range content {
 					fv, _ := strconv.ParseFloat(sliceItem.Value, 64)
 					items = append(items, NodeReference[float64]{Value: fv, ValueNode: sliceItem})
 				}
@@ -355,8 +361,8 @@ func SetField(field *reflect.Value, valueNode *yaml.Node, keyNode *yaml.Node) {
 
 		if utils.IsNodeArray(valueNode) {
 			if field.CanSet() {
-				items := make([]NodeReference[int], 0, len(valueNode.Content))
-				for _, sliceItem := range valueNode.Content {
+				items := make([]NodeReference[int], 0, len(content))
+				for _, sliceItem := range content {
 					iv, _ := strconv.Atoi(sliceItem.Value)
 					items = append(items, NodeReference[int]{
 						Value:     iv,
@@ -372,8 +378,8 @@ func SetField(field *reflect.Value, valueNode *yaml.Node, keyNode *yaml.Node) {
 
 		if utils.IsNodeArray(valueNode) {
 			if field.CanSet() {
-				items := make([]NodeReference[int64], 0, len(valueNode.Content))
-				for _, sliceItem := range valueNode.Content {
+				items := make([]NodeReference[int64], 0, len(content))
+				for _, sliceItem := range content {
 					iv, _ := strconv.ParseInt(sliceItem.Value, 10, 64)
 					items = append(items, NodeReference[int64]{
 						Value:     iv,
@@ -389,8 +395,8 @@ func SetField(field *reflect.Value, valueNode *yaml.Node, keyNode *yaml.Node) {
 
 		if utils.IsNodeArray(valueNode) {
 			if field.CanSet() {
-				items := make([]NodeReference[bool], 0, len(valueNode.Content))
-				for _, sliceItem := range valueNode.Content {
+				items := make([]NodeReference[bool], 0, len(content))
+				for _, sliceItem := range content {
 					bv, _ := strconv.ParseBool(sliceItem.Value)
 					items = append(items, NodeReference[bool]{
 						Value:     bv,
@@ -408,9 +414,9 @@ func SetField(field *reflect.Value, valueNode *yaml.Node, keyNode *yaml.Node) {
 		if utils.IsNodeMap(valueNode) {
 			if field.CanSet() {
 				items := orderedmap.New[KeyReference[string], ValueReference[string]]()
-				for i := 0; i < len(valueNode.Content)-1; i += 2 {
-					cf := valueNode.Content[i]
-					sliceItem := valueNode.Content[i+1]
+				for i := 0; i < len(content)-1; i += 2 {
+					cf := content[i]
+					sliceItem := content[i+1]
 					items.Set(KeyReference[string]{
 						Value:   cf.Value,
 						KeyNode: cf,
@@ -428,9 +434,9 @@ func SetField(field *reflect.Value, valueNode *yaml.Node, keyNode *yaml.Node) {
 		if utils.IsNodeMap(valueNode) {
 			if field.CanSet() {
 				items := orderedmap.New[KeyReference[string], ValueReference[string]]()
-				for i := 0; i < len(valueNode.Content)-1; i += 2 {
-					cf := valueNode.Content[i]
-					sliceItem := valueNode.Content[i+1]
+				for i := 0; i < len(content)-1; i += 2 {
+					cf := content[i]
+					sliceItem := content[i+1]
 					items.Set(KeyReference[string]{
 						Value:   cf.Value,
 						KeyNode: cf,
@@ -450,9 +456,9 @@ func SetField(field *reflect.Value, valueNode *yaml.Node, keyNode *yaml.Node) {
 		if utils.IsNodeMap(valueNode) {
 			if field.CanSet() {
 				items := orderedmap.New[KeyReference[string], ValueReference[string]]()
-				for i := 0; i < len(valueNode.Content)-1; i += 2 {
-					cf := valueNode.Content[i]
-					sliceItem := valueNode.Content[i+1]
+				for i := 0; i < len(content)-1; i += 2 {
+					cf := content[i]
+					sliceItem := content[i+1]
 					items.Set(KeyReference[string]{
 						Value:   cf.Value,
 						KeyNode: cf,
@@ -473,8 +479,8 @@ func SetField(field *reflect.Value, valueNode *yaml.Node, keyNode *yaml.Node) {
 
 		if utils.IsNodeArray(valueNode) {
 			if field.CanSet() {
-				items := make([]ValueReference[string], 0, len(valueNode.Content))
-				for _, sliceItem := range valueNode.Content {
+				items := make([]ValueReference[string], 0, len(content))
+				for _, sliceItem := range content {
 					items = append(items, ValueReference[string]{
 						Value:     sliceItem.Value,
 						ValueNode: sliceItem,
@@ -493,8 +499,8 @@ func SetField(field *reflect.Value, valueNode *yaml.Node, keyNode *yaml.Node) {
 
 		if utils.IsNodeArray(valueNode) {
 			if field.CanSet() {
-				items := make([]ValueReference[*yaml.Node], 0, len(valueNode.Content))
-				for _, sliceItem := range valueNode.Content {
+				items := make([]ValueReference[*yaml.Node], 0, len(content))
+				for _, sliceItem := range content {
 					items = append(items, ValueReference[*yaml.Node]{
 						Value:     sliceItem,
 						ValueNode: sliceItem,