fix: repair reference resolution, bundling, and comparison regressions

bundler/bundler_composer.go

@@ -68,6 +68,9 @@ func handleIndex(c *handleIndexConfig) error {
 			continue
 		}
 		mappedReference := mappedReferences[sequenced.FullDefinition]
+		if mappedReference == nil {
+			mappedReference, _ = c.idx.SearchIndexForReference(sequenced.FullDefinition)
+		}
 
 		// Check for invalid sibling properties if strict validation is enabled
 		if c.compositionConfig.StrictValidation &&
@@ -188,6 +191,14 @@ func processReference(model *v3.Document, pr *processRef, cf *handleIndexConfig)
 		}
 		model.Components = components
 	}
+	// An alias contributes no component of its own. Inline its reference after
+	// the target has been composed, so both paths use the same component.
+	isAlias, _, _ := utils.IsNodeRefValue(pr.ref.Node)
+	isAlias = isAlias && len(pr.ref.Node.Content) == 2
+	if !pr.fromDiscriminator && isAlias {
+		cf.inlineRequired = append(cf.inlineRequired, pr)
+		return nil
+	}
 
 	var location []string
 	if strings.Contains(pr.ref.FullDefinition, "#/") {
@@ -198,7 +209,9 @@ func processReference(model *v3.Document, pr *processRef, cf *handleIndexConfig)
 		// Bare-file imports need the sequenced absolute definition so composition
 		// keys and later rewrites point at the same target.
 		pr.ref.FullDefinition = pr.seqRef.FullDefinition
-		if importType, ok := inferComponentTypeFromSourcePath(pr.seqRef.SourcePath); ok &&
+		if pr.fromDiscriminator && isAlias {
+			_, location = fileImportLocationForType(v3low.SchemasLabel, components, pr, cf)
+		} else if importType, ok := inferComponentTypeFromSourcePath(pr.seqRef.SourcePath); ok &&
 			canComposeContextualReference(importType, pr.ref.Node, true) {
 			_, location = fileImportLocationForType(importType, components, pr, cf)
 		} else if importType, ok := DetectOpenAPIComponentType(pr.ref.Node); ok {
@@ -383,7 +396,8 @@ func enqueueDiscriminatorMappingTargets(
 		mapKey := processRefMapKeyForComponent(ref, v3low.SchemasLabel)
 
 		// Skip targets already queued for composition.
-		if cf.refMap.GetOrZero(mapKey) != nil {
+		if existing := cf.refMap.GetOrZero(mapKey); existing != nil {
+			existing.fromDiscriminator = true
 			continue
 		}
 

bundler/composer_functions.go

@@ -52,7 +52,15 @@ func processRefMapKey(target, source *index.Reference) string {
 	if fullDefinition == "" && source != nil {
 		fullDefinition = source.FullDefinition
 	}
-	return contextualProcessRefKey(fullDefinition, source)
+	key := contextualProcessRefKey(fullDefinition, source)
+	if key == fullDefinition && target != nil && !isExplicitComponentDefinition(fullDefinition) {
+		// A whole-file alias has no source path. Use the same detected bucket
+		// that composition uses, so it shares the target with contextual refs.
+		if componentType, ok := DetectOpenAPIComponentType(target.Node); ok {
+			return fullDefinition + contextualRefKeySeparator + componentType
+		}
+	}
+	return key
 }
 
 // processRefMapKeyForComponent scopes a target ref by an already-known component bucket.

bundler/external_regression_test.go

@@ -0,0 +1,152 @@
+package bundler
+
+import (
+	"fmt"
+	"os"
+	"path/filepath"
+	"strings"
+	"testing"
+
+	"github.com/pb33f/go-yaml"
+	"github.com/pb33f/libopenapi"
+	"github.com/pb33f/libopenapi/datamodel"
+	"github.com/pb33f/libopenapi/utils"
+	"github.com/pb33f/testify/require"
+)
+
+func externalRegressionConfig(t *testing.T, files map[string]string) *datamodel.DocumentConfiguration {
+	t.Helper()
+	dir := t.TempDir()
+	for name, content := range files {
+		path := filepath.Join(dir, name)
+		require.NoError(t, os.MkdirAll(filepath.Dir(path), 0755))
+		require.NoError(t, os.WriteFile(path, []byte(content), 0600))
+	}
+	return &datamodel.DocumentConfiguration{BasePath: dir, AllowFileReferences: true}
+}
+
+func TestBundleBytesComposed_EncodedPathItem(t *testing.T) {
+	config := externalRegressionConfig(t, map[string]string{"paths.yaml": `openapi: 3.1.0
+info: {title: Paths, version: "1"}
+paths:
+  /items/{id}:
+    get:
+      parameters: [{name: id, in: path, required: true, schema: {type: string}}]
+      responses:
+        '200': {description: ok}
+`})
+	root := []byte(`openapi: 3.1.0
+info: {title: Encoded paths, version: "1"}
+paths:
+  /items/{id}: {$ref: './paths.yaml#/paths/~1items~1%7Bid%7D'}
+`)
+	out, err := BundleBytesComposed(root, config, nil)
+	require.NoError(t, err)
+	var bundled yaml.Node
+	require.NoError(t, yaml.Unmarshal(out, &bundled))
+	_, paths := utils.FindKeyNodeTop("paths", bundled.Content[0].Content)
+	require.NotNil(t, paths)
+	_, pathItem := utils.FindKeyNodeTop("/items/{id}", paths.Content)
+	require.NotNil(t, pathItem)
+	require.Nil(t, utils.GetRefValueNode(pathItem), "path item must contain the operation, not a self-reference")
+	doc, err := libopenapi.NewDocument(out)
+	require.NoError(t, err)
+	model, err := doc.BuildV3Model()
+	require.NoError(t, err)
+	item := model.Model.Paths.PathItems.GetOrZero("/items/{id}")
+	require.NotNil(t, item.Get)
+	require.Len(t, item.Get.Parameters, 1)
+}
+
+func TestBundleBytesComposed_SharedAliasTarget(t *testing.T) {
+	config := externalRegressionConfig(t, map[string]string{
+		"schemas/List.yaml":  "type: object\nproperties:\n  data:\n    type: array\n    items: {$ref: ./Item.yaml}\n",
+		"schemas/Alias.yaml": "$ref: ./Item.yaml\n",
+		"schemas/Item.yaml":  "type: object\nproperties:\n  id: {type: string}\n",
+	})
+	root := []byte(`openapi: 3.1.0
+info: {title: Shared aliases, version: "1"}
+paths:
+  /items:
+    get:
+      responses:
+        '200':
+          description: ok
+          content: {application/json: {schema: {$ref: ./schemas/List.yaml}}}
+  /item:
+    get:
+      responses:
+        '200':
+          description: ok
+          content: {application/json: {schema: {$ref: ./schemas/Alias.yaml}}}
+`)
+	out, err := BundleBytesComposed(root, config, nil)
+	require.NoError(t, err)
+	doc, err := libopenapi.NewDocument(out)
+	require.NoError(t, err)
+	model, err := doc.BuildV3Model()
+	require.NoError(t, err)
+	list := model.Model.Components.Schemas.GetOrZero("List").Schema()
+	require.NotNil(t, list.Properties.GetOrZero("data"), string(out))
+	require.Equal(t, 2, model.Model.Components.Schemas.Len(), string(out))
+	item := list.Properties.GetOrZero("data").Schema().Items.A.Schema()
+	require.Equal(t, []string{"object"}, item.Type)
+	require.NotNil(t, item.Properties.GetOrZero("id"))
+}
+
+func TestBundleBytes_RecursiveSchemaAtDifferentDepths(t *testing.T) {
+	for depth := 0; depth <= 5; depth++ {
+		t.Run(fmt.Sprint(depth), func(t *testing.T) {
+			files := map[string]string{
+				"schemas/Step.yaml": "properties:\n  steps:\n    items: {$ref: ./Step.yaml}\n",
+				"schemas/V.yaml":    "properties:\n  steps:\n    items: {$ref: ./Step.yaml}\n  styles: {$ref: ./W.yaml}\n",
+				"schemas/W.yaml":    "properties:\n  c: {$ref: ./E.yaml}\n",
+				"schemas/E.yaml":    "{}\n",
+			}
+			ref := "V.yaml"
+			for i := depth; i > 0; i-- {
+				name := fmt.Sprintf("A%d.yaml", i)
+				files["schemas/"+name] = "properties:\n  p: {$ref: ./" + ref + "}\n"
+				ref = name
+			}
+			files["paths/item.yaml"] = "post:\n  requestBody:\n    content:\n      application/json:\n        schema: {$ref: ../schemas/" + ref + "}\n  responses:\n    '200': {description: ok}\n"
+			config := externalRegressionConfig(t, files)
+			root := []byte("openapi: 3.0.3\ninfo: {title: Nested recursion, version: '1'}\npaths:\n  /items: {$ref: ./paths/item.yaml}\n")
+			out, err := BundleBytes(root, config)
+			require.NoError(t, err)
+			doc, err := libopenapi.NewDocument(out)
+			require.NoError(t, err)
+			model, err := doc.BuildV3Model()
+			require.NoError(t, err)
+			step := model.Model.Components.Schemas.GetOrZero("Step")
+			require.NotNil(t, step, string(out))
+			require.Equal(t, "#/components/schemas/Step", step.Schema().Properties.GetOrZero("steps").Schema().Items.A.GetReference())
+		})
+	}
+}
+
+func TestBundleBytesComposed_AliasDiscriminatorMapping(t *testing.T) {
+	cfg := externalRegressionConfig(t, map[string]string{"schemas/Alias.yaml": "$ref: ./Dog.yaml\n", "schemas/Dog.yaml": "type: object\nproperties:\n  kind: {type: string, enum: [dog]}\n"})
+	out, err := BundleBytesComposed([]byte(`openapi: 3.1.0
+info: {title: Aliases, version: '1'}
+paths: {}
+components:
+  schemas:
+    Animal:
+      oneOf:
+        - {$ref: ./schemas/Alias.yaml}
+      discriminator:
+        propertyName: kind
+        mapping:
+          dog: ./schemas/Alias.yaml
+`), cfg, nil)
+	require.NoError(t, err)
+
+	doc, err := libopenapi.NewDocument(out)
+	require.NoError(t, err)
+	model, err := doc.BuildV3Model()
+	require.NoError(t, err)
+	mapping := model.Model.Components.Schemas.GetOrZero("Animal").Schema().Discriminator.Mapping.GetOrZero("dog")
+	require.True(t, strings.HasPrefix(mapping, "#/components/schemas/"), mapping)
+	require.NotNil(t, model.Model.Components.Schemas.GetOrZero(strings.TrimPrefix(mapping, "#/components/schemas/")), mapping)
+}

datamodel/document_config.go

@@ -81,6 +81,11 @@ type DocumentConfiguration struct {
 	// FileFilter should be used to limit the scope of the rolodex.
 	AllowFileReferences bool
 
+	// AllowExcessiveAliases disables the YAML alias expansion limit during indexing.
+	// Use it for trusted documents with large amounts of shared YAML content.
+	// The limit remains enabled by default; cycle detection is always enabled.
+	AllowExcessiveAliases bool
+
 	// SkipExternalRefResolution will skip resolving external $ref references (those not starting with #).
 	// When enabled, external references will be left as-is during model building. Schema proxies will
 	// report IsReference()=true and GetReference() will return the ref string, but Schema() will return nil.

datamodel/high/v2/path_item.go

@@ -39,6 +39,7 @@ type PathItem struct {
 func NewPathItem(pathItem *lowV2.PathItem) *PathItem {
 	p := new(PathItem)
 	p.low = pathItem
+	p.Ref = pathItem.Ref.Value
 	p.Extensions = high.ExtractExtensions(pathItem.Extensions)
 	if !pathItem.Parameters.IsEmpty() {
 		var params []*Parameter

datamodel/low/base/schema_build.go

@@ -68,7 +68,7 @@ func (s *Schema) Build(ctx context.Context, root *yaml.Node, idx *index.SpecInde
 
 	if !isTransformed {
 		if h, _, _ := utils.IsNodeRefValue(root); h {
-			ref, foundIdx, err, fctx := low.LocateRefNodeWithContext(ctx, root, idx)
+			ref, foundIdx, err, fctx := low.LocateRefEnd(ctx, root, idx, 0)
 			if ref != nil {
 				root = utils.ResolveMergeNodes(ref)
 				if fctx != nil {

datamodel/low/integer_decimal.go

@@ -0,0 +1,95 @@
+package low
+
+import (
+	"math"
+	"strconv"
+	"strings"
+)
+
+// parseDecimalInt64 converts a syntactically valid decimal without rounding.
+// It scans the mantissa once and retains at most 19 digits, regardless of exponent.
+func parseDecimalInt64(value string) (int64, bool) {
+	value = strings.ReplaceAll(value, "_", "")
+	negative := strings.HasPrefix(value, "-")
+	value = strings.TrimLeft(value, "+-")
+	mantissa := value
+	exponent := int64(0)
+	if i := strings.IndexAny(value, "eE"); i >= 0 {
+		mantissa = value[:i]
+		exponent, _ = strconv.ParseInt(value[i+1:], 10, 64)
+	}
+	var digits, leading, trailing, fractional int64
+	nonzero, afterPoint := false, false
+	for _, digit := range mantissa {
+		if digit == '.' {
+			afterPoint = true
+			continue
+		}
+		digits++
+		if afterPoint {
+			fractional++
+		}
+		if digit == '0' {
+			trailing++
+			if !nonzero {
+				leading++
+			}
+		} else {
+			nonzero = true
+			trailing = 0
+		}
+	}
+	if !nonzero {
+		return 0, true
+	}
+	limit := int64(math.MaxInt64)
+	if negative {
+		limit = math.MinInt64
+	}
+	// Bound the exponent before subtracting the mantissa's decimal places.
+	if exponent > digits+19 {
+		return limit, true
+	}
+	if exponent < -digits {
+		return 0, false
+	}
+	scale := exponent - fractional
+	if scale < -trailing {
+		return 0, false
+	}
+	integerDigits := digits - leading + scale
+	if integerDigits > 19 {
+		return limit, true
+	}
+	maxMagnitude := uint64(math.MaxInt64)
+	if negative {
+		maxMagnitude++
+	}
+	var result uint64
+	remaining := integerDigits
+	for _, digit := range mantissa {
+		if digit == '.' {
+			continue
+		}
+		if leading > 0 {
+			leading--
+			continue
+		}
+		if remaining == 0 {
+			break
+		}
+		result = result*10 + uint64(digit-'0')
+		remaining--
+	}
+	for remaining > 0 {
+		result *= 10
+		remaining--
+	}
+	if result > maxMagnitude {
+		return limit, true
+	}
+	if negative {
+		return -int64(result), true
+	}
+	return int64(result), true
+}