fix(workspace): only consider authored $dynamicAnchor in ResolveDynamicAnchorInContext

$defs entries that are themselves $refs no longer fall through to the
referenced target's $dynamicAnchor. OpenApiSchemaReference.DynamicAnchor
delegates to Target when the authored sibling is empty, which violated the
method's context-bound intent.

Adds AuthoredDynamicAnchor helper that reads Reference.DynamicAnchor for
OpenApiSchemaReference and the plain property otherwise. Both $defs lookups
(non-reference context branch and reference-holder branch) now use it.

Tests cover both branches in V31 and V32: a Container schema with an aliased
$ref def whose Target declares $dynamicAnchor: node, plus a reference holder
whose Reference.Definitions carries the same aliased entry.

Author: aqeelat

src/Microsoft.OpenApi/Services/OpenApiWorkspace.cs

@@ -750,16 +750,23 @@ public IReadOnlyList<IOpenApiSchema> GetDynamicAnchorCandidates(OpenApiDocument
                 if (osr.Reference.DynamicAnchor is string a && a.Equals(anchorName, StringComparison.Ordinal))
                     return contextSchema;
                 return osr.Reference.Definitions?.Values.FirstOrDefault(def =>
-                    def.DynamicAnchor is string da && da.Equals(anchorName, StringComparison.Ordinal));
+                    AuthoredDynamicAnchor(def) is string da && da.Equals(anchorName, StringComparison.Ordinal));
             }
 
             if (contextSchema.DynamicAnchor is string b && b.Equals(anchorName, StringComparison.Ordinal))
                 return contextSchema;
 
             return contextSchema.Definitions?.Values.FirstOrDefault(def =>
-                def.DynamicAnchor is string da && da.Equals(anchorName, StringComparison.Ordinal));
+                AuthoredDynamicAnchor(def) is string da && da.Equals(anchorName, StringComparison.Ordinal));
         }
 
+        // Reads only the authored $dynamicAnchor on the schema itself. For OpenApiSchemaReference,
+        // IOpenApiSchema.DynamicAnchor falls through to Target when the reference's authored sibling
+        // is empty, which would resolve an anchor declared on the referenced target rather than on
+        // the $defs entry. Context-bound resolution must consider only the authored sibling.
+        private static string? AuthoredDynamicAnchor(IOpenApiSchema schema)
+            => schema is OpenApiSchemaReference r ? r.Reference.DynamicAnchor : schema.DynamicAnchor;
+
         /// <summary>
         /// Adds a document id to the dictionaries of document locations and their ids.
         /// </summary>

test/Microsoft.OpenApi.Readers.Tests/V31Tests/OpenApiDynamicRefTests.cs

@@ -1107,6 +1107,61 @@ public async Task ResolveDynamicAnchorInContextDoesNotReadFromTargetForReference
         Assert.Null(result);
     }
 
+    [Fact]
+    public async Task ResolveDynamicAnchorInContextDoesNotReadFromTargetForReferenceDefsEntries()
+    {
+        // A $defs entry that is itself a $ref must contribute its own authored $dynamicAnchor,
+        // not an anchor declared on the referenced target. The "aliased" def points at a target
+        // that declares $dynamicAnchor: node, but the def itself does not author it, so the
+        // context-bound lookup must return null.
+        var yaml =
+        """
+        openapi: 3.1.0
+        info:
+          title: Test
+          version: 1.0.0
+        paths: {}
+        components:
+          schemas:
+            Target:
+              $dynamicAnchor: node
+              type: object
+              properties:
+                name:
+                  type: string
+            Container:
+              type: object
+              $defs:
+                aliased:
+                  $ref: '#/components/schemas/Target'
+        """;
+
+        var doc = await LoadDocumentAsync(yaml);
+
+        var container = doc.Components.Schemas["Container"];
+        var aliased = Assert.IsType<OpenApiSchemaReference>(container.Definitions!["aliased"]);
+        // Sanity: the fall-through property would surface the target's anchor...
+        Assert.Equal("node", aliased.DynamicAnchor);
+        // ...but the authored sibling on the def entry is empty.
+        Assert.Null(aliased.Reference.DynamicAnchor);
+
+        // Both the non-reference context branch (Container) and the reference-holder branch
+        // (a ref whose Reference.Definitions carries the entry) must ignore the target's anchor.
+        Assert.Null(OpenApiWorkspace.ResolveDynamicAnchorInContext(container, "node"));
+
+        var refWithDefs = new OpenApiSchemaReference("Container", doc)
+        {
+            Reference =
+            {
+                Definitions = new Dictionary<string, IOpenApiSchema>
+                {
+                    ["aliased"] = aliased
+                }
+            }
+        };
+        Assert.Null(OpenApiWorkspace.ResolveDynamicAnchorInContext(refWithDefs, "node"));
+    }
+
     [Fact]
     public async Task DynamicRefFallsBackToPlainAnchor()
     {

test/Microsoft.OpenApi.Readers.Tests/V32Tests/OpenApiDynamicRefTests.cs

@@ -1,3 +1,4 @@
+using System.Collections.Generic;
 using System.IO;
 using System.Text;
 using System.Text.Json.Nodes;
@@ -944,4 +945,59 @@ public async Task InliningDynamicRefProducesResolvedTargetSchema()
         Assert.NotNull(inlined.Properties);
         Assert.True(inlined.Properties.ContainsKey("value"));
     }
+
+    [Fact]
+    public async Task ResolveDynamicAnchorInContextDoesNotReadFromTargetForReferenceDefsEntries()
+    {
+        // A $defs entry that is itself a $ref must contribute its own authored $dynamicAnchor,
+        // not an anchor declared on the referenced target. The "aliased" def points at a target
+        // that declares $dynamicAnchor: node, but the def itself does not author it, so the
+        // context-bound lookup must return null.
+        var yaml =
+        """
+        openapi: 3.2.0
+        info:
+          title: Test
+          version: 1.0.0
+        paths: {}
+        components:
+          schemas:
+            Target:
+              $dynamicAnchor: node
+              type: object
+              properties:
+                name:
+                  type: string
+            Container:
+              type: object
+              $defs:
+                aliased:
+                  $ref: '#/components/schemas/Target'
+        """;
+
+        var doc = await LoadDocumentAsync(yaml);
+
+        var container = doc.Components.Schemas["Container"];
+        var aliased = Assert.IsType<OpenApiSchemaReference>(container.Definitions!["aliased"]);
+        // Sanity: the fall-through property would surface the target's anchor...
+        Assert.Equal("node", aliased.DynamicAnchor);
+        // ...but the authored sibling on the def entry is empty.
+        Assert.Null(aliased.Reference.DynamicAnchor);
+
+        // Both the non-reference context branch (Container) and the reference-holder branch
+        // (a ref whose Reference.Definitions carries the entry) must ignore the target's anchor.
+        Assert.Null(OpenApiWorkspace.ResolveDynamicAnchorInContext(container, "node"));
+
+        var refWithDefs = new OpenApiSchemaReference("Container", doc)
+        {
+            Reference =
+            {
+                Definitions = new Dictionary<string, IOpenApiSchema>
+                {
+                    ["aliased"] = aliased
+                }
+            }
+        };
+        Assert.Null(OpenApiWorkspace.ResolveDynamicAnchorInContext(refWithDefs, "node"));
+    }
 }