@apollo/federation-internals 2.4.6 → 2.4.8

package/src/operations.ts

@@ -47,11 +47,12 @@ import {
   Variables,
   isObjectType,
   NamedType,
+  isUnionType,
 } from "./definitions";
 import { isInterfaceObjectType } from "./federation";
 import { ERRORS } from "./error";
-import { isSubtype, sameType } from "./types";
-import { assert, isDefined, mapEntries, mapValues, MapWithCachedArrays, MultiMap, SetMultiMap } from "./utils";
+import { isSubtype, sameType, typesCanBeMerged } from "./types";
+import { assert, mapKeys, mapValues, MapWithCachedArrays, MultiMap, SetMultiMap } from "./utils";
 import { argumentsEquals, argumentsFromAST, isValidValue, valueToAST, valueToString } from "./values";
 import { v1 as uuidv1 } from 'uuid';
 
@@ -115,7 +116,7 @@ export class Field<TArgs extends {[key: string]: any} = {[key: string]: any}> ex
 
   constructor(
     readonly definition: FieldDefinition<CompositeType>,
-    private readonly args?: TArgs,
+    readonly args?: TArgs,
     directives?: readonly Directive<any>[],
     readonly alias?: string,
   ) {
@@ -696,88 +697,265 @@ export type RootOperationPath = {
   path: OperationPath
 }
 
-// TODO Operations can also have directives
-export class Operation {
-  constructor(
-    readonly schema: Schema,
-    readonly rootKind: SchemaRootKind,
-    readonly selectionSet: SelectionSet,
-    readonly variableDefinitions: VariableDefinitions,
-    readonly name?: string) {
+// Computes for every fragment, which other fragments use it (so the reverse of it's dependencies, the other fragment it uses). 
+function computeFragmentsDependents(fragments: NamedFragments): SetMultiMap<string, string> {
+  const reverseDeps = new SetMultiMap<string, string>();
+  for (const fragment of fragments.definitions()) {
+    for (const dependency of fragment.fragmentUsages().keys()) {
+      reverseDeps.add(dependency, fragment.name);
+    }
   }
+  return reverseDeps;
+}
 
-  optimize(fragments?: NamedFragments, minUsagesToOptimize: number = 2): Operation {
-    assert(minUsagesToOptimize >= 1, `Expected 'minUsagesToOptimize' to be at least 1, but got ${minUsagesToOptimize}`)
-    if (!fragments || fragments.isEmpty()) {
-      return this;
+function clearKeptFragments(
+  usages: Map<string, number>,
+  fragments: NamedFragments,
+  minUsagesToOptimize: number
+) {
+  // `toCheck` will contain only fragments that we know we want to keep (but haven't handled/removed from `usages` yet).
+  let toCheck = Array.from(usages.entries()).filter(([_, count]) => count >= minUsagesToOptimize).map(([name, _]) => name);
+  while (toCheck.length > 0) {
+    const newToCheck = [];
+    for (const name of toCheck) {
+      // We "keep" that fragment so clear it.
+      usages.delete(name);
+      // But as it is used, bump the usage for every fragment it uses.
+      const ownUsages = fragments.get(name)!.fragmentUsages();
+      for (const [otherName, otherCount] of ownUsages.entries()) {
+        const prevCount = usages.get(otherName);
+        // We're interested in fragment not in `usages` anymore.
+        if (prevCount !== undefined) {
+          const newCount = prevCount + otherCount;
+          usages.set(otherName, newCount);
+          if (prevCount < minUsagesToOptimize && newCount >= minUsagesToOptimize) {
+            newToCheck.push(otherName);
+          }
+        }
+      }
     }
+    toCheck = newToCheck;
+  }
+}
 
-    let optimizedSelection = this.selectionSet.optimize(fragments);
-    if (optimizedSelection === this.selectionSet) {
-      return this;
-    }
+// Checks, in `selectionSet`, which fragments (of `fragments`) are used at least `minUsagesToOptimize` times.
+// Returns the updated set of fragments containing only the fragment definitions with usage above our threshold,
+// and `undefined` or `null` if no such fragment meets said threshold. When this method returns `null`, it
+// additionally means that no fragments are use at all in `selectionSet` (and so `undefined` means that
+// "some" fragments are used in `selectionSet`, but just none of them is used at least `minUsagesToOptimize`
+// times).
+function computeFragmentsToKeep(
+  selectionSet: SelectionSet,
+  fragments: NamedFragments,
+  minUsagesToOptimize: number
+): NamedFragments | undefined | null {
+  // We start by collecting the usages within the selection set.
+  const usages = new Map<string, number>();
+  selectionSet.collectUsedFragmentNames(usages);
+
+  // If we have no fragment in the selection set, then it's simple, we just don't keep any fragments.
+  if (usages.size === 0) {
+    return null;
+  }
+
+  // We're going to remove fragments from usages as we categorize them as kept or expanded, so we
+  // first ensure that it has entries for every fragment, default to 0.
+  for (const fragment of fragments.definitions()) {
+    if (usages.get(fragment.name) === undefined) {
+      usages.set(fragment.name, 0);
+    }
+  }
+
+  // At this point, `usages` contains the usages of fragments "in the selection". From that, we want
+  // to decide which fragment to "keep", and which to re-expand. But there is 2 subtlety:
+  // 1. when we decide to keep some fragment F, then we should could it's own usages of other fragments. That
+  //  is, if a fragment G is use once in the selection, but also use once in a fragment F that we
+  //  keep, then the usages for G is really 2 (but if F is unused, then we don't want to count
+  //  it's usage of G for instance).
+  // 2. when we decide to expand a fragment, then this also impact the usages of other fragments it
+  //  uses, as those gets "inlined" into the selection. But that also mean we have to be careful
+  //  of the order in which we pick fragments to expand. Say we have:
+  //  ```graphql
+  //   query {
+  //      ...F1
+  //   }
+  //
+  //   fragment F1 {
+  //     a { ...F2 }
+  //     b { ...F2 }
+  //   }
+  //
+  //   fragment F2 {
+  //      // something
+  //   }
+  //  ```
+  //  then at this point where we've only counted usages in the query selection, `usages` will be
+  //  `{ F1: 1, F2: 0 }`. But we do not want to expand _both_ F1 and F2. Instead, we want to expand
+  //  F1 first, and then realize that this increases F2 usages to 2, which means we stop there and keep F2.
+  //  Generalizing this, it means we want to first pick up fragments to expand that are _not_ used by any
+  //  other fragments that may be expanded.
+  const reverseDependencies = computeFragmentsDependents(fragments);
+  // We'll add to `toExpand` fragment we will definitively expand.
+  const toExpand = new Set<string>;
+  let shouldContinue = true;
+  while (shouldContinue) {
+    // We'll do an iteration, but if we make no progress, we won't continue (we don't want to loop forever).
+    shouldContinue = false;
+    clearKeptFragments(usages, fragments, minUsagesToOptimize);
+    for (const name of mapKeys(usages)) {
+      // Note that we modify `usages` as we iterate it, so 1) we use `mapKeys` above which copy into a list and 2)
+      // we get the `count` manually instead of relying on (possibly outdated) entries.
+      const count = usages.get(name)!;
+      // A unused fragment is not technically expanded, it is just removed and we can ignore for now (it's count
+      // count increase later but ...).
+      if (count === 0) {
+        continue;
+      }
 
-    const usages = new Map<string, number>();
-    optimizedSelection.collectUsedFragmentNames(usages);
-    for (const fragment of fragments.names()) {
-      if (!usages.has(fragment)) {
-        usages.set(fragment, 0);
+      // If we find a fragment to keep, it means some fragment we expanded earlier in this iteration bump this
+      // one count. We unsure `shouldContinue` is set so `clearKeptFragments` is called again, but let that
+      // method deal with it otherwise.
+      if (count >= minUsagesToOptimize) {
+        shouldContinue = true;
+        break;
       }
-    }
 
-    // We re-expand any fragments that is used less than our minimum. Optimizing all fragments to potentially
-    // re-expand some is not entirely optimal, but it's simple and probably don't matter too much in practice
-    // (we only call this optimization on the final computed query plan, so not a very hot path; plus in most
-    // cases we won't even reach that point either because there is no fragment, or none will have been
-    // optimized away so we'll exit above). We can optimize later if this show up in profiling though.
-    //
-    // Also note `toDeoptimize` will always contains the unused fragments, which will allow `expandFragments`
-    // to remove them from the listed fragments in `optimizedSelection` (here again, this could make use call
-    // `expandFragments` on _only_ unused fragments and that case could be dealt with more efficiently, but
-    // probably not noticeable in practice so ...).
-    const toDeoptimize = mapEntries(usages).filter(([_, count]) => count < minUsagesToOptimize).map(([name]) => name);
-
-    if (toDeoptimize.length > 0) {
-      const newFragments = optimizedSelection.fragments?.without(toDeoptimize);
-      optimizedSelection = optimizedSelection.expandFragments(toDeoptimize, newFragments);
-      // Expanding fragments could create some "inefficiencies" that we wouldn't have if we hadn't re-optimized
-      // the fragments to de-optimize it later, so we do a final "trim" pass to remove those.
-      optimizedSelection = optimizedSelection.trimUnsatisfiableBranches(optimizedSelection.parentType);
+      const fragmentsUsingName = reverseDependencies.get(name);
+      if (!fragmentsUsingName || [...fragmentsUsingName].every((fragName) => toExpand.has(fragName) || !usages.get(fragName))) {
+        // This fragment is not used enough, and is only used by fragments we keep, so we
+        // are guaranteed that expanding another fragment will not increase its usage. So
+        // we definitively expand it.
+        toExpand.add(name);
+        usages.delete(name);
+
+        // We've added to `toExpand`, so it's worth redoing another iteration
+        // after that to see if something changes.
+        shouldContinue = true;
+
+        // Now that we expand it, we should bump the usage for every fragment it uses.
+        const nameUsages = fragments.get(name)!.fragmentUsages();
+        for (const [otherName, otherCount] of nameUsages.entries()) {
+          const prev = usages.get(otherName);
+          // Note that if `otherName` is not part of usages, it means it's a fragment we
+          // already decided to keep/expand, so we just ignore it.
+          if (prev !== undefined) {
+            usages.set(otherName, prev + count * otherCount);
+          }
+        }
+      }
     }
+  }
 
-    return new Operation(this.schema, this.rootKind, optimizedSelection, this.variableDefinitions, this.name);
+  // Finally, we know that to expand, which is `toExpand` plus whatever remains in `usage` (typically
+  // genuinely unused fragments).
+  for (const name of usages.keys()) {
+    toExpand.add(name);
   }
 
-  expandAllFragments(): Operation {
-    const expandedSelections = this.selectionSet.expandAllFragments();
-    if (expandedSelections === this.selectionSet) {
+  return toExpand.size === 0 ? fragments : fragments.filter((f) => !toExpand.has(f.name));
+}
+
+// TODO Operations can also have directives
+export class Operation {
+  constructor(
+    readonly schema: Schema,
+    readonly rootKind: SchemaRootKind,
+    readonly selectionSet: SelectionSet,
+    readonly variableDefinitions: VariableDefinitions,
+    readonly fragments?: NamedFragments,
+    readonly name?: string) {
+  }
+
+  // Returns a copy of this operation with the provided updated selection set.
+  // Note that this method assumes that the existing `this.fragments` is still appropriate.
+  private withUpdatedSelectionSet(newSelectionSet: SelectionSet): Operation {
+    if (this.selectionSet === newSelectionSet) {
       return this;
     }
 
     return new Operation(
       this.schema,
       this.rootKind,
-      expandedSelections,
+      newSelectionSet,
       this.variableDefinitions,
+      this.fragments,
       this.name
     );
   }
 
-  trimUnsatisfiableBranches(): Operation {
-    const trimmedSelections = this.selectionSet.trimUnsatisfiableBranches(this.selectionSet.parentType);
-    if (trimmedSelections === this.selectionSet) {
+  // Returns a copy of this operation with the provided updated selection set and fragments.
+  private withUpdatedSelectionSetAndFragments(newSelectionSet: SelectionSet, newFragments: NamedFragments | undefined): Operation {
+    if (this.selectionSet === newSelectionSet && newFragments === this.fragments) {
       return this;
     }
 
     return new Operation(
       this.schema,
       this.rootKind,
-      trimmedSelections,
+      newSelectionSet,
       this.variableDefinitions,
+      newFragments,
       this.name
     );
   }
 
+  optimize(fragments?: NamedFragments, minUsagesToOptimize: number = 2): Operation {
+    assert(minUsagesToOptimize >= 1, `Expected 'minUsagesToOptimize' to be at least 1, but got ${minUsagesToOptimize}`)
+    if (!fragments || fragments.isEmpty()) {
+      return this;
+    }
+
+    let optimizedSelection = this.selectionSet.optimize(fragments);
+    if (optimizedSelection === this.selectionSet) {
+      return this;
+    }
+
+    let finalFragments = computeFragmentsToKeep(optimizedSelection, fragments, minUsagesToOptimize);
+
+    // If there is fragment usages and we're not keeping all fragments, we need to expand fragments.
+    if (finalFragments !== null && finalFragments?.size !== fragments.size) {
+      // Note that optimizing all fragments to potentially re-expand some is not entirely optimal, but it's unclear
+      // how to do otherwise, and it probably don't matter too much in practice (we only call this optimization
+      // on the final computed query plan, so not a very hot path; plus in most cases we won't even reach that
+      // point either because there is no fragment, or none will have been optimized away so we'll exit above).
+      optimizedSelection = optimizedSelection.expandFragments(finalFragments);
+
+      // Expanding fragments could create some "inefficiencies" that we wouldn't have if we hadn't re-optimized
+      // the fragments to de-optimize it later, so we do a final "normalize" pass to remove those.
+      optimizedSelection = optimizedSelection.normalize({ parentType: optimizedSelection.parentType });
+
+      // And if we've expanded some fragments but kept others, then it's not 100% impossible that some
+      // fragment was used multiple times in some expanded fragment(s), but that post-expansion all of
+      // it's usages are "dead" branches that are removed by the final `normalize`. In that case though,
+      // we need to ensure we don't include the now-unused fragment in the final list of fragments.
+      // TODO: remark that the same reasoning could leave a single instance of a fragment usage, so if
+      // we really really want to never have less than `minUsagesToOptimize`, we could do some loop of
+      // `expand then normalize` unless all fragments are provably used enough. We don't bother, because
+      // leaving this is not a huge deal and it's not worth the complexity, but it could be that we can
+      // refactor all this later to avoid this case without additional complexity.
+      if (finalFragments) {
+        const usages = new Map<string, number>();
+        optimizedSelection.collectUsedFragmentNames(usages);
+        finalFragments = finalFragments.filter((f) => (usages.get(f.name) ?? 0) > 0);
+      }
+    }
+
+    return this.withUpdatedSelectionSetAndFragments(optimizedSelection, finalFragments ?? undefined);
+  }
+
+  expandAllFragments(): Operation {
+    // We clear up the fragments since we've expanded all.
+    // Also note that expanding fragment usually generate unecessary fragments/inefficient selections, so it
+    // basically always make sense to normalize afterwards. Besides, fragment reuse (done by `optimize`) rely
+    // on the fact that its input is normalized to work properly, so all the more reason to do it here.
+    const expanded = this.selectionSet.expandFragments();
+    return this.withUpdatedSelectionSetAndFragments(expanded.normalize({ parentType: expanded.parentType }), undefined);
+  }
+
+  normalize(): Operation {
+    return this.withUpdatedSelectionSet(this.selectionSet.normalize({ parentType: this.selectionSet.parentType }));
+  }
+
   /**
    * Returns this operation but potentially modified so all/some of the @defer applications have been removed.
    *
@@ -786,14 +964,7 @@ export class Operation {
    * applications are removed.
    */
   withoutDefer(labelsToRemove?: Set<string>): Operation {
-    // If we have named fragments, we should be looking inside those and either expand those having @defer or,
-    // probably better, replace them with a verison without @defer. But as we currently only call this method
-    // after `expandAllFragments`, we'll implement this when/if we need it.
-    assert(!this.selectionSet.fragments || this.selectionSet.fragments.isEmpty(), 'Removing @defer currently only work on "expanded" selections (no named fragments)');
-    const updated = this.selectionSet.withoutDefer(labelsToRemove);
-    return updated == this.selectionSet
-      ? this
-      : new Operation(this.schema, this.rootKind, updated, this.variableDefinitions, this.name);
+    return this.withUpdatedSelectionSet(this.selectionSet.withoutDefer(labelsToRemove));
   }
 
   /**
@@ -815,15 +986,11 @@ export class Operation {
     assignedDeferLabels: Set<string>,
     deferConditions: SetMultiMap<string, string>,
   } {
-    // Similar comment than in `withoutDefer`
-    assert(!this.selectionSet.fragments || this.selectionSet.fragments.isEmpty(), 'Assigning @defer lables currently only work on "expanded" selections (no named fragments)');
-
     const normalizer = new DeferNormalizer();
     const { hasDefers, hasNonLabelledOrConditionalDefers } = normalizer.init(this.selectionSet);
     let updatedOperation: Operation = this;
     if (hasNonLabelledOrConditionalDefers) {
-      const updated = this.selectionSet.withNormalizedDefer(normalizer);
-      updatedOperation = new Operation(this.schema, this.rootKind, updated, this.variableDefinitions, this.name);
+      updatedOperation = this.withUpdatedSelectionSet(this.selectionSet.withNormalizedDefer(normalizer));
     }
     return {
       operation: updatedOperation,
@@ -844,14 +1011,22 @@ export class Operation {
   }
 
   toString(expandFragments: boolean = false, prettyPrint: boolean = true): string {
-    return this.selectionSet.toOperationString(this.rootKind, this.variableDefinitions, this.name, expandFragments, prettyPrint);
+    return this.selectionSet.toOperationString(this.rootKind, this.variableDefinitions, this.fragments, this.name, expandFragments, prettyPrint);
   }
 }
 
+export type FragmentRestrictionAtType = { selectionSet: SelectionSet, validator?: FieldsConflictValidator };
+
 export class NamedFragmentDefinition extends DirectiveTargetElement<NamedFragmentDefinition> {
   private _selectionSet: SelectionSet | undefined;
 
-  private readonly selectionSetsAtTypesCache = new Map<string, SelectionSet>();
+  // Lazily computed cache of the expanded selection set.
+  private _expandedSelectionSet: SelectionSet | undefined;
+
+  private _fragmentUsages: Map<string, number> | undefined;
+  private _includedFragmentNames: Set<string> | undefined;
+
+  private readonly expandedSelectionSetsAtTypesCache = new Map<string, FragmentRestrictionAtType>();
 
   constructor(
     schema: Schema,
@@ -876,12 +1051,31 @@ export class NamedFragmentDefinition extends DirectiveTargetElement<NamedFragmen
     return this._selectionSet;
   }
 
+  expandedSelectionSet(): SelectionSet {
+    if (!this._expandedSelectionSet) {
+      this._expandedSelectionSet = this.selectionSet.expandFragments().normalize({ parentType: this.typeCondition });
+    }
+    return this._expandedSelectionSet;
+  }
+
   withUpdatedSelectionSet(newSelectionSet: SelectionSet): NamedFragmentDefinition {
     return new NamedFragmentDefinition(this.schema(), this.name, this.typeCondition).setSelectionSet(newSelectionSet);
   }
 
+  fragmentUsages(): ReadonlyMap<string, number> {
+    if (!this._fragmentUsages) {
+      this._fragmentUsages = new Map();
+      this.selectionSet.collectUsedFragmentNames(this._fragmentUsages);
+    }
+    return this._fragmentUsages;
+  }
+
   collectUsedFragmentNames(collector: Map<string, number>) {
-    this.selectionSet.collectUsedFragmentNames(collector);
+    const usages = this.fragmentUsages();
+    for (const [name, count] of usages.entries()) {
+      const prevCount = collector.get(name);
+      collector.set(name, prevCount ? prevCount + count : count);
+    }
   }
 
   toFragmentDefinitionNode() : FragmentDefinitionNode {
@@ -903,17 +1097,58 @@ export class NamedFragmentDefinition extends DirectiveTargetElement<NamedFragmen
   }
 
   /**
-   * Whether this fragment may apply at the provided type, that is if its type condition runtime types intersects with the
-   * runtimes of the provided type.
+   * Whether this fragment may apply _directly_ at the provided type, meaning that the fragment sub-selection
+   * could be put directly inside a `... on type {}` inline fragment (_without_ re-adding the fragment condition
+   * that is), and both be valid and not "lose context".
+   *
+   * For that to be true, we need one of this to be true:
+   * 1. the runtime types of the fragment condition must be at least as general as those of the provided `type`.
+   *    Otherwise, putting it at `type` without its condition would "generalize" more than fragment meant to (and
+   *    so we'd "lose context"
+   * 2. either `type` and `this.typeCondition` are equal, or `type` is an object or `this.typeCondition` is a union
+   *    The idea is that, assuming our 1st point, then:
+   *    - if both are equal, things works trivially.
+   *    - if `type` is an object, `this.typeCondition` is either the same object, or a union/interface for which
+   *      type is a valid runtime. In all case, anything valid on `this.typeCondition` would apply to `type` too.
+   *    - if `this.typeCondition` is a union, then it's selection can only have fragments on object types at top-level
+   *      (save for `__typename`), and all those selection will work at `type` too.
+   *    But in any other case, both types must be abstract (if `this.typeCondition` is an object, the 1st condition
+   *    imply `type` can only be the same type) and we're in one of:
+   *    - `type` and `this.typeCondition` are both different interfaces (that intersect but are different).
+   *    - `type` is aunion and `this.typeCondition` an interface.
+   *       And in both cases, the selection of the fragment may selection an interface that is not valid at `type` (if `type`
+   *       is a union because a direct field is always wrong, and if `type` is another interface because that interface may
+   *       not have that particular field).
    *
    * @param type - the type at which we're looking at applying the fragment
    */
-  canApplyAtType(type: CompositeType): boolean {
-    return sameType(type, this.typeCondition) || runtimeTypesIntersects(type, this.typeCondition);
+  canApplyDirectlyAtType(type: CompositeType): boolean {
+    if (sameType(type, this.typeCondition)) {
+      return true;
+    }
+
+    // No point computing runtime types if the condition is an object (it can never cover all of
+    // the runtimes of `type` unless it's the same type, which is already covered).
+    if (!isAbstractType(this.typeCondition)) {
+      return false;
+    }
+
+    const conditionRuntimes = possibleRuntimeTypes(this.typeCondition);
+    const typeRuntimes = possibleRuntimeTypes(type);
+    // The fragment condition must be at least as general as the provided type (in other words, all of the
+    // runtimes of `type` must be in `conditionRuntimes`).
+    // Note: the `length` test is technically redundant, but just avoid the more costly sub-set check if we
+    // can cheaply show it's unnecessary.
+    if (conditionRuntimes.length < typeRuntimes.length
+      || !typeRuntimes.every((t1) => conditionRuntimes.some((t2) => sameType(t1, t2)))) {
+      return false;
+    }
+
+    return isObjectType(type) || isUnionType(this.typeCondition);
   }
 
   /**
-   * This methods *assumes* that `this.canApplyAtType(type)` is `true` (and may crash if this is not true), and returns
+   * This methods *assumes* that `this.canApplyDirectlyAtType(type)` is `true` (and may crash if this is not true), and returns
    * a version fo this named fragment selection set that corresponds to the "expansion" of this named fragment at `type`
    *
    * The overall idea here is that if we have an interface I with 2 implementations T1 and T2, and we have a fragment like:
@@ -930,32 +1165,63 @@ export class NamedFragmentDefinition extends DirectiveTargetElement<NamedFragmen
    * then if the current type is `T1`, then all we care about matching for this fragment is the `... on T1` part, and this method gives
    * us that part.
    */
-  selectionSetAtType(type: CompositeType): SelectionSet {
-    // First, if the candidate condition is an object or is the type passed, then there isn't any additional restriction to do.
+  expandedSelectionSetAtType(type: CompositeType): FragmentRestrictionAtType {
+    // First, if the candidate condition is an object or is the type passed, then there isn't any restriction to do.
     if (sameType(type, this.typeCondition) || isObjectType(this.typeCondition)) {
-      return this.selectionSet;
+      return { selectionSet: this.expandedSelectionSet() };
+    }
+
+    let cached = this.expandedSelectionSetsAtTypesCache.get(type.name);
+    if (!cached) {
+      cached = this.computeExpandedSelectionSetAtType(type);
+      this.expandedSelectionSetsAtTypesCache.set(type.name, cached);
+    }
+    return cached;
+  }
+
+  private computeExpandedSelectionSetAtType(type: CompositeType): FragmentRestrictionAtType {
+    const expandedSelectionSet = this.expandedSelectionSet();
+    // Note that what we want is get any simplification coming from normalizing at `type`, but any such simplication
+    // stops as soon as we traverse a field, so no point in being recursive.
+    const selectionSet = expandedSelectionSet.normalize({ parentType: type, recursive: false });
+
+    // Note that `trimmed` is the difference of 2 selections that may not have been normalized on the same parent type,
+    // so in practice, it is possible that `trimmed` contains some of the selections that `selectionSet` contains, but
+    // that they have been simplified in `selectionSet` in such a way that the `minus` call does not see it. However,
+    // it is not trivial to deal with this, and it is fine given that we use trimmed to create the validator because
+    // we know the non-trimmed parts cannot create field conflict issues so we're trying to build a smaller validator,
+    // but it's ok if trimmed is not as small as it theoretically can be.
+    const trimmed = expandedSelectionSet.minus(selectionSet);
+    const validator = trimmed.isEmpty() ? undefined : FieldsConflictValidator.build(trimmed);
+    return { selectionSet, validator };
+  }
+
+  /**
+   * Whether this fragment fully includes `otherFragment`.
+   * Note that this is slightly different from `this` "using" `otherFragment` in that this essentially checks
+   * if the full selection set of `otherFragment` is contained by `this`, so this only look at "top-level" usages.
+   *
+   * Note that this is guaranteed to return `false` if passed `this` name.
+   */
+  includes(otherFragment: string): boolean {
+    if (this.name === otherFragment) {
+      return false;
     }
 
-    // We should not call `trimUnsatisfiableBranches` where `type` is an abstract type (`interface` or `union`) as it currently could
-    // create an invalid selection set (and throw down the line). In theory, when `type` is an abstract type, we could look at the
-    // intersection of its runtime types with those of `this.typeCondition`, call `trimUnsatisfiableBranches` for each of the resulting
-    // object types, and merge all those selection sets, and this "may" result in a smaller selection at times. This is a bit complex
-    // and costly to do however, so we just return the selection unchanged for now, which is always valid but simply may not be absolutely
-    // optimal.
-    // Concretely, this means that there may be corner cases where a named fragment could be reused but isn't, but waiting on finding
-    // concrete examples where this matter to decide if it's worth the complexity.
-    if (!isObjectType(type)) {
-      return this.selectionSet;
+    if (!this._includedFragmentNames) {
+      this._includedFragmentNames = this.computeIncludedFragmentNames();
     }
+    return this._includedFragmentNames.has(otherFragment);
+  }
 
-    let selectionSet = this.selectionSetsAtTypesCache.get(type.name);
-    if (!selectionSet) {
-      // Note that all we want is removing any top-level branches that don't apply due to the current type. There is no point
-      // in going recursive however: any simplification due to `type` stops as soon as we traverse a field. And so we don't bother. 
-      selectionSet = this.selectionSet.trimUnsatisfiableBranches(type, { recursive: false });
-      this.selectionSetsAtTypesCache.set(type.name, selectionSet);
+  private computeIncludedFragmentNames(): Set<string> {
+    const included = new Set<string>();
+    for (const selection of this.selectionSet.selections()) {
+      if (selection instanceof FragmentSpreadSelection) {
+        included.add(selection.namedFragment.name);
+      }
     }
-    return selectionSet;
+    return included;
   }
 
   toString(indent?: string): string {
@@ -963,11 +1229,16 @@ export class NamedFragmentDefinition extends DirectiveTargetElement<NamedFragmen
   }
 }
 
+
 export class NamedFragments {
   private readonly fragments = new MapWithCachedArrays<string, NamedFragmentDefinition>();
 
   isEmpty(): boolean {
-    return this.fragments.size === 0;
+    return this.size === 0;
+  }
+
+  get size(): number {
+    return this.fragments.size;
   }
 
   names(): readonly string[] {
@@ -987,28 +1258,8 @@ export class NamedFragments {
     }
   }
 
-  maybeApplyingAtType(type: CompositeType): NamedFragmentDefinition[] {
-    return this.fragments.values().filter(f => f.canApplyAtType(type));
-  }
-
-  without(names: string[]): NamedFragments | undefined {
-    if (!names.some(n => this.fragments.has(n))) {
-      return this;
-    }
-
-    const newFragments = new NamedFragments();
-    for (const fragment of this.fragments.values()) {
-      if (!names.includes(fragment.name)) {
-        // We want to keep that fragment. But that fragment might use a fragment we
-        // remove, and if so, we need to expand that removed fragment.
-        const updatedSelectionSet = fragment.selectionSet.expandFragments(names, newFragments);
-        const newFragment = updatedSelectionSet === fragment.selectionSet
-          ? fragment
-          : fragment.withUpdatedSelectionSet(updatedSelectionSet);
-        newFragments.add(newFragment);
-      }
-    }
-    return newFragments.isEmpty() ? undefined : newFragments;
+  maybeApplyingDirectlyAtType(type: CompositeType): NamedFragmentDefinition[] {
+    return this.fragments.values().filter(f => f.canApplyDirectlyAtType(type));
   }
 
   get(name: string): NamedFragmentDefinition | undefined {
@@ -1032,47 +1283,44 @@ export class NamedFragments {
   }
 
   /**
-   * This method:
-   * - expands all nested fragments,
-   * - applies the provided mapper to the selection set of the fragments,
-   * - and finally re-fragments the nested fragments.
+   * The mapper is called on every fragment definition (`fragment` argument), but in such a way that if a fragment A uses another fragment B,
+   * then the mapper is guaranteed to be called on B _before_ being called on A. Further, the `newFragments` argument is a new `NamedFragments`
+   * containing all the previously mapped definition (minus those for which the mapper returned `undefined`). So if A uses B (and the mapper
+   * on B do not return undefined), then when mapper is called on A `newFragments` will have the mapped value for B.
    */
-  mapToExpandedSelectionSets(
-    mapper: (selectionSet: SelectionSet) => SelectionSet | undefined,
-    recreateFct: (frag: NamedFragmentDefinition, newSelectionSet: SelectionSet) => NamedFragmentDefinition = (f, s) => f.withUpdatedSelectionSet(s),
+  mapInDependencyOrder(
+    mapper: (fragment: NamedFragmentDefinition, newFragments: NamedFragments) => NamedFragmentDefinition | undefined
   ): NamedFragments | undefined {
-    type FragmentInfo = {
-      original: NamedFragmentDefinition,
-      mappedSelectionSet: SelectionSet,
+    type FragmentDependencies = {
+      fragment: NamedFragmentDefinition,
       dependsOn: string[],
     };
-    const fragmentsMap = new Map<string, FragmentInfo>();
-    const removedFragments = new Set<string>();
+    const fragmentsMap = new Map<string, FragmentDependencies>();
     for (const fragment of this.definitions()) {
-      const mappedSelectionSet = mapper(fragment.selectionSet.expandAllFragments().trimUnsatisfiableBranches(fragment.typeCondition));
-      if (!mappedSelectionSet) {
-        removedFragments.add(fragment.name);
-        continue;
-      }
-
-      const otherFragmentsUsages = new Map<string, number>();
-      fragment.collectUsedFragmentNames(otherFragmentsUsages);
       fragmentsMap.set(fragment.name, {
-        original: fragment,
-        mappedSelectionSet,
-        dependsOn: Array.from(otherFragmentsUsages.keys()),
+        fragment,
+        dependsOn: Array.from(fragment.fragmentUsages().keys()),
       });
     }
 
+    const removedFragments = new Set<string>();
     const mappedFragments = new NamedFragments();
     while (fragmentsMap.size > 0) {
       for (const [name, info] of fragmentsMap) {
         // Note that graphQL specifies that named fragments cannot have cycles (https://spec.graphql.org/draft/#sec-Fragment-spreads-must-not-form-cycles)
         // and so we're guaranteed that on every iteration, at least one element of the map is removed (so the `while` loop will terminate).
         if (info.dependsOn.every((n) => mappedFragments.has(n) || removedFragments.has(n))) {
-          const reoptimizedSelectionSet = info.mappedSelectionSet.optimize(mappedFragments);
-          mappedFragments.add(recreateFct(info.original, reoptimizedSelectionSet));
+          const mapped = mapper(info.fragment, mappedFragments);
           fragmentsMap.delete(name);
+          if (!mapped) {
+            removedFragments.add(name);
+          } else {
+            mappedFragments.add(mapped);
+          }
+          // We just deleted from `fragmentsMap` so continuing our current `for` iteration is dangerous,
+          // so we break to the `while` loop (besides, there is no reason why continuing the inner iteration
+          // would be better than restarting it right away).
+          break;
         }
       }
     }
@@ -1080,20 +1328,58 @@ export class NamedFragments {
     return mappedFragments.isEmpty() ? undefined : mappedFragments;
   }
 
+  /**
+   * This method:
+   * - expands all nested fragments,
+   * - applies the provided mapper to the selection set of the fragments,
+   * - and finally re-fragments the nested fragments.
+   */
+  mapToExpandedSelectionSets(
+    mapper: (selectionSet: SelectionSet) => SelectionSet | undefined,
+  ): NamedFragments | undefined {
+    return this.mapInDependencyOrder((fragment, newFragments) => {
+      const mappedSelectionSet = mapper(fragment.selectionSet.expandFragments().normalize({ parentType: fragment.typeCondition }));
+      if (!mappedSelectionSet) {
+        return undefined;
+      }
+      const reoptimizedSelectionSet = mappedSelectionSet.optimize(newFragments);
+      return fragment.withUpdatedSelectionSet(reoptimizedSelectionSet);
+    });
+  }
+
   rebaseOn(schema: Schema): NamedFragments | undefined {
-    return this.mapToExpandedSelectionSets(
-      (s) => {
-        const rebasedType = schema.type(s.parentType.name);
-        try {
-          return rebasedType && isCompositeType(rebasedType) ? s.rebaseOn(rebasedType) : undefined;
-        } catch (e) {
-          // This means we cannot rebase this selection on the schema and thus cannot reuse that fragment on that
-          // particular schema.
+    return this.mapInDependencyOrder((fragment, newFragments) => {
+      const rebasedType = schema.type(fragment.selectionSet.parentType.name);
+      try {
+        if (!rebasedType || !isCompositeType(rebasedType)) {
           return undefined;
         }
-      },
-      (orig, newSelection) => new NamedFragmentDefinition(schema, orig.name, newSelection.parentType).setSelectionSet(newSelection),
-    );
+
+        const rebasedSelection = fragment.selectionSet.rebaseOn(rebasedType, newFragments);
+        return new NamedFragmentDefinition(schema, fragment.name, rebasedType).setSelectionSet(rebasedSelection);
+      } catch (e) {
+        // This means we cannot rebase this selection on the schema and thus cannot reuse that fragment on that
+        // particular schema.
+        return undefined;
+      }
+    });
+  }
+
+  filter(predicate: (fragment: NamedFragmentDefinition) => boolean): NamedFragments | undefined {
+    return this.mapInDependencyOrder((fragment, newFragments) => {
+      if (predicate(fragment)) {
+        // We want to keep that fragment. But that fragment might use a fragment we remove, and if so,
+        // we need to expand that removed fragment. Note that because we're running in
+        // dependency order, we know that `newFragments` will have every fragments that should be
+        // kept/not expanded.
+        const updatedSelectionSet = fragment.selectionSet.expandFragments(newFragments);
+        return updatedSelectionSet === fragment.selectionSet
+          ? fragment
+          : fragment.withUpdatedSelectionSet(updatedSelectionSet);
+      } else {
+        return undefined;
+      }
+    });
   }
 
   validate(variableDefinitions: VariableDefinitions) {
@@ -1173,6 +1459,16 @@ class DeferNormalizer {
   }
 }
 
+export enum ContainsResult {
+  // Note: enum values are numbers in the end, and 0 means false in JS, so we should keep `NOT_CONTAINED` first 
+  // so that using the result of `contains` as a boolean works.
+  NOT_CONTAINED,
+  STRICTLY_CONTAINED,
+  EQUAL,
+}
+
+export type CollectedFieldsInSet = { path: string[], field: FieldSelection }[];
+
 export class SelectionSet {
   private readonly _keyedSelections: Map<string, Selection>;
   private readonly _selections: readonly Selection[];
@@ -1180,7 +1476,6 @@ export class SelectionSet {
   constructor(
     readonly parentType: CompositeType,
     keyedSelections: Map<string, Selection> = new Map(),
-    readonly fragments?: NamedFragments,
   ) {
     this._keyedSelections = keyedSelections;
     this._selections = mapValues(keyedSelections);
@@ -1204,7 +1499,7 @@ export class SelectionSet {
     return this._keyedSelections.has(typenameFieldName);
   }
 
-  fieldsInSet(): { path: string[], field: FieldSelection }[] {
+  fieldsInSet(): CollectedFieldsInSet {
     const fields = new Array<{ path: string[], field: FieldSelection }>();
     for (const selection of this.selections()) {
       if (selection.kind === 'FieldSelection') {
@@ -1220,6 +1515,22 @@ export class SelectionSet {
     return fields;
   }
 
+  fieldsByResponseName(): MultiMap<string, FieldSelection> {
+    const byResponseName = new MultiMap<string, FieldSelection>();
+    this.collectFieldsByResponseName(byResponseName);
+    return byResponseName;
+  }
+
+  private collectFieldsByResponseName(collector: MultiMap<string, FieldSelection>) {
+    for (const selection of this.selections()) {
+      if (selection.kind === 'FieldSelection') {
+        collector.add(selection.element.responseName(), selection);
+      } else {
+        selection.selectionSet.collectFieldsByResponseName(collector);
+      }
+    }
+  }
+
   usedVariables(): Variables {
     const collector = new VariableCollector();
     this.collectVariables(collector);
@@ -1234,7 +1545,7 @@ export class SelectionSet {
 
   collectUsedFragmentNames(collector: Map<string, number>) {
     for (const selection of this.selections()) {
-        selection.collectUsedFragmentNames(collector);
+      selection.collectUsedFragmentNames(collector);
     }
   }
 
@@ -1259,44 +1570,104 @@ export class SelectionSet {
     // With that, `optimizeSelections` will correctly match on the `on Query` fragment; after which
     // we can unpack the final result.
     const wrapped = new InlineFragmentSelection(new FragmentElement(this.parentType, this.parentType), this);
-    const optimized = wrapped.optimize(fragments);
+    const validator = FieldsConflictValidator.build(this);
+    const optimized = wrapped.optimize(fragments, validator);
 
     // Now, it's possible we matched a full fragment, in which case `optimized` will be just the named fragment,
     // and in that case we return a singleton selection with just that. Otherwise, it's our wrapping inline fragment
     // with the sub-selections optimized, and we just return that subselection.
     return optimized instanceof FragmentSpreadSelection
-      ? selectionSetOf(this.parentType, optimized, fragments)
+      ? selectionSetOf(this.parentType, optimized)
       : optimized.selectionSet;
   }
 
   // Tries to match fragments inside each selections of this selection set, and this recursively. However, note that this
   // may not match fragments that would apply at top-level, so you should usually use `optimize` instead (this exists mostly
   // for the recursion).
-  optimizeSelections(fragments: NamedFragments): SelectionSet {
-    // Handling the case where the selection may alreayd have some fragments adds complexity,
-    // not only because we need to deal with merging new and existing fragments, but also because
-    // things get weird if some fragment names are in common to both. Since we currently only care
-    // about this method when optimizing subgraph fetch selections and those are initially created
-    // without any fragments, we don't bother handling this more complex case.
-    assert(!this.fragments || this.fragments.isEmpty(), `Should not be called on selection that already has named fragments, but got ${this.fragments}`)
-
-    return this.lazyMap((selection) => selection.optimize(fragments), { fragments });
+  optimizeSelections(fragments: NamedFragments, validator: FieldsConflictValidator): SelectionSet {
+    return this.lazyMap((selection) => selection.optimize(fragments, validator));
   }
 
-  expandAllFragments(): SelectionSet {
-    return this.lazyMap((selection) => selection.expandAllFragments(), { fragments: null });
-  }
-
-  expandFragments(names: string[], updatedFragments: NamedFragments | undefined): SelectionSet {
-    if (names.length === 0) {
-      return this;
-    }
-
-    return this.lazyMap((selection) => selection.expandFragments(names, updatedFragments), { fragments: updatedFragments ?? null });
+  expandFragments(updatedFragments?: NamedFragments): SelectionSet {
+    return this.lazyMap((selection) => selection.expandFragments(updatedFragments));
   }
 
-  trimUnsatisfiableBranches(parentType: CompositeType, options?: { recursive? : boolean }): SelectionSet {
-    return this.lazyMap((selection) => selection.trimUnsatisfiableBranches(parentType, options), { parentType });
+  /**
+   * Applies some normalization rules to this selection set in the context of the provided `parentType`. 
+   *
+   * Normalization mostly removes unecessary/redundant inline fragments, so that for instance, with
+   * schema:
+   * ```graphql
+   *   type Query {
+   *     t1: T1
+   *     i: I
+   *   }
+   *
+   *   interface I {
+   *     id: ID!
+   *   }
+   *
+   *   type T1 implements I {
+   *     id: ID!
+   *     v1: Int
+   *   }
+   *
+   *   type T2 implements I {
+   *     id: ID!
+   *     v2: Int
+   *   }
+   * ```
+   *
+   * ```
+   * normalize({
+   *   t1 {
+   *     ... on I {
+   *       id
+   *     }
+   *   }
+   *   i {
+   *     ... on T1 {
+   *       ... on I {
+   *          ... on T1 {
+   *            v1
+   *          }
+   *          ... on T2 {
+   *            v2
+   *          }
+   *       }
+   *     }
+   *     ... on T2 {
+   *       ... on I {
+   *         id
+   *       }
+   *     }
+   *   }
+   * }) === {
+   *   t1 {
+   *     id
+   *   }
+   *   i {
+   *     ... on T1 {
+   *       v1
+   *     }
+   *     ... on T2 {
+   *       id
+   *     }
+   *   }
+   * }
+   * ```
+   *
+   * For this operation to be valid (to not throw), `parentType` must be such this selection set would
+   * be valid as a subselection of an inline fragment `... on parentType { <this selection set> }` (and
+   * so `this.normalize(this.parentType)` is always valid and useful, but it is possible to pass a `parentType`
+   * that is more "restrictive" than the selection current parent type).
+   *
+   * Passing the option `recursive == false` makes the normalization only apply at the top-level, removing
+   * any unecessary top-level inline fragments, possibly multiple layers of them, but we never recurse
+   * inside the sub-selection of an selection that is not removed by the normalization.
+   */
+  normalize({ parentType, recursive }: { parentType: CompositeType, recursive? : boolean }): SelectionSet {
+    return this.lazyMap((selection) => selection.normalize({ parentType, recursive }), { parentType });
   }
 
   /**
@@ -1310,14 +1681,10 @@ export class SelectionSet {
   lazyMap(
     mapper: (selection: Selection) => Selection | readonly Selection[] | SelectionSet | undefined,
     options?: {
-      fragments?: NamedFragments | null,
       parentType?: CompositeType,
     }
   ): SelectionSet {
     const selections = this.selections();
-    const updatedFragments = options?.fragments;
-    const newFragments = updatedFragments === undefined ? this.fragments : (updatedFragments ?? undefined);
-
     let updatedSelections: SelectionSetUpdates | undefined = undefined;
     for (let i = 0; i < selections.length; i++) {
       const selection = selections[i];
@@ -1333,22 +1700,16 @@ export class SelectionSet {
       }
     }
     if (!updatedSelections) {
-      return this.withUpdatedFragments(newFragments);
+      return this;
     }
-    return updatedSelections.toSelectionSet(options?.parentType ?? this.parentType, newFragments);
-  }
-
-  private withUpdatedFragments(newFragments: NamedFragments | undefined): SelectionSet {
-    return this.fragments === newFragments ? this : new SelectionSet(this.parentType, this._keyedSelections, newFragments);
+    return updatedSelections.toSelectionSet(options?.parentType ?? this.parentType);
   }
 
   withoutDefer(labelsToRemove?: Set<string>): SelectionSet {
-    assert(!this.fragments, 'Not yet supported');
     return this.lazyMap((selection) => selection.withoutDefer(labelsToRemove));
   }
 
   withNormalizedDefer(normalizer: DeferNormalizer): SelectionSet {
-    assert(!this.fragments, 'Not yet supported');
     return this.lazyMap((selection) => selection.withNormalizedDefer(normalizer));
   }
 
@@ -1357,31 +1718,40 @@ export class SelectionSet {
   }
 
   /**
-   * Returns the selection select from filtering out any selection that does not match the provided predicate.
+   * Returns the selection set resulting from filtering out any of the top-level selection that does not match the provided predicate.
    *
-   * Please that this method will expand *ALL* fragments as the result of applying it's filtering. You should
-   * call `optimize` on the result if you want to re-apply some fragments.
+   * Please that this method does not recurse within sub-selections.
    */
   filter(predicate: (selection: Selection) => boolean): SelectionSet {
-    return this.lazyMap((selection) => selection.filter(predicate));
+    return this.lazyMap((selection) => predicate(selection) ? selection : undefined);
+  }
+
+  /**
+   * Returns the selection set resulting from "recursively" filtering any selection that does not match the provided predicate.
+   * This method calls `predicate` on every selection of the selection set, not just top-level ones, and apply a "depth-first"
+   * strategy, meaning that when the predicate is call on a given selection, the it is guaranteed that filtering has happened
+   * on all the selections of its sub-selection.
+   */
+  filterRecursiveDepthFirst(predicate: (selection: Selection) => boolean): SelectionSet {
+    return this.lazyMap((selection) => selection.filterRecursiveDepthFirst(predicate));
   }
 
   withoutEmptyBranches(): SelectionSet | undefined {
-    const updated = this.filter((selection) => selection.selectionSet?.isEmpty() !== true);
+    const updated = this.filterRecursiveDepthFirst((selection) => selection.selectionSet?.isEmpty() !== true);
     return updated.isEmpty() ? undefined : updated;
   }
 
-  rebaseOn(parentType: CompositeType): SelectionSet {
+  rebaseOn(parentType: CompositeType, fragments: NamedFragments | undefined): SelectionSet {
     if (this.parentType === parentType) {
       return this;
     }
 
     const newSelections = new Map<string, Selection>();
     for (const selection of this.selections()) {
-      newSelections.set(selection.key(), selection.rebaseOn(parentType));
+      newSelections.set(selection.key(), selection.rebaseOn(parentType, fragments));
     }
 
-    return new SelectionSet(parentType, newSelections, this.fragments);
+    return new SelectionSet(parentType, newSelections);
   }
 
   equals(that: SelectionSet): boolean {
@@ -1402,165 +1772,24 @@ export class SelectionSet {
     return true;
   }
 
-  private triviallyNestedSelectionsForKey(parentType: CompositeType, key: string): Selection[] {
-    const found: Selection[] = [];
-    for (const selection of this.selections()) {
-      if (selection.isUnecessaryInlineFragment(parentType)) {
-        const selectionForKey = selection.selectionSet._keyedSelections.get(key);
-        if (selectionForKey) {
-          found.push(selectionForKey);
-        }
-        for (const nestedSelection of selection.selectionSet.triviallyNestedSelectionsForKey(parentType, key)) {
-          found.push(nestedSelection);
-        }
-      }
+  contains(that: SelectionSet): ContainsResult {
+    if (that._selections.length > this._selections.length) {
+      return ContainsResult.NOT_CONTAINED;
     }
-    return found;
-  }
-
-  private mergeSameKeySelections(selections: Selection[]): Selection | undefined {
-    if (selections.length === 0) {
-      return undefined;
-    }
-    const first = selections[0];
-    // We know that all the selections passed are for exactly the same element (same "key"). So if it is a
-    // leaf field or a named fragment, then we know that even if we have more than 1 selection, all of them
-    // are the exact same and we can just return the first one. Only if we have a composite field or an
-    // inline fragment do we need to merge the underlying sub-selection (which may differ).
-    if (!first.selectionSet || (first instanceof FragmentSpreadSelection) || selections.length === 1) {
-      return first;
-    }
-    const mergedSubselections = new SelectionSetUpdates();
-    for (const selection of selections) {
-      mergedSubselections.add(selection.selectionSet!);
-    }
-
-    // We know all the `selections` are basically for the same element (same field or same inline fragment),
-    // and we want to return a single selection with the merged selections. There is a subtlety regarding
-    // the parent type of that merged selection however: we cannot safely rely on the parent type of any
-    // of the individual selections, because this can be incorrect. Let's illustrate.
-    // Consider that we have:
-    // ```graphql
-    //   type Query {
-    //     a: A!
-    //   }
-    //
-    //   interface IA1 {
-    //     b: IB1!
-    //   }
-    //
-    //   interface IA2 {
-    //     b: IB2!
-    //   }
-    //
-    //   type A implements IA1 & IA2 {
-    //     b: B!
-    //   }
-    //
-    //   interface IB1 {
-    //     v1: Int!
-    //   }
-    //
-    //   interface IB2 {
-    //     v2: Int!
-    //   }
-    //
-    //   type B implements IB1 & IB2 {
-    //     v1: Int!
-    //     v2: Int!
-    //   }
-    // ```
-    // and suppose that we're trying to check if selection set:
-    //  maybeSuperset = { ... on IA1 { b { v1 } } ... on IA2 { b { v2 } } }  // (parent type A)
-    // contains selection set:
-    //  maybeSubset   = { b { v1 v2 } }                                      // (parent type A)
-    //
-    // In that case, the `contains` method below will call this function with the 2 sub-selections
-    // from `maybeSuperset`, but with the unecessary interface fragment removed (reminder that the
-    // parent type is `A`, so the "casts" into the interfaces are semantically useless).
-    //
-    // And so in that case, the argument to this method will be:
-    //   [ b { v1 } (parent type IA1), b { v2 } (parent type IA2) ]
-    // but then, the sub-selection `{ v1 }` of the 1st value will have parent type IB1,
-    //       and the sub-selection `{ v2 }` of the 2nd value will have parent type IB2,
-    // neither of which work for the merge sub-selection.
-    //
-    // Instead, we want to use as parent type the type of field `b` the parent type of `this`
-    // (which is `maybeSupeset` in our example). Which means that we want to use type `B` for
-    // the sub-selection, which is now guaranteed to work (or `maybeSupergerset` wouldn't have
-    // been valid).
-    //
-    // Long story short, we get that type by rebasing any of the selection element (we use the
-    // first as we have it) on `this.parentType`, which gives use the element we want, and we
-    // use the type of that for the sub-selection.
-
-    if (first.kind === 'FieldSelection') {
-      const rebasedField = first.element.rebaseOn(this.parentType);
-      return new FieldSelection(rebasedField, mergedSubselections.toSelectionSet(rebasedField.baseType() as CompositeType));
-    } else {
-      const rebasedFragment = first.element.rebaseOn(this.parentType);
-      return new InlineFragmentSelection(rebasedFragment, mergedSubselections.toSelectionSet(rebasedFragment.castedType()));
-    }
-  }
-
-  contains(that: SelectionSet): boolean {
-    // Note that we cannot really rely on the number of selections in `this` and `that` to short-cut this method
-    // due to the handling of "trivially nested selections". That is, `this` might have less top-level selections
-    // than `that`, and yet contains a named fragment directly on the parent type that includes everything in `that`.
 
+    let isEqual = true;
     for (const [key, thatSelection] of that._keyedSelections) {
       const thisSelection = this._keyedSelections.get(key);
-      const otherSelections = this.triviallyNestedSelectionsForKey(this.parentType, key);
-      const mergedSelection = this.mergeSameKeySelections([thisSelection].concat(otherSelections).filter(isDefined));
-
-      if (!(mergedSelection && mergedSelection.contains(thatSelection))
-        && !(thatSelection.isUnecessaryInlineFragment(this.parentType) && this.contains(thatSelection.selectionSet))
-      ) {
-        return false
+      const selectionResult = thisSelection?.contains(thatSelection);
+      if (selectionResult === undefined || selectionResult === ContainsResult.NOT_CONTAINED) {
+        return ContainsResult.NOT_CONTAINED;
       }
+      isEqual &&= selectionResult === ContainsResult.EQUAL;
     }
-    return true;
-  }
 
-  // Please note that this method assumes that `candidate.canApplyAtType(parentType) === true` but it is left to the caller to
-  // validate this (`canApplyAtType` is not free, and we want to avoid repeating it multiple times).
-  diffWithNamedFragmentIfContained(candidate: NamedFragmentDefinition, parentType: CompositeType): { contains: boolean, diff?: SelectionSet } {
-    const that = candidate.selectionSetAtType(parentType);
-    // It's possible that while the fragment technically applies at `parentType`, it's "rebasing" on
-    // `parentType` is empty, or contains only `__typename`. For instance, suppose we have
-    // a union `U = A | B | C`, and then a fragment:
-    // ```graphql
-    //   fragment F on U {
-    //     ... on A {
-    //       x
-    //     }
-    //     ... on b {
-    //       y
-    //     }
-    //   }
-    // ```
-    // It is then possible to apply `F` when the parent type is `C`, but this ends up selecting
-    // nothing at all.
-    //
-    // Returning `contains: true` in those cases is, while not 100% incorrect, at least not productive,
-    // and so we skip right away in that case. This is essentially an optimisation.
-    if (that.isEmpty() || (that.selections().length === 1 && that.selections()[0].isTypenameField())) {
-      return { contains: false };
-    }
-
-    if (this.contains(that)) {
-      // One subtlety here is that at "this" sub-selections may already have been optimized with some fragments. It's
-      // usually ok because `candidate` will also use those fragments, but one fragments that `candidate` can never be
-      // using is itself (the `contains` check is fine with this, but it's harder to deal in `minus`). So we expand
-      // the candidate we're currently looking at in "this" to avoid some issues.
-      let updatedThis = this.expandFragments([candidate.name], this.fragments);
-      if (updatedThis !== this) {
-        updatedThis = updatedThis.trimUnsatisfiableBranches(parentType);
-      }
-      const diff = updatedThis.minus(that);
-      return { contains: true, diff: diff.isEmpty() ? undefined : diff };
-    }
-    return { contains: false };
+    return isEqual && that._selections.length === this._selections.length
+      ? ContainsResult.EQUAL
+      : ContainsResult.STRICTLY_CONTAINED;
   }
 
   /**
@@ -1572,29 +1801,38 @@ export class SelectionSet {
 
     for (const [key, thisSelection] of this._keyedSelections) {
       const thatSelection = that._keyedSelections.get(key);
-      const otherSelections = that.triviallyNestedSelectionsForKey(this.parentType, key);
-      const allSelections = thatSelection ? [thatSelection].concat(otherSelections) : otherSelections;
-      if (allSelections.length === 0) {
-        // If it is a fragment spread, and we didn't find it in `that`, then we try to expand that
-        // fragment and see if that result is entirely covered by `that`. If that is the case, then it means
-        // `thisSelection` does not need to be in the returned "diff". If it's not entirely covered,
-        // we just add the spread itself to the diff: even if some parts of it were covered by `that`,
-        // keeping just the fragment is, in a sense, more condensed.
-        if (thisSelection instanceof FragmentSpreadSelection) {
-          const expanded = thisSelection.selectionSet.expandAllFragments().trimUnsatisfiableBranches(this.parentType);
-          if (expanded.minus(that).isEmpty()) {
-            continue;
-          }
+      if (thatSelection) {
+        const remainder = thisSelection.minus(thatSelection);
+        if (remainder) {
+          updated.add(remainder);
         }
-        updated.add(thisSelection);
       } else {
-        const selectionDiff = allSelections.reduce<Selection | undefined>((prev, val) => prev?.minus(val), thisSelection);
-        if (selectionDiff) {
-          updated.add(selectionDiff);
+        updated.add(thisSelection);
+      }
+    }
+    return updated.toSelectionSet(this.parentType);
+  }
+
+  intersectionWith(that: SelectionSet): SelectionSet {
+    if (this.isEmpty()) {
+      return this;
+    }
+    if (that.isEmpty()) {
+      return that;
+    }
+
+    const intersection = new SelectionSetUpdates();
+    for (const [key, thisSelection] of this._keyedSelections) {
+      const thatSelection = that._keyedSelections.get(key);
+      if (thatSelection) {
+        const selection = thisSelection.intersectionWith(thatSelection);
+        if (selection) {
+          intersection.add(selection);
         }
       }
     }
-    return updated.toSelectionSet(this.parentType, this.fragments);
+
+    return intersection.toSelectionSet(this.parentType);
   }
 
   canRebaseOn(parentTypeToTest: CompositeType): boolean {
@@ -1693,13 +1931,14 @@ export class SelectionSet {
   toOperationString(
     rootKind: SchemaRootKind,
     variableDefinitions: VariableDefinitions,
+    fragments: NamedFragments | undefined,
     operationName?: string,
     expandFragments: boolean = false,
     prettyPrint: boolean = true
   ): string {
     const indent = prettyPrint ? '' : undefined;
-    const fragmentsDefinitions = !expandFragments && this.fragments && !this.fragments.isEmpty()
-      ? this.fragments.toString(indent) + "\n\n"
+    const fragmentsDefinitions = !expandFragments && fragments && !fragments.isEmpty()
+      ? fragments.toString(indent) + "\n\n"
       : "";
     if (rootKind == "query" && !operationName && variableDefinitions.isEmpty()) {
       return fragmentsDefinitions + this.toString(expandFragments, true, indent);
@@ -1813,6 +2052,19 @@ export class SelectionSetUpdates {
   toSelectionSet(parentType: CompositeType, fragments?: NamedFragments): SelectionSet {
     return makeSelectionSet(parentType, this.keyedUpdates, fragments);
   }
+
+  toString() {
+    return '{\n'
+      + [...this.keyedUpdates.entries()].map(([k, updates]) => {
+        const updStr = updates.map((upd) =>
+        upd instanceof AbstractSelection
+          ? upd.toString()
+          : `${upd.path} -> ${upd.selections}`
+        );
+        return ` - ${k}: ${updStr}`;
+      }).join('\n')
+      +'\n\}'
+  }
 }
 
 function addToKeyedUpdates(keyedUpdates: MultiMap<string, SelectionUpdate>, selections: Selection | SelectionSet | readonly Selection[]) {
@@ -1889,7 +2141,7 @@ function makeSelection(parentType: CompositeType, updates: SelectionUpdate[], fr
 
   // Optimize for the simple case of a single selection, as we don't have to do anything complex to merge the sub-selections.
   if (updates.length === 1 && first instanceof AbstractSelection) {
-    return first.rebaseOn(parentType);
+    return first.rebaseOn(parentType, fragments);
   }
 
   const element = updateElement(first).rebaseOn(parentType);
@@ -1936,7 +2188,7 @@ function makeSelectionSet(parentType: CompositeType, keyedUpdates: MultiMap<stri
   for (const [key, updates] of keyedUpdates.entries()) {
     selections.set(key, makeSelection(parentType, updates, fragments));
   }
-  return new SelectionSet(parentType, selections, fragments);
+  return new SelectionSet(parentType, selections);
 }
 
 /**
@@ -2046,14 +2298,14 @@ export function allFieldDefinitionsInSelectionSet(selection: SelectionSet): Fiel
   return allFields;
 }
 
-export function selectionSetOf(parentType: CompositeType, selection: Selection, fragments?: NamedFragments): SelectionSet {
+export function selectionSetOf(parentType: CompositeType, selection: Selection): SelectionSet {
   const map = new Map<string, Selection>()
   map.set(selection.key(), selection);
-  return new SelectionSet(parentType, map, fragments);
+  return new SelectionSet(parentType, map);
 }
 
-export function selectionSetOfElement(element: OperationElement, subSelection?: SelectionSet, fragments?: NamedFragments): SelectionSet {
-  return selectionSetOf(element.parentType, selectionOfElement(element, subSelection), fragments);
+export function selectionSetOfElement(element: OperationElement, subSelection?: SelectionSet): SelectionSet {
+  return selectionSetOf(element.parentType, selectionOfElement(element, subSelection));
 }
 
 export function selectionOfElement(element: OperationElement, subSelection?: SelectionSet): Selection {
@@ -2075,13 +2327,13 @@ abstract class AbstractSelection<TElement extends OperationElement, TIsLeaf exte
 
   abstract key(): string;
 
-  abstract optimize(fragments: NamedFragments): Selection;
+  abstract optimize(fragments: NamedFragments, validator: FieldsConflictValidator): Selection;
 
   abstract toSelectionNode(): SelectionNode;
 
   abstract validate(variableDefinitions: VariableDefinitions): void;
 
-  abstract rebaseOn(parentType: CompositeType): TOwnType;
+  abstract rebaseOn(parentType: CompositeType, fragments: NamedFragments | undefined): TOwnType;
 
   get parentType(): CompositeType {
     return this.element.parentType;
@@ -2101,10 +2353,6 @@ abstract class AbstractSelection<TElement extends OperationElement, TIsLeaf exte
     this.selectionSet?.collectUsedFragmentNames(collector);
   }
 
-  namedFragments(): NamedFragments | undefined {
-    return this.selectionSet?.fragments;
-  }
-
   abstract withUpdatedComponents(element: TElement, selectionSet: SelectionSet | TIsLeaf): TOwnType;
 
   withUpdatedSelectionSet(selectionSet: SelectionSet | TIsLeaf): TOwnType {
@@ -2132,11 +2380,13 @@ abstract class AbstractSelection<TElement extends OperationElement, TIsLeaf exte
 
   abstract hasDefer(): boolean;
 
-  abstract expandAllFragments(): TOwnType | readonly Selection[];
+  abstract expandFragments(updatedFragments: NamedFragments | undefined): TOwnType | readonly Selection[];
 
-  abstract expandFragments(names: string[], updatedFragments: NamedFragments | undefined): TOwnType | readonly Selection[];
+  abstract normalize(args: { parentType: CompositeType, recursive? : boolean }): TOwnType | SelectionSet | undefined;
 
-  abstract trimUnsatisfiableBranches(parentType: CompositeType, options?: { recursive? : boolean }): TOwnType | SelectionSet | undefined;
+  isFragmentSpread(): boolean {
+    return false;
+  }
 
   minus(that: Selection): TOwnType | undefined {
     // If there is a subset, then we compute the diff of the subset and add that (if not empty).
@@ -2150,53 +2400,331 @@ abstract class AbstractSelection<TElement extends OperationElement, TIsLeaf exte
     return undefined;
   }
 
-  // Attempts to optimize the subselection of this field selection using named fragments `candidates` _assuming_ that
-  // those candidates do apply at `parentType` (that is, `candidates.every((c) => c.canApplyAtType(parentType))` is true,
-  // which is ensured by the fact that `tryOptimizeSubselectionWithFragments` calls this on a subset of the candidates
-  // returned by `maybeApplyingAtType`).
-  protected tryOptimizeSubselectionOnce(_: {
-    parentType: CompositeType,
-    subSelection: SelectionSet,
-    candidates: NamedFragmentDefinition[],
-    fragments: NamedFragments,
-  }): {
-    spread?: FragmentSpreadSelection,
-    optimizedSelection?: SelectionSet,
-    hasDiff?: boolean,
-  } {
-    // Field and inline fragment override this, but this should never be called for a spread.
-    assert(false, `UNSUPPORTED`);
+  intersectionWith(that: Selection): TOwnType | undefined {
+    // If there is a subset, then we compute the intersection add that (if not empty).
+    // Otherwise, the intersection is this element.
+    if (this.selectionSet && that.selectionSet) {
+      const subSelectionSetIntersection = this.selectionSet.intersectionWith(that.selectionSet);
+      if (subSelectionSetIntersection.isEmpty()) {
+        return undefined;
+      } else {
+        return this.withUpdatedSelectionSet(subSelectionSetIntersection);
+      }
+    } else {
+      return this.us();
+    }
   }
 
   protected tryOptimizeSubselectionWithFragments({
     parentType,
     subSelection,
     fragments,
-    fragmentFilter,
+    validator,
+    canUseFullMatchingFragment,
   }: {
     parentType: CompositeType,
     subSelection: SelectionSet,
     fragments: NamedFragments,
-    fragmentFilter?: (f: NamedFragmentDefinition) => boolean,
-  }): SelectionSet | FragmentSpreadSelection {
-    let candidates = fragments.maybeApplyingAtType(parentType);
-    if (fragmentFilter) {
-      candidates = candidates.filter(fragmentFilter);
-    }
-    let shouldTryAgain: boolean;
-    do {
-      const { spread, optimizedSelection, hasDiff } = this.tryOptimizeSubselectionOnce({ parentType, subSelection, candidates, fragments });
-      if (optimizedSelection) {
-        subSelection = optimizedSelection;
-      } else if (spread) {
-        return spread;
+    validator: FieldsConflictValidator,
+    canUseFullMatchingFragment: (match: NamedFragmentDefinition) => boolean,
+  }): SelectionSet | NamedFragmentDefinition {
+    // We limit to fragments whose selection could be applied "directly" at `parentType`, meaning without taking the fragment condition
+    // into account. The idea being that if the fragment condition would be needed inside `parentType`, then that condition will not
+    // have been "normalized away" and so we want for this very call to be called on the fragment whose type _is_ the fragment condition (at
+    // which point, this `maybeApplyingDirectlyAtType` method will apply.
+    // Also note that this is because we have this restriction that calling `expandedSelectionSetAtType` is ok.
+    let candidates = fragments.maybeApplyingDirectlyAtType(parentType);
+    if (candidates.length === 0) {
+      return subSelection;
+    }
+
+    // First, we check which of the candidates do apply inside `subSelection`, if any.
+    // If we find a candidate that applies to the whole `subSelection`, then we stop and only return
+    // that one candidate. Otherwise, we cumulate in `applyingFragments` the list of fragments that
+    // applies to a subset of `subSelection`.
+    const applyingFragments: { fragment: NamedFragmentDefinition, atType: FragmentRestrictionAtType }[] = [];
+    for (const candidate of candidates) {
+      const atType = candidate.expandedSelectionSetAtType(parentType);
+      const selectionSetAtType = atType.selectionSet;
+      // It's possible that while the fragment technically applies at `parentType`, it's "rebasing" on
+      // `parentType` is empty, or contains only `__typename`. For instance, suppose we have
+      // a union `U = A | B | C`, and then a fragment:
+      // ```graphql
+      //   fragment F on U {
+      //     ... on A {
+      //       x
+      //     }
+      //     ... on b {
+      //       y
+      //     }
+      //   }
+      // ```
+      // It is then possible to apply `F` when the parent type is `C`, but this ends up selecting
+      // nothing at all.
+      //
+      // Using `F` in those cases is, while not 100% incorrect, at least not productive, and so we
+      // skip it that case. This is essentially an optimisation.
+      if (selectionSetAtType.isEmpty() || (selectionSetAtType.selections().length === 1 && selectionSetAtType.selections()[0].isTypenameField())) {
+        continue;
+      }
+
+      const res = subSelection.contains(selectionSetAtType);
+
+      if (res === ContainsResult.EQUAL) {
+        if (canUseFullMatchingFragment(candidate)) {
+          if (!validator.checkCanReuseFragmentAndTrackIt(atType)) {
+            // We cannot use it at all, so no point in adding to `applyingFragments`.
+            continue;
+          }
+          return candidate;
+        }
+        // If we're not going to replace the full thing, then same reasoning a below.
+        if (candidate.appliedDirectives.length === 0) {
+          applyingFragments.push({ fragment: candidate, atType});
+        }
+      // Note that if a fragment applies to only a subset of the subSelection, then we really only can use
+      // it if that fragment is defined _without_ directives.
+      } else if (res === ContainsResult.STRICTLY_CONTAINED && candidate.appliedDirectives.length === 0) {
+        applyingFragments.push({ fragment: candidate, atType });
+      }
+    }
+
+    if (applyingFragments.length === 0) {
+      return subSelection;
+    }
+
+    // We have found the list of fragments that applies to some subset of `subSelection`. In general, we
+    // want to now produce the selection set with spread for those fragments plus any selection that is not
+    // covered by any of the fragments. For instance, suppose that `subselection` is `{ a b c d e }`
+    // and we have found that `fragment F1 on X { a b c }` and `fragment F2 on X { c d }` applies, then
+    // we will generate `{ ...F1 ...F2 e }`.
+    //
+    // In that example, `c` is covered by both fragments. And this is fine in this example as it is
+    // worth using both fragments in general. A special case of this however is if a fragment is entirely
+    // included into another. That is, consider that we now have `fragment F1 on X { a ...F2 }` and
+    // `fragment F2 on X { b c }`. In that case, the code above would still match both `F1 and `F2`,
+    // but as `F1` includes `F2` already, we really want to only use `F1`. So in practice, we filter
+    // away any fragment spread that is known to be included in another one that applies.
+    //
+    // TODO: note that the logic used for this is theoretically a bit sub-optimial. That is, we only
+    // check if one of the fragment happens to directly include a spread for another fragment at
+    // top-level as in the example above. We do this because it is cheap to check and is likely the
+    // most common case of this kind of inclusion. But in theory, we would have
+    // `fragment F1 on X { a b c }` and `fragment F2 on X { b c }`, in which case `F2` is still
+    // included in `F1`, but we'd have to work harder to figure this out and it's unclear it's
+    // a good tradeoff. And while you could argue that it's on the user to define its fragments
+    // a bit more optimally, it's actually a tad more complex because we're looking at fragments
+    // in a particular context/parent type. Consider an interface `I` and:
+    // ```graphql
+    //   fragment F3 on I {
+    //     ... on X {
+    //       a
+    //     }
+    //     ... on Y {
+    //       b
+    //       c
+    //     }
+    //   }
+    //
+    //   fragment F4 on I {
+    //     ... on Y {
+    //       c
+    //     }
+    //     ... on Z {
+    //       d
+    //     }
+    //   }
+    // ```
+    // In that case, neither fragment include the other per-se. But what if we have sub-selection
+    // `{ b c }` but where parent type is `Y`. In that case, both `F3` and `F4` applies, and in that
+    // particular context, `F3` is fully included in `F4`. Long story short, we'll currently
+    // return `{ ...F3 ...F4 }` in that case, but it would be technically better to return only `F4`.
+    // However, this feels niche, and it might be costly to verify such inclusions, so not doing it
+    // for now.
+    const filteredApplyingFragments = applyingFragments.filter(({ fragment }) => !applyingFragments.some((o) => o.fragment.includes(fragment.name)))
+
+    let notCoveredByFragments = subSelection;
+    const optimized = new SelectionSetUpdates();
+    for (const { fragment, atType} of filteredApplyingFragments) {
+      if (!validator.checkCanReuseFragmentAndTrackIt(atType)) {
+        continue;
       }
-      shouldTryAgain = !!spread && !!hasDiff;
-      if (shouldTryAgain) {
-        candidates = candidates.filter((c) => c !== spread?.namedFragment)
+      const notCovered = subSelection.minus(atType.selectionSet);
+      notCoveredByFragments = notCoveredByFragments.intersectionWith(notCovered);
+      optimized.add(new FragmentSpreadSelection(parentType, fragments, fragment, []));
+    }
+
+    return optimized.add(notCoveredByFragments).toSelectionSet(parentType, fragments)
+  }
+}
+
+class FieldsConflictValidator {
+  private usedSpreadTrimmedPartAtLevel?: FieldsConflictValidator[];
+
+  private constructor(
+    private readonly byResponseName: Map<string, Map<Field, FieldsConflictValidator | null>>,
+  ) {
+  }
+
+  static build(s: SelectionSet): FieldsConflictValidator {
+    return FieldsConflictValidator.forLevel(s.fieldsInSet());
+  }
+
+  private static forLevel(level: CollectedFieldsInSet): FieldsConflictValidator {
+    const atLevel = new Map<string, Map<Field, CollectedFieldsInSet | null>>();
+
+    for (const { field } of level) {
+      const responseName = field.element.responseName();
+      let atResponseName = atLevel.get(responseName);
+      if (!atResponseName) {
+        atResponseName = new Map<Field, CollectedFieldsInSet>();
+        atLevel.set(responseName, atResponseName);
       }
-    } while (shouldTryAgain);
-    return subSelection;
+      if (field.selectionSet) {
+        let forField = atResponseName.get(field.element) ?? [];
+        atResponseName.set(field.element, forField.concat(field.selectionSet.fieldsInSet()));
+      } else {
+        atResponseName.set(field.element, null);
+      }
+    }
+
+    const byResponseName = new Map<string, Map<Field, FieldsConflictValidator | null>>();
+    for (const [name, level] of atLevel.entries()) {
+      const atResponseName = new Map<Field, FieldsConflictValidator | null>();
+      for (const [field, collectedFields] of level) {
+        const validator = collectedFields ? FieldsConflictValidator.forLevel(collectedFields) : null;
+        atResponseName.set(field, validator);
+      }
+      byResponseName.set(name, atResponseName);
+    }
+    return new FieldsConflictValidator(byResponseName);
+  }
+
+  forField(field: Field): FieldsConflictValidator {
+    const validator = this.byResponseName.get(field.responseName())?.get(field);
+    // This should be called on validator built on the exact selection set from field this `field` is coming, so
+    // we should find it or the code is buggy.
+    assert(validator, () => `Should have found validator for ${field}`);
+    return validator;
+  }
+
+  // At this point, we known that the fragment, restricted to the current parent type, matches a subset of the
+  // sub-selection. However, there is still one case we we cannot use it that we need to check, and this is
+  // if using the fragment would create a field "conflict" (in the sense of the graphQL spec
+  // [`FieldsInSetCanMerge`](https://spec.graphql.org/draft/#FieldsInSetCanMerge())) and thus create an
+  // invalid selection. To be clear, `atType.selectionSet` cannot create a conflict, since it is a subset
+  // of `subSelection` and `subSelection` is valid. *But* there may be some part of the fragment that
+  // is not `atType.selectionSet` due to being "dead branches" for type `parentType`. And while those
+  // branches _are_ "dead" as far as execution goes, the `FieldsInSetCanMerge` validation does not take
+  // this into account (it's 1st step says "including visiting fragments and inline fragments" but has
+  // no logic regarding ignoring any fragment that may not apply due to the intersection of runtimes
+  // between multiple fragment being empty).
+  checkCanReuseFragmentAndTrackIt(fragment: FragmentRestrictionAtType): boolean {
+    // No validator means that everything in the fragment selection was part of the selection we're optimizing
+    // away (by using the fragment), and we know the original selection was ok, so nothing to check.
+    const validator = fragment.validator;
+    if (!validator) {
+      return true;
+    }
+
+    if (!this.doMergeWith(validator)) {
+      return false;
+    }
+
+    // We need to make sure the trimmed parts of `fragment` merges with the rest of the selection,
+    // but also that it merge with any of the trimmed parts of any fragment we have added already.
+    // Note: this last condition means that if 2 fragment conflict on their "trimmed" parts,
+    // then the choice of which is used can be based on the fragment ordering and selection order,
+    // which may not be optimal. This feels niche enough that we keep it simple for now, but we
+    // can revisit this decision if we run into real cases that justify it (but making it optimal
+    // would be a involved in general, as in theory you could have complex dependencies of fragments
+    // that conflict, even cycles, and you need to take the size of fragments into account to know
+    // what's best; and even then, this could even depend on overall usage, as it can be better to
+    // reuse a fragment that is used in other places, than to use one for which it's the only usage.
+    // Adding to all that the fact that conflict can happen in sibling branches).
+    if (this.usedSpreadTrimmedPartAtLevel) {
+      if (!this.usedSpreadTrimmedPartAtLevel.every((t) => validator.doMergeWith(t))) {
+        return false;
+      }
+    } else {
+      this.usedSpreadTrimmedPartAtLevel = [];
+    }
+
+    // We're good, but track the fragment
+    this.usedSpreadTrimmedPartAtLevel.push(validator);
+    return true;
+  }
+
+  doMergeWith(that: FieldsConflictValidator): boolean {
+    for (const [responseName, thisFields] of this.byResponseName.entries()) {
+      const thatFields = that.byResponseName.get(responseName);
+      if (!thatFields) {
+        continue;
+      }
+
+      // We're basically checking [FieldInSetCanMerge](https://spec.graphql.org/draft/#FieldsInSetCanMerge()),
+      // but from 2 set of fields (`thisFields` and `thatFields`) of the same response that we know individually
+      // merge already.
+      for (const [thisField, thisValidator] of thisFields.entries()) {
+        for (const [thatField, thatValidator] of thatFields.entries()) {
+          // The `SameResponseShape` test that all fields must pass.
+          if (!typesCanBeMerged(thisField.definition.type!, thatField.definition.type!)) {
+            return false;
+          }
+
+          const p1 = thisField.parentType;
+          const p2 = thatField.parentType;
+          if (sameType(p1, p2) || !isObjectType(p1) || !isObjectType(p2)) {
+            // Additional checks of `FieldsInSetCanMerge` when same parent type or one isn't object
+            if (thisField.name !== thatField.name
+              || !argumentsEquals(thisField.args ?? {}, thatField.args ?? {})
+              || (thisValidator && thatValidator && !thisValidator.doMergeWith(thatValidator))
+            ) {
+              return false;
+            }
+          } else {
+            // Otherwise, the sub-selection must pass [SameResponseShape](https://spec.graphql.org/draft/#SameResponseShape()).
+            if (thisValidator && thatValidator && !thisValidator.hasSameResponseShapeThan(thatValidator)) {
+              return false;
+            }
+          }
+        }
+      }
+    }
+    return true;
+  }
+
+  hasSameResponseShapeThan(that: FieldsConflictValidator): boolean {
+    for (const [responseName, thisFields] of this.byResponseName.entries()) {
+      const thatFields = that.byResponseName.get(responseName);
+      if (!thatFields) {
+        continue;
+      }
+
+      for (const [thisField, thisValidator] of thisFields.entries()) {
+        for (const [thatField, thatValidator] of thatFields.entries()) {
+          if (!typesCanBeMerged(thisField.definition.type!, thatField.definition.type!)
+            || (thisValidator && thatValidator && !thisValidator.hasSameResponseShapeThan(thatValidator))) {
+            return false;
+          }
+        }
+      }
+    }
+    return true;
+  }
+
+  toString(indent: string = ''): string {
+    // For debugging/testing ...
+    return '{\n'
+      + [...this.byResponseName.entries()].map(([name, byFields]) => {
+        const innerIndent = indent + '  ';
+        return `${innerIndent}${name}: [\n`
+        + [...byFields.entries()]
+            .map(([field, next]) => `${innerIndent}  ${field.parentType}.${field}${next ? next.toString(innerIndent + '  '): ''}`)
+            .join('\n')
+        + `\n${innerIndent}]`;
+      }).join('\n')
+      + `\n${indent}}`
   }
 }
 
@@ -2223,6 +2751,9 @@ export class FieldSelection extends AbstractSelection<Field<any>, undefined, Fie
   }
 
   withUpdatedComponents(field: Field<any>, selectionSet: SelectionSet | undefined): FieldSelection {
+    if (this.element === field && this.selectionSet === selectionSet) {
+      return this;
+    }
     return new FieldSelection(field, selectionSet);
   }
 
@@ -2230,66 +2761,48 @@ export class FieldSelection extends AbstractSelection<Field<any>, undefined, Fie
     return this.element.key();
   }
 
-  optimize(fragments: NamedFragments): Selection {
-    let optimizedSelection = this.selectionSet ? this.selectionSet.optimizeSelections(fragments) : undefined;
-    const fieldBaseType = this.element.baseType();
-    if (isCompositeType(fieldBaseType) && optimizedSelection) {
+  optimize(fragments: NamedFragments, validator: FieldsConflictValidator): Selection {
+    const fieldBaseType = baseType(this.element.definition.type!);
+    if (!isCompositeType(fieldBaseType) || !this.selectionSet) {
+      return this;
+    }
+
+    const fieldValidator = validator.forField(this.element);
+
+    // First, see if we can reuse fragments for the selection of this field.
+    let optimizedSelection = this.selectionSet;
+    if (isCompositeType(fieldBaseType) && this.selectionSet) {
       const optimized = this.tryOptimizeSubselectionWithFragments({
         parentType: fieldBaseType,
-        subSelection: optimizedSelection,
+        subSelection: this.selectionSet,
         fragments,
-        // We can never apply a fragments that has directives on it at the field level (but when those are expanded,
-        // their type condition would always be preserved due to said applied directives, so they will always
-        // be handled by `InlineFragmentSelection.optimize` anyway).
-        fragmentFilter: (f) => f.appliedDirectives.length === 0,
+        validator: fieldValidator,
+        // We can never apply a fragments that has directives on it at the field level.
+        canUseFullMatchingFragment: (fragment) => fragment.appliedDirectives.length === 0,
       });
 
-      assert(!(optimized instanceof FragmentSpreadSelection), 'tryOptimizeSubselectionOnce should never return only a spread');
-      optimizedSelection = optimized;
+      if (optimized instanceof NamedFragmentDefinition) {
+        optimizedSelection = selectionSetOf(fieldBaseType, new FragmentSpreadSelection(fieldBaseType, fragments, optimized, []));
+      } else {
+        optimizedSelection = optimized;
+      }
     }
 
+    // Then, recurse inside the field sub-selection (note that if we matched some fragments above,
+    // this recursion will "ignore" those as `FragmentSpreadSelection.optimize()` is a no-op).
+    optimizedSelection = optimizedSelection.optimizeSelections(fragments, fieldValidator);
+
     return this.selectionSet === optimizedSelection
       ? this
-      : new FieldSelection(this.element, optimizedSelection);
+      : this.withUpdatedSelectionSet(optimizedSelection);
   }
 
-  protected tryOptimizeSubselectionOnce({
-    parentType,
-    subSelection,
-    candidates,
-    fragments,
-  }: {
-    parentType: CompositeType,
-    subSelection: SelectionSet,
-    candidates: NamedFragmentDefinition[],
-    fragments: NamedFragments,
-  }): {
-    spread?: FragmentSpreadSelection,
-    optimizedSelection?: SelectionSet,
-    hasDiff?: boolean,
-  }{
-    let optimizedSelection = subSelection;
-    for (const candidate of candidates) {
-      const { contains, diff } = optimizedSelection.diffWithNamedFragmentIfContained(candidate, parentType);
-      if (contains) {
-        // We can optimize the selection with this fragment. The replaced sub-selection will be
-        // comprised of this new spread and the remaining `diff` if there is any.
-        const spread = new FragmentSpreadSelection(parentType, fragments, candidate, []);
-        optimizedSelection = diff
-          ? new SelectionSetUpdates().add(spread).add(diff).toSelectionSet(parentType, fragments)
-          : selectionSetOf(parentType, spread);
-        return { spread, optimizedSelection, hasDiff: !!diff }
-      }
-    }
-    return {};
-  }
-
-  filter(predicate: (selection: Selection) => boolean): FieldSelection | undefined {
+  filterRecursiveDepthFirst(predicate: (selection: Selection) => boolean): FieldSelection | undefined {
     if (!this.selectionSet) {
       return predicate(this) ? this : undefined;
     }
 
-    const updatedSelectionSet = this.selectionSet.filter(predicate);
+    const updatedSelectionSet = this.selectionSet.filterRecursiveDepthFirst(predicate);
     const thisWithFilteredSelectionSet = this.selectionSet === updatedSelectionSet
       ? this
       : new FieldSelection(this.element, updatedSelectionSet);
@@ -2315,7 +2828,7 @@ export class FieldSelection extends AbstractSelection<Field<any>, undefined, Fie
    * Obviously, this operation will only succeed if this selection (both the field itself and its subselections)
    * make sense from the provided parent type. If this is not the case, this method will throw.
    */
-  rebaseOn(parentType: CompositeType): FieldSelection {
+  rebaseOn(parentType: CompositeType, fragments: NamedFragments | undefined): FieldSelection {
     if (this.element.parentType === parentType) {
       return this;
     }
@@ -2331,7 +2844,7 @@ export class FieldSelection extends AbstractSelection<Field<any>, undefined, Fie
     }
 
     validate(isCompositeType(rebasedBase), () => `Cannot rebase field selection ${this} on ${parentType}: rebased field base return type ${rebasedBase} is not composite`);
-    return this.withUpdatedComponents(rebasedElement, this.selectionSet.rebaseOn(rebasedBase));
+    return this.withUpdatedComponents(rebasedElement, this.selectionSet.rebaseOn(rebasedBase, fragments));
   }
 
   /**
@@ -2382,37 +2895,46 @@ export class FieldSelection extends AbstractSelection<Field<any>, undefined, Fie
     return !!this.selectionSet?.hasDefer();
   }
 
-  expandAllFragments(): FieldSelection {
-    return this.mapToSelectionSet((s) => s.expandAllFragments());
-  }
+  normalize({ parentType, recursive }: { parentType: CompositeType, recursive? : boolean }): FieldSelection {
+    // This could be an interface field, and if we're normalizing on one of the implementation of that
+    // interface, we want to make sure we use the field of the implementation, as it may in particular
+    // have a more specific type which should propagate to the recursive call to normalize.
+
+    const definition = parentType === this.parentType
+      ? this.element.definition
+      : parentType.field(this.element.name);
+    assert(definition, `Cannot normalize ${this.element} at ${parentType} which does not have that field`)
 
-  trimUnsatisfiableBranches(_: CompositeType, options?: { recursive? : boolean }): FieldSelection {
+    const element = this.element.definition === definition ? this.element : this.element.withUpdatedDefinition(definition);
     if (!this.selectionSet) {
-      return this;
+      return this.withUpdatedElement(element);
     }
 
-    const base = this.element.baseType()
-    assert(isCompositeType(base), () => `Field ${this.element} should not have a sub-selection`);
-    const trimmed = (options?.recursive ?? true) ? this.mapToSelectionSet((s) => s.trimUnsatisfiableBranches(base)) : this;
+    const base = element.baseType();
+    assert(isCompositeType(base), () => `Field ${element} should not have a sub-selection`);
+    const normalizedSubSelection = (recursive ?? true) ? this.selectionSet.normalize({ parentType: base }) : this.selectionSet;
     // In rare caes, it's possible that everything in the sub-selection was trimmed away and so the
     // sub-selection is empty. Which suggest something may be wrong with this part of the query
     // intent, but the query was valid while keeping an empty sub-selection isn't. So in that
     // case, we just add some "non-included" __typename field just to keep the query valid.
-    if (trimmed.selectionSet?.isEmpty()) {
-      return trimmed.withUpdatedSelectionSet(selectionSetOfElement(
-        new Field(
-          base.typenameField()!,
-          undefined,
-          [new Directive('include', { 'if': false })],
+    if (normalizedSubSelection?.isEmpty()) {
+      return this.withUpdatedComponents(
+        element,
+        selectionSetOfElement(
+          new Field(
+            base.typenameField()!,
+            undefined,
+            [new Directive('include', { 'if': false })],
+          )
         )
-      ));
+      );
     } else {
-      return trimmed;
+      return this.withUpdatedComponents(element, normalizedSubSelection);
     }
   }
 
-  expandFragments(names: string[], updatedFragments: NamedFragments | undefined): FieldSelection {
-    return this.mapToSelectionSet((s) => s.expandFragments(names, updatedFragments));
+  expandFragments(updatedFragments?: NamedFragments): FieldSelection {
+    return this.mapToSelectionSet((s) => s.expandFragments(updatedFragments));
   }
 
   equals(that: Selection): boolean {
@@ -2429,20 +2951,17 @@ export class FieldSelection extends AbstractSelection<Field<any>, undefined, Fie
     return !!that.selectionSet && this.selectionSet.equals(that.selectionSet);
   }
 
-  contains(that: Selection): boolean {
+  contains(that: Selection): ContainsResult {
     if (!(that instanceof FieldSelection) || !this.element.equals(that.element)) {
-      return false;
+      return ContainsResult.NOT_CONTAINED;
     }
 
-    if (!that.selectionSet) {
-      return true;
+    if (!this.selectionSet) {
+      assert(!that.selectionSet, '`this` and `that` have the same element, so if one does not have a sub-selection, neither should the other one')
+      return ContainsResult.EQUAL;
     }
-    return !!this.selectionSet && this.selectionSet.contains(that.selectionSet);
-  }
-
-  isUnecessaryInlineFragment(_: CompositeType): this is InlineFragmentSelection {
-    // Overridden by inline fragments
-    return false;
+    assert(that.selectionSet, '`this` and `that` have the same element, so if one has sub-selection, the other one should too')
+    return this.selectionSet.contains(that.selectionSet);
   }
 
   toString(expandFragments: boolean = true, indent?: string): string {
@@ -2470,11 +2989,10 @@ export abstract class FragmentSelection extends AbstractSelection<FragmentElemen
     }
   }
   
-  filter(predicate: (selection: Selection) => boolean): FragmentSelection | undefined {
+  filterRecursiveDepthFirst(predicate: (selection: Selection) => boolean): FragmentSelection | undefined {
     // Note that we essentially expand all fragments as part of this.
-    const selectionSet = this.selectionSet;
-    const updatedSelectionSet = selectionSet.filter(predicate);
-    const thisWithFilteredSelectionSet = updatedSelectionSet === selectionSet
+    const updatedSelectionSet = this.selectionSet.filterRecursiveDepthFirst(predicate);
+    const thisWithFilteredSelectionSet = updatedSelectionSet === this.selectionSet
       ? this
       : new InlineFragmentSelection(this.element, updatedSelectionSet);
 
@@ -2487,16 +3005,7 @@ export abstract class FragmentSelection extends AbstractSelection<FragmentElemen
 
   abstract equals(that: Selection): boolean;
 
-  abstract contains(that: Selection): boolean;
-
-  isUnecessaryInlineFragment(parentType: CompositeType): boolean {
-    return this.element.appliedDirectives.length === 0
-      && !!this.element.typeCondition
-      && (
-        this.element.typeCondition.name === parentType.name 
-          || (isObjectType(parentType) && possibleRuntimeTypes(this.element.typeCondition).some((t) => t.name === parentType.name))
-      );
-  }
+  abstract contains(that: Selection): ContainsResult;
 }
 
 class InlineFragmentSelection extends FragmentSelection {
@@ -2516,6 +3025,9 @@ class InlineFragmentSelection extends FragmentSelection {
   }
 
   withUpdatedComponents(fragment: FragmentElement, selectionSet: SelectionSet): InlineFragmentSelection {
+    if (fragment === this.element && selectionSet === this.selectionSet) {
+      return this;
+    }
     return new InlineFragmentSelection(fragment, selectionSet);
   }
 
@@ -2530,7 +3042,7 @@ class InlineFragmentSelection extends FragmentSelection {
     this.selectionSet.validate(variableDefinitions);
   }
 
-  rebaseOn(parentType: CompositeType): FragmentSelection {
+  rebaseOn(parentType: CompositeType, fragments: NamedFragments | undefined): FragmentSelection {
     if (this.parentType === parentType) {
       return this;
     }
@@ -2541,7 +3053,7 @@ class InlineFragmentSelection extends FragmentSelection {
       return this.withUpdatedElement(rebasedFragment);
     }
 
-    return this.withUpdatedComponents(rebasedFragment, this.selectionSet.rebaseOn(rebasedCastedType));
+    return this.withUpdatedComponents(rebasedFragment, this.selectionSet.rebaseOn(rebasedCastedType, fragments));
   }
 
   canAddTo(parentType: CompositeType): boolean {
@@ -2578,87 +3090,62 @@ class InlineFragmentSelection extends FragmentSelection {
     };
   }
 
-  optimize(fragments: NamedFragments): FragmentSelection {
-    let optimizedSelection = this.selectionSet.optimizeSelections(fragments);
+  optimize(fragments: NamedFragments, validator: FieldsConflictValidator): FragmentSelection {
+    let optimizedSelection = this.selectionSet;
+
+    // First, see if we can reuse fragments for the selection of this field.
     const typeCondition = this.element.typeCondition;
     if (typeCondition) {
       const optimized = this.tryOptimizeSubselectionWithFragments({
         parentType: typeCondition,
         subSelection: optimizedSelection,
         fragments,
+        validator,
+        canUseFullMatchingFragment: (fragment) => {
+          // To be able to use a matching fragment, it needs to have either no directives, or if it has
+          // some, then:
+          //  1. all it's directives should also be on the current element.
+          //  2. the directives of this element should be the fragment condition.
+          // because if those 2 conditions are true, we can replace the whole current inline fragment
+          // with the match spread and directives will still match.
+          return fragment.appliedDirectives.length === 0
+            || (
+              sameType(typeCondition, fragment.typeCondition)
+                && fragment.appliedDirectives.every((d) => this.element.appliedDirectives.some((s) => sameDirectiveApplication(d, s)))
+            );
+        },
       });
-      if (optimized instanceof FragmentSpreadSelection) {
-        // This means the whole inline fragment can be replaced by the spread.
-        return optimized;
-      }
-      optimizedSelection = optimized;
-    }
-    return this.selectionSet === optimizedSelection
-      ? this
-      : new InlineFragmentSelection(this.element, optimizedSelection);
-  }
 
-  protected tryOptimizeSubselectionOnce({
-    parentType,
-    subSelection,
-    candidates,
-    fragments,
-  }: {
-    parentType: CompositeType,
-    subSelection: SelectionSet,
-    candidates: NamedFragmentDefinition[],
-    fragments: NamedFragments,
-  }): {
-    spread?: FragmentSpreadSelection,
-    optimizedSelection?: SelectionSet,
-    hasDiff?: boolean,
-  }{
-    let optimizedSelection = subSelection;
-    for (const candidate of candidates) {
-      const { contains, diff } = optimizedSelection.diffWithNamedFragmentIfContained(candidate, parentType);
-      if (contains) {
-        // The candidate selection is included in our sub-selection. One remaining thing to take into account
-        // is applied directives: if the candidate has directives, then we can only use it if 1) there is
-        // no `diff`, 2) the type condition of this fragment matches the candidate one and 3) the directives
-        // in question are also on this very fragment. In that case, we can replace this whole inline fragment
-        // by a spread of the candidate.
-        if (!diff && sameType(this.element.typeCondition!, candidate.typeCondition)) {
-          // We can potentially replace the whole fragment by the candidate; but as said above, still needs
-          // to check the directives.
-          let spreadDirectives: Directive<any>[] = this.element.appliedDirectives;
-          if (candidate.appliedDirectives.length > 0) {
-            const { isSubset, difference } = diffDirectives(this.element.appliedDirectives, candidate.appliedDirectives);
-            if (!isSubset) {
-              // While the candidate otherwise match, it has directives that are not on this element, so we
-              // cannot reuse it.
-              continue;
-            }
-            // Otherwise, any directives on this element that are not on the candidate should be kept and used
-            // on the spread created.
-            spreadDirectives = difference;
+      if (optimized instanceof NamedFragmentDefinition) {
+        // We're fully matching the sub-selection. If the fragment condition is also this element condition,
+        // then we can replace the whole element by the spread (not just the sub-selection).
+        if (sameType(typeCondition, optimized.typeCondition)) {
+          // Note that `canUseFullMatchingFragment` above guarantees us that this element directives
+          // are a superset of the fragment directives. But there can be additional directives, and in
+          // that case they should be kept on the spread.
+          let spreadDirectives = this.element.appliedDirectives;
+          if (optimized.appliedDirectives) {
+            spreadDirectives = spreadDirectives.filter(
+              (s) => !optimized.appliedDirectives.some((d) => sameDirectiveApplication(d, s))
+            );
           }
-          // Returning a spread without a subselection will make the code "replace" this whole inline fragment
-          // by the spread, which is what we want. Do not that as we're replacing the whole inline fragment,
-          // we use `this.parentType` instead of `parentType` (the later being `this.element.typeCondition` basically).
-          return {
-            spread: new FragmentSpreadSelection(this.parentType, fragments, candidate, spreadDirectives),
-          };
-        }
-
-        // We're already dealt with the one case where we might be able to handle a candidate that has directives.
-        if (candidate.appliedDirectives.length > 0) {
-          continue;
+          return new FragmentSpreadSelection(this.parentType, fragments, optimized, spreadDirectives);
+        } else {
+          // Otherwise, we keep this element and use a sub-selection with just the spread.
+          optimizedSelection = selectionSetOf(typeCondition, new FragmentSpreadSelection(typeCondition, fragments, optimized, []));
         }
-
-        const spread = new FragmentSpreadSelection(parentType, fragments, candidate, []);
-        optimizedSelection = diff
-          ? new SelectionSetUpdates().add(spread).add(diff).toSelectionSet(parentType, fragments)
-          : selectionSetOf(parentType, spread);
-
-        return { spread, optimizedSelection, hasDiff: !!diff };
+      } else {
+        optimizedSelection = optimized;
       }
     }
-    return {};
+
+    // Then, recurse inside the field sub-selection (note that if we matched some fragments above,
+    // this recursion will "ignore" those as `FragmentSpreadSelection.optimize()` is a no-op).
+    optimizedSelection = optimizedSelection.optimizeSelections(fragments, validator);
+
+    return this.selectionSet === optimizedSelection
+      ? this
+      : new InlineFragmentSelection(this.element, optimizedSelection);
   }
 
   withoutDefer(labelsToRemove?: Set<string>): InlineFragmentSelection | SelectionSet {
@@ -2686,55 +3173,60 @@ class InlineFragmentSelection extends FragmentSelection {
       : this.withUpdatedComponents(newElement, newSelection);
   }
 
-  trimUnsatisfiableBranches(currentType: CompositeType, options?: { recursive? : boolean }): FragmentSelection | SelectionSet | undefined {
-    const recursive = options?.recursive ?? true;
-
+  normalize({ parentType, recursive }: { parentType: CompositeType, recursive? : boolean }): FragmentSelection | SelectionSet | undefined {
     const thisCondition = this.element.typeCondition;
-    // Note that if the condition has directives, we preserve the fragment no matter what.
-    if (this.element.appliedDirectives.length === 0) {
-      if (!thisCondition || currentType === this.element.typeCondition) {
-        const trimmed = this.selectionSet.trimUnsatisfiableBranches(currentType, options);
-        return trimmed.isEmpty() ? undefined : trimmed;
-      }
 
-      // If the current type is an object, then we never need to keep the current fragment because:
-      // - either the fragment is also an object, but we've eliminated the case where the 2 types are the same,
-      //   so this is just an unsatisfiable branch.
-      // - or it's not an object, but then the current type is more precise and no point in "casting" to a
-      //   less precise interface/union. And if the current type is not even a valid runtime of said interface/union,
-      //   then we should completely ignore the branch (or, since we're eliminating `thisCondition`, we would be
-      //   building an invalid selection). 
-      if (isObjectType(currentType)) {
-        if (isObjectType(thisCondition) || !possibleRuntimeTypes(thisCondition).includes(currentType)) {
-          return undefined;
-        } else {
-          const trimmed = this.selectionSet.trimUnsatisfiableBranches(currentType, options);
-          return trimmed.isEmpty() ? undefined : trimmed;
-        }
+    // This method assumes by contract that `parentType` runtimes intersects `this.parentType`'s, but `parentType`
+    // runtimes may be a subset. So first check if the selection should not be discarded on that account (that
+    // is, we should not keep the selection if its condition runtimes don't intersect at all with those of
+    // `parentType` as that would ultimately make an invalid selection set).
+    if (thisCondition && parentType !== this.parentType) {
+      const conditionRuntimes = possibleRuntimeTypes(thisCondition);
+      const typeRuntimes = possibleRuntimeTypes(parentType);
+      if (!conditionRuntimes.some((t) => typeRuntimes.includes(t))) {
+        return undefined;
       }
     }
 
-    // As we preserve the current fragment, the rest is about recursing. If we don't recurse, we're done
-    if (!recursive) {
-      return this;
+    // We know the condition is "valid", but it may not be useful. That said, if the condition has directives,
+    // we preserve the fragment no matter what.
+    if (this.element.appliedDirectives.length === 0) {
+      // There is a number of cases where a fragment is not useful:
+      // 1. if there is not conditions (remember it also has no directives).
+      // 2. if it's the same type as the current type: it's not restricting types further.
+      // 3. if the current type is an object more generally: because in that case too the condition
+      //   cannot be restricting things further (it's typically a less precise interface/union).
+      if (!thisCondition || parentType === this.element.typeCondition || isObjectType(parentType)) {
+        const normalized = this.selectionSet.normalize({ parentType, recursive });
+        return normalized.isEmpty() ? undefined : normalized;
+      }
     }
 
-    // In all other cases, we first recurse on the sub-selection.
-    const trimmedSelectionSet = this.selectionSet.trimUnsatisfiableBranches(this.element.typeCondition ?? this.parentType);
+    // We preserve the current fragment, so we only recurse within the sub-selection if we're asked to be recusive.
+    // (note that even if we're not recursive, we may still have some "lifting" to do)
+    let normalizedSelectionSet: SelectionSet;
+    if (recursive ?? true) {
+      normalizedSelectionSet = this.selectionSet.normalize({ parentType: thisCondition ?? parentType });
 
-    // First, could be that everything was unsatisfiable.
-    if (trimmedSelectionSet.isEmpty()) {
-      if (this.element.appliedDirectives.length === 0) {
-        return undefined;
-      } else {
-        return this.withUpdatedSelectionSet(selectionSetOfElement(
-          new Field(
-            (this.element.typeCondition ?? this.parentType).typenameField()!,
-            undefined,
-            [new Directive('include', { 'if': false })],
-          )
-        ));
+      // It could be that everything was unsatisfiable.
+      if (normalizedSelectionSet.isEmpty()) {
+        if (this.element.appliedDirectives.length === 0) {
+          return undefined;
+        } else {
+          return this.withUpdatedComponents(
+            this.element.rebaseOn(parentType),
+            selectionSetOfElement(
+              new Field(
+                (this.element.typeCondition ?? parentType).typenameField()!,
+                undefined,
+                [new Directive('include', { 'if': false })],
+              )
+            )
+          );
+        }
       }
+    } else {
+      normalizedSelectionSet = this.selectionSet;
     }
 
     // Second, we check if some of the sub-selection fragments can be "lifted" outside of this fragment. This can happen if:
@@ -2742,10 +3234,10 @@ class InlineFragmentSelection extends FragmentSelection {
     // 2. the sub-fragment is an object type,
     // 3. the sub-fragment type is a valid runtime of the current type.
     if (this.element.appliedDirectives.length === 0 && isAbstractType(thisCondition!)) {
-      assert(!isObjectType(currentType), () => `Should not have got here if ${currentType} is an object type`);
-      const currentRuntimes = possibleRuntimeTypes(currentType);
+      assert(!isObjectType(parentType), () => `Should not have got here if ${parentType} is an object type`);
+      const currentRuntimes = possibleRuntimeTypes(parentType);
       const liftableSelections: Selection[] = [];
-      for (const selection of trimmedSelectionSet.selections()) {
+      for (const selection of normalizedSelectionSet.selections()) {
         if (selection.kind === 'FragmentSelection'
           && selection.element.typeCondition
           && isObjectType(selection.element.typeCondition)
@@ -2756,8 +3248,8 @@ class InlineFragmentSelection extends FragmentSelection {
       }
 
       // If we can lift all selections, then that just mean we can get rid of the current fragment altogether
-      if (liftableSelections.length === trimmedSelectionSet.selections().length) {
-        return trimmedSelectionSet;
+      if (liftableSelections.length === normalizedSelectionSet.selections().length) {
+        return normalizedSelectionSet;
       }
 
       // Otherwise, if there is "liftable" selections, we must return a set comprised of those lifted selection,
@@ -2766,21 +3258,19 @@ class InlineFragmentSelection extends FragmentSelection {
         const newSet = new SelectionSetUpdates();
         newSet.add(liftableSelections);
         newSet.add(this.withUpdatedSelectionSet(
-          trimmedSelectionSet.filter((s) => !liftableSelections.includes(s)),
+          normalizedSelectionSet.filter((s) => !liftableSelections.includes(s)),
         ));
-        return newSet.toSelectionSet(this.parentType);
+        return newSet.toSelectionSet(parentType);
       }
     }
 
-    return this.selectionSet === trimmedSelectionSet ? this : this.withUpdatedSelectionSet(trimmedSelectionSet);
-  }
-
-  expandAllFragments(): FragmentSelection {
-    return this.mapToSelectionSet((s) => s.expandAllFragments());
+    return this.parentType === parentType && this.selectionSet === normalizedSelectionSet
+      ? this
+      : this.withUpdatedComponents(this.element.rebaseOn(parentType), normalizedSelectionSet);
   }
 
-  expandFragments(names: string[], updatedFragments: NamedFragments | undefined): FragmentSelection {
-    return this.mapToSelectionSet((s) => s.expandFragments(names, updatedFragments));
+  expandFragments(updatedFragments: NamedFragments | undefined): FragmentSelection {
+    return this.mapToSelectionSet((s) => s.expandFragments(updatedFragments));
   }
 
   equals(that: Selection): boolean {
@@ -2793,10 +3283,12 @@ class InlineFragmentSelection extends FragmentSelection {
       && this.selectionSet.equals(that.selectionSet);
   }
 
-  contains(that: Selection): boolean {
-    return (that instanceof FragmentSelection)
-      && this.element.equals(that.element)
-      && this.selectionSet.contains(that.selectionSet);
+  contains(that: Selection): ContainsResult {
+    if (!(that instanceof FragmentSelection) || !this.element.equals(that.element)) {
+      return ContainsResult.NOT_CONTAINED;
+    }
+
+    return this.selectionSet.contains(that.selectionSet);
   }
 
   toString(expandFragments: boolean = true, indent?: string): string {
@@ -2804,14 +3296,6 @@ class InlineFragmentSelection extends FragmentSelection {
   }
 }
 
-function diffDirectives(superset: readonly Directive<any>[], maybeSubset: readonly Directive<any>[]): { isSubset: boolean, difference: Directive[] } {
-  if (maybeSubset.every((d) => superset.some((s) => sameDirectiveApplication(d, s)))) {
-    return { isSubset: true, difference: superset.filter((s) => !maybeSubset.some((d) => sameDirectiveApplication(d, s))) };
-  } else {
-    return { isSubset: false, difference: [] };
-  }
-}
-
 class FragmentSpreadSelection extends FragmentSelection {
   private computedKey: string | undefined;
 
@@ -2824,6 +3308,10 @@ class FragmentSpreadSelection extends FragmentSelection {
     super(new FragmentElement(sourceType, namedFragment.typeCondition, namedFragment.appliedDirectives.concat(spreadDirectives)));
   }
 
+  isFragmentSpread(): boolean {
+    return true;
+  }
+
   get selectionSet(): SelectionSet {
     return this.namedFragment.selectionSet;
   }
@@ -2839,20 +3327,20 @@ class FragmentSpreadSelection extends FragmentSelection {
     assert(false, `Unsupported`);
   }
 
-  trimUnsatisfiableBranches(parentType: CompositeType): FragmentSelection  {
+  normalize({ parentType }: { parentType: CompositeType }): FragmentSelection  {
     // We must update the spread parent type if necessary since we're not going deeper,
     // or we'll be fundamentally losing context.
-    return this.rebaseOn(parentType);
-  }
-
-  namedFragments(): NamedFragments | undefined {
-    return this.fragments;
+    assert(parentType.schema() === this.parentType.schema(), 'Should not try to normalize using a type from another schema');
+    return this.rebaseOn(parentType, this.fragments);
   }
 
   validate(): void {
     this.validateDeferAndStream();
 
-    // We don't do anything else because fragment definition are validated when created.
+    validate(
+      runtimeTypesIntersects(this.parentType, this.namedFragment.typeCondition),
+      () => `Fragment "${this.namedFragment.name}" cannot be spread inside type ${this.parentType} as the runtime types do not intersect ${this.namedFragment.typeCondition}`
+    );
   }
 
   toSelectionNode(): FragmentSpreadNode {
@@ -2875,11 +3363,11 @@ class FragmentSpreadSelection extends FragmentSelection {
     };
   }
 
-  optimize(_: NamedFragments): FragmentSelection {
+  optimize(_1: NamedFragments, _2: FieldsConflictValidator): FragmentSelection {
     return this;
   }
 
-  rebaseOn(parentType: CompositeType): FragmentSelection {
+  rebaseOn(parentType: CompositeType, fragments: NamedFragments | undefined): FragmentSelection {
     // We preserve the parent type here, to make sure we don't lose context, but we actually don't
     // want to expand the spread  as that would compromise the code that optimize subgraph fetches to re-use named
     // fragments.
@@ -2892,10 +3380,18 @@ class FragmentSpreadSelection extends FragmentSelection {
     if (this.parentType === parentType) {
       return this;
     }
+
+    // If we're rebasing on a _different_ schema, then we *must* have fragments, since reusing
+    // `this.fragments` would be incorrect. If we're on the same schema though, we're happy to default
+    // to `this.fragments`.
+    assert(fragments || this.parentType.schema() === parentType.schema(), `Must provide fragments is rebasing on other schema`);
+    const newFragments = fragments ?? this.fragments;
+    const namedFragment = newFragments.get(this.namedFragment.name);
+    assert(namedFragment, () => `Cannot rebase ${this} if it isn't part of the provided fragments`);
     return new FragmentSpreadSelection(
       parentType,
-      this.fragments,
-      this.namedFragment,
+      newFragments,
+      namedFragment,
       this.spreadDirectives,
     );
   }
@@ -2906,26 +3402,20 @@ class FragmentSpreadSelection extends FragmentSelection {
     return true;
   }
 
-  expandAllFragments(): FragmentSelection | readonly Selection[] {
-    const expandedSubSelections = this.selectionSet.expandAllFragments();
-    return sameType(this.parentType, this.namedFragment.typeCondition) && this.element.appliedDirectives.length === 0
-      ? expandedSubSelections.selections()
-      : new InlineFragmentSelection(this.element, expandedSubSelections);
-  }
-
-  expandFragments(names: string[], updatedFragments: NamedFragments | undefined): FragmentSelection | readonly Selection[] {
-    if (!names.includes(this.namedFragment.name)) {
+  expandFragments(updatedFragments: NamedFragments | undefined): FragmentSelection | readonly Selection[] {
+    // Note that this test will always fail if `updatedFragments` is `undefined`, making us expand everything.
+    if (updatedFragments?.has(this.namedFragment.name)) {
+      // This one is still there, it's not expanded.
       return this;
     }
 
-    const expandedSubSelections = this.selectionSet.expandFragments(names, updatedFragments);
+    const expandedSubSelections = this.selectionSet.expandFragments(updatedFragments);
     return sameType(this.parentType, this.namedFragment.typeCondition) && this.element.appliedDirectives.length === 0
       ? expandedSubSelections.selections()
       : new InlineFragmentSelection(this.element, expandedSubSelections);
   }
 
   collectUsedFragmentNames(collector: Map<string, number>): void {
-    this.selectionSet.collectUsedFragmentNames(collector);
     const usageCount = collector.get(this.namedFragment.name);
     collector.set(this.namedFragment.name, usageCount === undefined ? 1 : usageCount + 1);
   }
@@ -2953,14 +3443,16 @@ class FragmentSpreadSelection extends FragmentSelection {
       && sameDirectiveApplications(this.spreadDirectives, that.spreadDirectives);
   }
 
-  contains(that: Selection): boolean {
+  contains(that: Selection): ContainsResult {
     if (this.equals(that)) {
-      return true;
+      return ContainsResult.EQUAL;
     }
 
-    return (that instanceof FragmentSelection)
-      && this.element.equals(that.element)
-      && this.selectionSet.contains(that.selectionSet);
+    if (!(that instanceof FragmentSelection) || !this.element.equals(that.element)) {
+      return ContainsResult.NOT_CONTAINED;
+    }
+
+    return  this.selectionSet.contains(that.selectionSet);
   }
 
   toString(expandFragments: boolean = true, indent?: string): string {
@@ -2985,7 +3477,6 @@ function selectionSetOfNode(
     return selectionSetOf(
       parentType,
       selectionOfNode(parentType, node.selections[0], variableDefinitions, fragments, fieldAccessor),
-      fragments,
     );
   }
 
@@ -3117,6 +3608,7 @@ function operationFromAST({
 }) : Operation {
   const rootType = schema.schemaDefinition.root(operation.operation);
   validate(rootType, () => `The schema has no "${operation.operation}" root type defined`);
+  const fragmentsIfAny = fragments.isEmpty() ? undefined : fragments;
   return new Operation(
     schema,
     operation.operation,
@@ -3124,10 +3616,11 @@ function operationFromAST({
       parentType: rootType.type,
       source: operation.selectionSet,
       variableDefinitions,
-      fragments: fragments.isEmpty() ? undefined : fragments,
+      fragments: fragmentsIfAny,
       validate: validateInput,
     }),
     variableDefinitions,
+    fragmentsIfAny,
     operation.name?.value
   );
 }
@@ -3184,8 +3677,8 @@ export function operationToDocument(operation: Operation): DocumentNode {
     selectionSet: operation.selectionSet.toSelectionSetNode(),
     variableDefinitions: operation.variableDefinitions.toVariableDefinitionNodes(),
   };
-  const fragmentASTs: DefinitionNode[] = operation.selectionSet.fragments
-    ? operation.selectionSet.fragments?.toFragmentDefinitionNodes()
+  const fragmentASTs: DefinitionNode[] = operation.fragments
+    ? operation.fragments?.toFragmentDefinitionNodes()
     : [];
   return {
     kind: Kind.DOCUMENT,