More work

Author: michaelstaib

src/HotChocolate/Fusion/benchmarks/Fusion.Execution.Benchmarks/VariableMergingBenchmark.cs

@@ -196,7 +196,8 @@ private static OperationRequirement Requirement(string key)
             key,
             new NamedTypeNode("String"),
             SelectionPath.Root,
-            new PathNode(new PathSegmentNode(new FusionNameNode(key))));
+            new PathNode(new PathSegmentNode(new FusionNameNode(key))),
+            null);
 
     private static CompactPath Path(params int[] segments)
     {

src/HotChocolate/Fusion/src/Fusion.Composition/ApolloFederation/RemoveExternalFields.cs

@@ -253,6 +253,32 @@ private static bool IsReferencedByOutputField(
                             outputType,
                             out var selectedFields);
 
+                        // A @require map that traverses an object- or interface-typed
+                        // intermediate (a nested selection such as
+                        // "dimensions { size weight }") keeps its ENTIRE subtree with
+                        // @external intact: the intermediate path field has to stay
+                        // traversable and its leaf fields belong to the same non-resolvable
+                        // input contribution, so dropping them would leave the intermediate
+                        // type empty. A map that is a flat, root-level scalar requirement
+                        // (such as "price") keeps nothing: its external leaf is removed so it
+                        // never competes with its real owner as a spurious partial
+                        // contribution.
+                        var hasComplexIntermediate = false;
+
+                        foreach (var selectedField in selectedFields)
+                        {
+                            if (selectedField.Type.NamedType() is IComplexTypeDefinition)
+                            {
+                                hasComplexIntermediate = true;
+                                break;
+                            }
+                        }
+
+                        if (!hasComplexIntermediate)
+                        {
+                            continue;
+                        }
+
                         foreach (var selectedField in selectedFields)
                         {
                             var coordinate = selectedField.Coordinate;

src/HotChocolate/Fusion/src/Fusion.Execution/Execution/ApolloFederation/RepresentationShape.cs

@@ -99,6 +99,14 @@ internal sealed class RepresentationShapeNode
     /// or <c>null</c> when unconditional.
     /// </summary>
     public string? TypeCondition { get; set; }
+
+    /// <summary>
+    /// Gets whether the emitter must write the runtime <c>__typename</c> into
+    /// this composite node's object. This is set when the node's declared type
+    /// is abstract and the node carries no type-conditioned branches, so the
+    /// source schema cannot reconstruct the abstract value without its type name.
+    /// </summary>
+    public bool RequiresTypeName { get; set; }
 }
 
 /// <summary>