houdini 1.0.11 → 1.1.1-next.0

package/build/vite-cjs/index.js

@@ -7511,7 +7511,7 @@ var require_definition = __commonJS({
     exports.assertLeafType = assertLeafType;
     exports.isCompositeType = isCompositeType;
     exports.assertCompositeType = assertCompositeType;
-    exports.isAbstractType = isAbstractType3;
+    exports.isAbstractType = isAbstractType4;
     exports.assertAbstractType = assertAbstractType;
     exports.GraphQLList = GraphQLList6;
     exports.GraphQLNonNull = GraphQLNonNull6;
@@ -7682,11 +7682,11 @@ var require_definition = __commonJS({
       }
       return type;
     }
-    function isAbstractType3(type) {
+    function isAbstractType4(type) {
       return isInterfaceType12(type) || isUnionType13(type);
     }
     function assertAbstractType(type) {
-      if (!isAbstractType3(type)) {
+      if (!isAbstractType4(type)) {
         throw new Error("Expected ".concat((0, _inspect.default)(type), " to be a GraphQL abstract type."));
       }
       return type;
@@ -10950,8 +10950,8 @@ var require_KnownFragmentNamesRule = __commonJS({
       return {
         FragmentSpread: function FragmentSpread(node) {
           var fragmentName = node.name.value;
-          var fragment = context.getFragment(fragmentName);
-          if (!fragment) {
+          var fragment2 = context.getFragment(fragmentName);
+          if (!fragment2) {
             context.reportError(new _GraphQLError.GraphQLError('Unknown fragment "'.concat(fragmentName, '".'), node.name));
           }
         }
@@ -10987,8 +10987,8 @@ var require_NoUnusedFragmentsRule = __commonJS({
             for (var _i2 = 0; _i2 < operationDefs.length; _i2++) {
               var operation = operationDefs[_i2];
               for (var _i4 = 0, _context$getRecursive2 = context.getRecursivelyReferencedFragments(operation); _i4 < _context$getRecursive2.length; _i4++) {
-                var fragment = _context$getRecursive2[_i4];
-                fragmentNameUsed[fragment.name.value] = true;
+                var fragment2 = _context$getRecursive2[_i4];
+                fragmentNameUsed[fragment2.name.value] = true;
               }
             }
             for (var _i6 = 0; _i6 < fragmentDefs.length; _i6++) {
@@ -11078,13 +11078,13 @@ var require_NoFragmentCyclesRule = __commonJS({
           return false;
         }
       };
-      function detectCycleRecursive(fragment) {
-        if (visitedFrags[fragment.name.value]) {
+      function detectCycleRecursive(fragment2) {
+        if (visitedFrags[fragment2.name.value]) {
           return;
         }
-        var fragmentName = fragment.name.value;
+        var fragmentName = fragment2.name.value;
         visitedFrags[fragmentName] = true;
-        var spreadNodes = context.getFragmentSpreads(fragment.selectionSet);
+        var spreadNodes = context.getFragmentSpreads(fragment2.selectionSet);
         if (spreadNodes.length === 0) {
           return;
         }
@@ -11905,11 +11905,11 @@ var require_OverlappingFieldsCanBeMergedRule = __commonJS({
       return conflicts;
     }
     function collectConflictsBetweenFieldsAndFragment(context, conflicts, cachedFieldsAndFragmentNames, comparedFragmentPairs, areMutuallyExclusive, fieldMap, fragmentName) {
-      var fragment = context.getFragment(fragmentName);
-      if (!fragment) {
+      var fragment2 = context.getFragment(fragmentName);
+      if (!fragment2) {
         return;
       }
-      var _getReferencedFieldsA = getReferencedFieldsAndFragmentNames(context, cachedFieldsAndFragmentNames, fragment), fieldMap2 = _getReferencedFieldsA[0], fragmentNames2 = _getReferencedFieldsA[1];
+      var _getReferencedFieldsA = getReferencedFieldsAndFragmentNames(context, cachedFieldsAndFragmentNames, fragment2), fieldMap2 = _getReferencedFieldsA[0], fragmentNames2 = _getReferencedFieldsA[1];
       if (fieldMap === fieldMap2) {
         return;
       }
@@ -12080,38 +12080,38 @@ var require_OverlappingFieldsCanBeMergedRule = __commonJS({
       }
       return cached;
     }
-    function getReferencedFieldsAndFragmentNames(context, cachedFieldsAndFragmentNames, fragment) {
-      var cached = cachedFieldsAndFragmentNames.get(fragment.selectionSet);
+    function getReferencedFieldsAndFragmentNames(context, cachedFieldsAndFragmentNames, fragment2) {
+      var cached = cachedFieldsAndFragmentNames.get(fragment2.selectionSet);
       if (cached) {
         return cached;
       }
-      var fragmentType = (0, _typeFromAST.typeFromAST)(context.getSchema(), fragment.typeCondition);
-      return getFieldsAndFragmentNames(context, cachedFieldsAndFragmentNames, fragmentType, fragment.selectionSet);
+      var fragmentType = (0, _typeFromAST.typeFromAST)(context.getSchema(), fragment2.typeCondition);
+      return getFieldsAndFragmentNames(context, cachedFieldsAndFragmentNames, fragmentType, fragment2.selectionSet);
     }
     function _collectFieldsAndFragmentNames(context, parentType, selectionSet, nodeAndDefs, fragmentNames) {
       for (var _i9 = 0, _selectionSet$selecti2 = selectionSet.selections; _i9 < _selectionSet$selecti2.length; _i9++) {
-        var selection2 = _selectionSet$selecti2[_i9];
-        switch (selection2.kind) {
+        var selection = _selectionSet$selecti2[_i9];
+        switch (selection.kind) {
           case _kinds.Kind.FIELD: {
-            var fieldName = selection2.name.value;
+            var fieldName = selection.name.value;
             var fieldDef = void 0;
             if ((0, _definition.isObjectType)(parentType) || (0, _definition.isInterfaceType)(parentType)) {
               fieldDef = parentType.getFields()[fieldName];
             }
-            var responseName = selection2.alias ? selection2.alias.value : fieldName;
+            var responseName = selection.alias ? selection.alias.value : fieldName;
             if (!nodeAndDefs[responseName]) {
               nodeAndDefs[responseName] = [];
             }
-            nodeAndDefs[responseName].push([parentType, selection2, fieldDef]);
+            nodeAndDefs[responseName].push([parentType, selection, fieldDef]);
             break;
           }
           case _kinds.Kind.FRAGMENT_SPREAD:
-            fragmentNames[selection2.name.value] = true;
+            fragmentNames[selection.name.value] = true;
             break;
           case _kinds.Kind.INLINE_FRAGMENT: {
-            var typeCondition = selection2.typeCondition;
+            var typeCondition = selection.typeCondition;
             var inlineFragmentType = typeCondition ? (0, _typeFromAST.typeFromAST)(context.getSchema(), typeCondition) : parentType;
-            _collectFieldsAndFragmentNames(context, inlineFragmentType, selection2.selectionSet, nodeAndDefs, fragmentNames);
+            _collectFieldsAndFragmentNames(context, inlineFragmentType, selection.selectionSet, nodeAndDefs, fragmentNames);
             break;
           }
         }
@@ -12647,11 +12647,11 @@ var require_ValidationContext = __commonJS({
           while (setsToVisit.length !== 0) {
             var set = setsToVisit.pop();
             for (var _i2 = 0, _set$selections2 = set.selections; _i2 < _set$selections2.length; _i2++) {
-              var selection2 = _set$selections2[_i2];
-              if (selection2.kind === _kinds.Kind.FRAGMENT_SPREAD) {
-                spreads.push(selection2);
-              } else if (selection2.selectionSet) {
-                setsToVisit.push(selection2.selectionSet);
+              var selection = _set$selections2[_i2];
+              if (selection.kind === _kinds.Kind.FRAGMENT_SPREAD) {
+                spreads.push(selection);
+              } else if (selection.selectionSet) {
+                setsToVisit.push(selection.selectionSet);
               }
             }
           }
@@ -12672,10 +12672,10 @@ var require_ValidationContext = __commonJS({
               var fragName = spread.name.value;
               if (collectedNames[fragName] !== true) {
                 collectedNames[fragName] = true;
-                var fragment = this.getFragment(fragName);
-                if (fragment) {
-                  fragments.push(fragment);
-                  nodesToVisit.push(fragment.selectionSet);
+                var fragment2 = this.getFragment(fragName);
+                if (fragment2) {
+                  fragments.push(fragment2);
+                  nodesToVisit.push(fragment2.selectionSet);
                 }
               }
             }
@@ -13588,37 +13588,37 @@ var require_execute = __commonJS({
     }
     function collectFields(exeContext, runtimeType, selectionSet, fields, visitedFragmentNames) {
       for (var _i6 = 0, _selectionSet$selecti2 = selectionSet.selections; _i6 < _selectionSet$selecti2.length; _i6++) {
-        var selection2 = _selectionSet$selecti2[_i6];
-        switch (selection2.kind) {
+        var selection = _selectionSet$selecti2[_i6];
+        switch (selection.kind) {
           case _kinds.Kind.FIELD: {
-            if (!shouldIncludeNode(exeContext, selection2)) {
+            if (!shouldIncludeNode(exeContext, selection)) {
               continue;
             }
-            var name = getFieldEntryKey(selection2);
+            var name = getFieldEntryKey(selection);
             if (!fields[name]) {
               fields[name] = [];
             }
-            fields[name].push(selection2);
+            fields[name].push(selection);
             break;
           }
           case _kinds.Kind.INLINE_FRAGMENT: {
-            if (!shouldIncludeNode(exeContext, selection2) || !doesFragmentConditionMatch(exeContext, selection2, runtimeType)) {
+            if (!shouldIncludeNode(exeContext, selection) || !doesFragmentConditionMatch(exeContext, selection, runtimeType)) {
               continue;
             }
-            collectFields(exeContext, runtimeType, selection2.selectionSet, fields, visitedFragmentNames);
+            collectFields(exeContext, runtimeType, selection.selectionSet, fields, visitedFragmentNames);
             break;
           }
           case _kinds.Kind.FRAGMENT_SPREAD: {
-            var fragName = selection2.name.value;
-            if (visitedFragmentNames[fragName] || !shouldIncludeNode(exeContext, selection2)) {
+            var fragName = selection.name.value;
+            if (visitedFragmentNames[fragName] || !shouldIncludeNode(exeContext, selection)) {
               continue;
             }
             visitedFragmentNames[fragName] = true;
-            var fragment = exeContext.fragments[fragName];
-            if (!fragment || !doesFragmentConditionMatch(exeContext, fragment, runtimeType)) {
+            var fragment2 = exeContext.fragments[fragName];
+            if (!fragment2 || !doesFragmentConditionMatch(exeContext, fragment2, runtimeType)) {
               continue;
             }
-            collectFields(exeContext, runtimeType, fragment.selectionSet, fields, visitedFragmentNames);
+            collectFields(exeContext, runtimeType, fragment2.selectionSet, fields, visitedFragmentNames);
             break;
           }
         }
@@ -13636,8 +13636,8 @@ var require_execute = __commonJS({
       }
       return true;
     }
-    function doesFragmentConditionMatch(exeContext, fragment, type) {
-      var typeConditionNode = fragment.typeCondition;
+    function doesFragmentConditionMatch(exeContext, fragment2, type) {
+      var typeConditionNode = fragment2.typeCondition;
       if (!typeConditionNode) {
         return true;
       }
@@ -65340,14 +65340,14 @@ function deepEquals(objA, objB, map = /* @__PURE__ */ new WeakMap()) {
 }
 
 // src/runtime/lib/selection.ts
-function getFieldsForType(selection2, __typename) {
-  let targetSelection = selection2.fields || {};
-  if (selection2.abstractFields && __typename) {
-    const mappedType = selection2.abstractFields.typeMap[__typename];
+function getFieldsForType(selection, __typename) {
+  let targetSelection = selection.fields || {};
+  if (selection.abstractFields && __typename) {
+    const mappedType = selection.abstractFields.typeMap[__typename];
     if (mappedType) {
-      targetSelection = selection2.abstractFields.fields[mappedType];
-    } else if (selection2.abstractFields.fields[__typename]) {
-      targetSelection = selection2.abstractFields.fields[__typename];
+      targetSelection = selection.abstractFields.fields[mappedType];
+    } else if (selection.abstractFields.fields[__typename]) {
+      targetSelection = selection.abstractFields.fields[__typename];
     }
   }
   return targetSelection;
@@ -65355,7 +65355,7 @@ function getFieldsForType(selection2, __typename) {
 
 // src/runtime/lib/scalars.ts
 async function marshalSelection({
-  selection: selection2,
+  selection,
   data
 }) {
   const config4 = getCurrentConfig();
@@ -65363,18 +65363,18 @@ async function marshalSelection({
     return data;
   }
   if (Array.isArray(data)) {
-    return await Promise.all(data.map((val) => marshalSelection({ selection: selection2, data: val })));
+    return await Promise.all(data.map((val) => marshalSelection({ selection, data: val })));
   }
-  const targetSelection = getFieldsForType(selection2, data["__typename"]);
+  const targetSelection = getFieldsForType(selection, data["__typename"]);
   return Object.fromEntries(
     await Promise.all(
       Object.entries(data).map(async ([fieldName, value]) => {
-        const { type, selection: selection3 } = targetSelection[fieldName];
+        const { type, selection: selection2 } = targetSelection[fieldName];
         if (!type) {
           return [fieldName, value];
         }
-        if (selection3) {
-          return [fieldName, await marshalSelection({ selection: selection3, data: value })];
+        if (selection2) {
+          return [fieldName, await marshalSelection({ selection: selection2, data: value })];
         }
         if (config4.scalars?.[type]) {
           const marshalFn = config4.scalars[type].marshal;
@@ -65425,6 +65425,7 @@ var DataSource = {
   Network: "network",
   Ssr: "ssr"
 };
+var fragmentKey = " $fragments";
 
 // src/runtime/lib/key.ts
 var computeKey = ({ field, args }) => {
@@ -67167,7 +67168,7 @@ var List = class {
     recordType,
     key,
     listType,
-    selection: selection2,
+    selection,
     when,
     filters,
     connection,
@@ -67179,7 +67180,7 @@ var List = class {
     this.key = key;
     this.type = listType;
     this.cache = manager.cache;
-    this.selection = selection2;
+    this.selection = selection;
     this._when = when;
     this.filters = filters;
     this.name = name;
@@ -67190,19 +67191,19 @@ var List = class {
   when(when) {
     return this.manager.lists.get(this.name).get(this.recordID).when(when);
   }
-  append(selection2, data, variables = {}) {
-    return this.addToList(selection2, data, variables, "last");
+  append(selection, data, variables = {}) {
+    return this.addToList(selection, data, variables, "last");
   }
-  prepend(selection2, data, variables = {}) {
-    return this.addToList(selection2, data, variables, "first");
+  prepend(selection, data, variables = {}) {
+    return this.addToList(selection, data, variables, "first");
   }
-  addToList(selection2, data, variables = {}, where) {
+  addToList(selection, data, variables = {}, where) {
     const listType = this.listType(data);
     const dataID = this.cache._internal_unstable.id(listType, data);
     if (!this.validateWhen() || !dataID) {
       return;
     }
-    let insertSelection = selection2;
+    let insertSelection = selection;
     let insertData = data;
     if (this.connection) {
       insertSelection = {
@@ -67222,9 +67223,9 @@ var List = class {
                         type: listType,
                         keyRaw: "node",
                         selection: {
-                          ...selection2,
+                          ...selection,
                           fields: {
-                            ...selection2.fields,
+                            ...selection.fields,
                             __typename: {
                               keyRaw: "__typename",
                               type: "String"
@@ -67253,9 +67254,9 @@ var List = class {
             type: listType,
             updates: ["append", "prepend"],
             selection: {
-              ...selection2,
+              ...selection,
               fields: {
-                ...selection2.fields,
+                ...selection.fields,
                 __typename: {
                   keyRaw: "__typename",
                   type: "String"
@@ -67330,7 +67331,8 @@ var List = class {
         this.cache._internal_unstable.getSelection({
           parent: spec.parentID || this.manager.rootID,
           selection: spec.selection,
-          variables: spec.variables?.() || {}
+          variables: spec.variables?.() || {},
+          ignoreMasking: false
         }).data
       );
     }
@@ -67366,9 +67368,9 @@ var List = class {
     }
     return ok;
   }
-  toggleElement(selection2, data, variables = {}, where) {
+  toggleElement(selection, data, variables = {}, where) {
     if (!this.remove(data, variables)) {
-      this.addToList(selection2, data, variables, where);
+      this.addToList(selection, data, variables, where);
     }
   }
   *[Symbol.iterator]() {
@@ -67943,14 +67945,24 @@ var InMemorySubscriptions = class {
   add({
     parent,
     spec,
-    selection: selection2,
+    selection,
     variables,
     parentType
   }) {
     const __typename = this.cache._internal_unstable.storage.get(parent, "__typename").value;
-    let targetSelection = getFieldsForType(selection2, __typename);
+    let targetSelection = getFieldsForType(selection, __typename);
     for (const fieldSelection of Object.values(targetSelection || {})) {
-      const { keyRaw, selection: innerSelection, type, list, filters } = fieldSelection;
+      const {
+        keyRaw,
+        selection: innerSelection,
+        type,
+        list,
+        filters,
+        visible
+      } = fieldSelection;
+      if (!visible) {
+        continue;
+      }
       const key = evaluateKey(keyRaw, variables);
       let targetSelection2;
       if (innerSelection) {
@@ -67998,10 +68010,10 @@ var InMemorySubscriptions = class {
   addFieldSubscription({
     id,
     key,
-    selection: selection2,
+    selection,
     type
   }) {
-    const spec = selection2[0];
+    const spec = selection[0];
     if (!this.subscribers[id]) {
       this.subscribers[id] = {};
     }
@@ -68013,7 +68025,7 @@ var InMemorySubscriptions = class {
     }
     this.keyVersions[key].add(key);
     if (!this.subscribers[id][key].map(([{ set }]) => set).includes(spec.set)) {
-      this.subscribers[id][key].push([spec, selection2[1]]);
+      this.subscribers[id][key].push([spec, selection[1]]);
     }
     if (!this.referenceCounts[id]) {
       this.referenceCounts[id] = {};
@@ -68024,14 +68036,13 @@ var InMemorySubscriptions = class {
     const counts = this.referenceCounts[id][key];
     counts.set(spec.set, (counts.get(spec.set) || 0) + 1);
     this.cache._internal_unstable.lifetimes.resetLifetime(id, key);
-    const { selection: innerSelection } = selection2[1]?.[key] ?? {};
   }
   registerList({
     list,
     id,
     key,
     parentType,
-    selection: selection2,
+    selection,
     filters,
     variables
   }) {
@@ -68042,7 +68053,7 @@ var InMemorySubscriptions = class {
       recordType: this.cache._internal_unstable.storage.get(id, "__typename")?.value || parentType,
       listType: list.type,
       key,
-      selection: selection2,
+      selection,
       filters: Object.entries(filters || {}).reduce((acc, [key2, { kind, value }]) => {
         return {
           ...acc,
@@ -68058,14 +68069,14 @@ var InMemorySubscriptions = class {
     parentType
   }) {
     for (const [spec, targetSelection] of subscribers) {
-      for (const selection2 of Object.values(targetSelection ?? {})) {
+      for (const selection of Object.values(targetSelection ?? {})) {
         const {
           type: linkedType,
           keyRaw,
           selection: innerSelection,
           list,
           filters
-        } = selection2;
+        } = selection;
         const key = evaluateKey(keyRaw, variables);
         const fieldSelection = innerSelection ? getFieldsForType(innerSelection, parentType) : void 0;
         this.addFieldSubscription({
@@ -68085,7 +68096,7 @@ var InMemorySubscriptions = class {
             parentType: parentType || spec.rootType
           });
         }
-        const childSelection = selection2.selection;
+        const childSelection = selection.selection;
         if (childSelection) {
           const { value: link } = this.cache._internal_unstable.storage.get(parent, key);
           const children = !Array.isArray(link) ? [link] : flatten(link);
@@ -68112,11 +68123,11 @@ var InMemorySubscriptions = class {
   get(id, field) {
     return this.subscribers[id]?.[field] || [];
   }
-  remove(id, selection2, targets, variables, visited = []) {
+  remove(id, selection, targets, variables, visited = []) {
     visited.push(id);
     const linkedIDs = [];
     const __typename = this.cache._internal_unstable.storage.get(id, "__typename").value;
-    let targetSelection = getFieldsForType(selection2, __typename);
+    let targetSelection = getFieldsForType(selection, __typename);
     for (const fieldSelection of Object.values(targetSelection || {})) {
       const key = evaluateKey(fieldSelection.keyRaw, variables);
       this.removeSubscribers(id, key, targets);
@@ -68178,7 +68189,7 @@ var InMemorySubscriptions = class {
 // src/runtime/cache/cache.ts
 var Cache = class {
   _internal_unstable;
-  constructor(config4) {
+  constructor({ disabled, ...config4 } = {}) {
     this._internal_unstable = new CacheInternal({
       cache: this,
       storage: new InMemoryStorage(),
@@ -68186,9 +68197,10 @@ var Cache = class {
       lists: new ListManager(this, rootID),
       lifetimes: new GarbageCollector(this),
       staleManager: new StaleManager(this),
-      schema: new SchemaManager(this)
+      schema: new SchemaManager(this),
+      disabled: disabled ?? typeof globalThis.window === "undefined"
     });
-    if (config4) {
+    if (Object.keys(config4).length > 0) {
       this.setConfig(defaultConfigValues(config4));
     }
   }
@@ -68207,7 +68219,8 @@ var Cache = class {
           this._internal_unstable.getSelection({
             parent: spec.parentID || rootID,
             selection: spec.selection,
-            variables: spec.variables?.() || {}
+            variables: spec.variables?.() || {},
+            ignoreMasking: false
           }).data
         );
       }
@@ -68282,16 +68295,13 @@ var Cache = class {
   getFieldTime(id, field) {
     return this._internal_unstable.staleManager.getFieldTime(id, field);
   }
+  config() {
+    return this._internal_unstable.config;
+  }
 };
 var CacheInternal = class {
   _disabled = false;
-  config = defaultConfigValues({
-    plugins: {
-      "houdini-svelte": {
-        client: ""
-      }
-    }
-  });
+  _config;
   storage;
   subscriptions;
   lists;
@@ -68306,7 +68316,9 @@ var CacheInternal = class {
     cache,
     lifetimes,
     staleManager,
-    schema
+    schema,
+    disabled,
+    config: config4
   }) {
     this.storage = storage;
     this.subscriptions = subscriptions;
@@ -68315,7 +68327,8 @@ var CacheInternal = class {
     this.lifetimes = lifetimes;
     this.staleManager = staleManager;
     this.schema = schema;
-    this._disabled = typeof globalThis.window === "undefined";
+    this._config = config4;
+    this._disabled = disabled;
     try {
       if (process.env.HOUDINI_TEST === "true") {
         this._disabled = false;
@@ -68323,12 +68336,15 @@ var CacheInternal = class {
     } catch {
     }
   }
+  get config() {
+    return this._config ?? getCurrentConfig();
+  }
   setConfig(config4) {
-    this.config = config4;
+    this._config = config4;
   }
   writeSelection({
     data,
-    selection: selection2,
+    selection,
     variables = {},
     parent = rootID,
     applyUpdates,
@@ -68340,9 +68356,9 @@ var CacheInternal = class {
     if (this._disabled) {
       return [];
     }
-    let targetSelection = getFieldsForType(selection2, data["__typename"]);
+    let targetSelection = getFieldsForType(selection, data["__typename"]);
     for (const [field, value] of Object.entries(data)) {
-      if (!selection2 || !targetSelection[field]) {
+      if (!selection || !targetSelection[field]) {
         continue;
       }
       let {
@@ -68598,25 +68614,40 @@ var CacheInternal = class {
     return toNotify;
   }
   getSelection({
-    selection: selection2,
+    selection,
     parent = rootID,
     variables,
-    stepsFromConnection = null
+    stepsFromConnection = null,
+    ignoreMasking
   }) {
     if (parent === null) {
       return { data: null, partial: false, stale: false, hasData: true };
     }
     const target = {};
+    if (selection.fragments) {
+      target[fragmentKey] = Object.fromEntries(
+        Object.entries(selection.fragments).map(([key, value]) => [
+          key,
+          {
+            parent,
+            variables: evaluateFragmentVariables(value, variables ?? {})
+          }
+        ])
+      );
+    }
     let hasData = false;
     let partial = false;
     let cascadeNull = false;
     let stale = false;
     const typename = this.storage.get(parent, "__typename").value;
-    let targetSelection = getFieldsForType(selection2, typename);
+    let targetSelection = getFieldsForType(selection, typename);
     for (const [
       attributeName,
-      { type, keyRaw, selection: fieldSelection, nullable, list }
+      { type, keyRaw, selection: fieldSelection, nullable, list, visible }
     ] of Object.entries(targetSelection)) {
+      if (!visible && !ignoreMasking) {
+        continue;
+      }
       const key = evaluateKey(keyRaw, variables);
       const { value } = this.storage.get(parent, key);
       const dt_field = this.staleManager.getFieldTime(parent, key);
@@ -68656,7 +68687,8 @@ var CacheInternal = class {
           fields: fieldSelection,
           variables,
           linkedList: value,
-          stepsFromConnection: nextStep
+          stepsFromConnection: nextStep,
+          ignoreMasking: !!ignoreMasking
         });
         target[attributeName] = listValue.data;
         if (listValue.partial) {
@@ -68673,7 +68705,8 @@ var CacheInternal = class {
           parent: value,
           selection: fieldSelection,
           variables,
-          stepsFromConnection: nextStep
+          stepsFromConnection: nextStep,
+          ignoreMasking
         });
         target[attributeName] = objectFields.data;
         if (objectFields.partial) {
@@ -68717,7 +68750,8 @@ var CacheInternal = class {
     fields,
     variables,
     linkedList,
-    stepsFromConnection
+    stepsFromConnection,
+    ignoreMasking
   }) {
     const result = [];
     let partialData = false;
@@ -68729,7 +68763,8 @@ var CacheInternal = class {
           fields,
           variables,
           linkedList: entry,
-          stepsFromConnection
+          stepsFromConnection,
+          ignoreMasking
         });
         result.push(nestedValue.data);
         if (nestedValue.partial) {
@@ -68750,7 +68785,8 @@ var CacheInternal = class {
         parent: entry,
         selection: fields,
         variables,
-        stepsFromConnection
+        stepsFromConnection,
+        ignoreMasking
       });
       result.push(data);
       if (partial) {
@@ -68853,11 +68889,54 @@ var CacheInternal = class {
     }
   }
 };
+function evaluateFragmentVariables(variables, args) {
+  return Object.fromEntries(
+    Object.entries(variables).map(([key, value]) => [key, fragmentVariableValue(value, args)])
+  );
+}
+function fragmentVariableValue(value, args) {
+  if (value.kind === "StringValue") {
+    return value.value;
+  }
+  if (value.kind === "BooleanValue") {
+    return value.value;
+  }
+  if (value.kind === "EnumValue") {
+    return value.value;
+  }
+  if (value.kind === "FloatValue") {
+    return parseFloat(value.value);
+  }
+  if (value.kind === "IntValue") {
+    return parseInt(value.value, 10);
+  }
+  if (value.kind === "NullValue") {
+    return null;
+  }
+  if (value.kind === "Variable") {
+    return args[value.name.value];
+  }
+  if (value.kind === "ListValue") {
+    return value.values.map((value2) => fragmentVariableValue(value2, args));
+  }
+  if (value.kind === "ObjectValue") {
+    return value.fields.reduce(
+      (obj, field) => ({
+        ...obj,
+        [field.name.value]: fragmentVariableValue(field.value, args)
+      }),
+      {}
+    );
+  }
+}
 var rootID = "_ROOT_";
 
 // src/runtime/cache/index.ts
 var cache_default = new Cache();
 
+// src/runtime/client/plugins/cache.ts
+var serverSide = typeof globalThis.window === "undefined";
+
 // src/runtime/client/utils/documentPlugins.ts
 var documentPlugin = (kind, source) => {
   return () => {
@@ -68893,7 +68972,6 @@ var documentPlugin = (kind, source) => {
 var query = documentPlugin(ArtifactKind.Query, function() {
   let subscriptionSpec = null;
   let lastVariables = null;
-  let artifactName = "";
   return {
     start(ctx, { next }) {
       ctx.variables = {
@@ -68903,8 +68981,7 @@ var query = documentPlugin(ArtifactKind.Query, function() {
       next(ctx);
     },
     end(ctx, { resolve: resolve2, marshalVariables, variablesChanged }) {
-      if (variablesChanged(ctx)) {
-        artifactName = ctx.artifact.name;
+      if (variablesChanged(ctx) && !ctx.cacheParams?.disableSubscriptions) {
         if (subscriptionSpec) {
           cache_default.unsubscribe(subscriptionSpec, subscriptionSpec.variables?.() || {});
         }
@@ -68925,19 +69002,61 @@ var query = documentPlugin(ArtifactKind.Query, function() {
             });
           }
         };
-        cache_default.subscribe(subscriptionSpec, lastVariables ?? {});
+        cache_default.subscribe(subscriptionSpec, lastVariables);
       }
       resolve2(ctx);
     },
     cleanup() {
       if (subscriptionSpec) {
-        cache_default.unsubscribe(subscriptionSpec, subscriptionSpec.variables?.() ?? {});
+        cache_default.unsubscribe(subscriptionSpec, subscriptionSpec.variables?.());
         lastVariables = null;
       }
     }
   };
 });
 
+// src/runtime/client/plugins/fragment.ts
+var fragment = documentPlugin(ArtifactKind.Fragment, function() {
+  let subscriptionSpec = null;
+  return {
+    start(ctx, { next, resolve: resolve2, variablesChanged, marshalVariables }) {
+      if (!ctx.stuff.parentID) {
+        return next(ctx);
+      }
+      if (variablesChanged(ctx) && !ctx.cacheParams?.disableSubscriptions) {
+        if (subscriptionSpec) {
+          cache_default.unsubscribe(subscriptionSpec, subscriptionSpec.variables?.() || {});
+        }
+        const variables = marshalVariables(ctx);
+        subscriptionSpec = {
+          rootType: ctx.artifact.rootType,
+          selection: ctx.artifact.selection,
+          variables: () => variables,
+          parentID: ctx.stuff.parentID,
+          set: (newValue) => {
+            resolve2(ctx, {
+              data: newValue,
+              errors: null,
+              fetching: false,
+              partial: false,
+              stale: false,
+              source: DataSource.Cache,
+              variables
+            });
+          }
+        };
+        cache_default.subscribe(subscriptionSpec, variables);
+      }
+      next(ctx);
+    },
+    cleanup() {
+      if (subscriptionSpec) {
+        cache_default.unsubscribe(subscriptionSpec, subscriptionSpec.variables?.());
+      }
+    }
+  };
+});
+
 // src/runtime/client/plugins/mutation.ts
 var mutation = documentPlugin(ArtifactKind.Mutation, () => {
   return {
@@ -69094,6 +69213,7 @@ var Config = class {
     this.schemaPollInterval = watchSchema?.interval ?? 2e3;
     this.schemaPollHeaders = watchSchema?.headers ?? {};
     this.rootDir = join2(this.projectRoot, "$houdini");
+    this.#fragmentVariableMaps = {};
     if (defaultKeys) {
       this.defaultKeys = defaultKeys;
     }
@@ -69243,7 +69363,7 @@ var Config = class {
     return `$houdini/${this.artifactDirectoryName}/${name}`;
   }
   keyFieldsForType(type) {
-    return keyFieldsForType(this.configFile, type);
+    return this.schema.getQueryType()?.name === type ? [] : keyFieldsForType(this.configFile, type);
   }
   computeID(type, data) {
     return computeID(this.configFile, type, data);
@@ -69262,7 +69382,7 @@ var Config = class {
       ({ kind }) => kind === graphql2.Kind.FRAGMENT_DEFINITION
     );
     if (fragmentDefinitions.length) {
-      return fragmentDefinitions.map((fragment) => fragment.name.value).join("_");
+      return fragmentDefinitions[0].name.value;
     }
     throw new Error("Could not generate artifact name for document: " + graphql2.print(document));
   }
@@ -69434,6 +69554,56 @@ var Config = class {
     }, []) ?? [];
     return !defaultDirectives.includes(name) && (internalDirectives.includes(name) || this.isDeleteDirective(name));
   }
+  #fragmentVariableMaps;
+  registerFragmentVariablesHash({
+    hash,
+    args,
+    fragment: fragment2
+  }) {
+    this.#fragmentVariableMaps[hash] = {
+      args: this.#serializeValueMap(args),
+      fragment: fragment2
+    };
+  }
+  getFragmentVariablesHash(hash) {
+    return this.#fragmentVariableMaps[hash] ?? {
+      fragment: hash,
+      args: {},
+      hash
+    };
+  }
+  #serializeValueMap(map) {
+    if (!map) {
+      return null;
+    }
+    return Object.fromEntries(
+      Object.entries(map).map(([key, input]) => {
+        const result = {
+          kind: input.kind
+        };
+        if (typeof input === "object") {
+          if ("value" in input) {
+            result.value = input.value;
+          }
+          if ("values" in input) {
+            result.values = input.values.map(
+              (value) => this.#serializeValueMap({ foo: value }).foo
+            );
+          }
+          if ("name" in input) {
+            result.name = input.name;
+          }
+          if ("fields" in input) {
+            result.fields = input.fields.map((field) => ({
+              name: field.name,
+              value: this.#serializeValueMap({ foo: field.value }).foo
+            }));
+          }
+        }
+        return [key, result];
+      })
+    );
+  }
   isListFragment(name) {
     return name.endsWith(this.insertFragmentSuffix) || name.endsWith(this.removeFragmentSuffix) || name.endsWith(this.toggleFragmentSuffix);
   }
@@ -69935,11 +70105,17 @@ function deepMerge(filepath, ...targets) {
     if (targets.length === 1) {
       return targets[0];
     } else if (targets.length === 2) {
-      return (0, import_deepmerge.default)(targets[0], targets[1]);
+      return (0, import_deepmerge.default)(targets[0], targets[1], {
+        arrayMerge: (source, update) => [...new Set(source.concat(update))]
+      });
     }
     return deepMerge(filepath, targets[0], deepMerge(filepath, ...targets.slice(1)));
   } catch (e2) {
-    throw new HoudiniError({ filepath, message: "could not merge: " + targets });
+    throw new HoudiniError({
+      filepath,
+      message: "could not merge: " + targets,
+      description: e2.message
+    });
   }
 }
 
@@ -70167,16 +70343,16 @@ function flattenSelections({
   filepath,
   selections,
   fragmentDefinitions,
-  applyFragments,
-  ignoreMaskDisable
+  ignoreMaskDisable,
+  keepFragmentSpreadNodes
 }) {
   const fields = new FieldCollection({
     config: config4,
     filepath,
     selections,
     fragmentDefinitions,
-    applyFragments,
-    ignoreMaskDisable: !!ignoreMaskDisable
+    ignoreMaskDisable: !!ignoreMaskDisable,
+    keepFragmentSpreadNodes: !!keepFragmentSpreadNodes
   });
   return fields.toSelectionSet();
 }
@@ -70187,57 +70363,60 @@ var FieldCollection = class {
   fields;
   inlineFragments;
   fragmentSpreads;
-  applyFragments;
   ignoreMaskDisable;
+  keepFragmentSpreadNodes;
   constructor(args) {
     this.config = args.config;
     this.fragmentDefinitions = args.fragmentDefinitions;
-    this.applyFragments = args.applyFragments;
     this.ignoreMaskDisable = args.ignoreMaskDisable;
+    this.keepFragmentSpreadNodes = args.keepFragmentSpreadNodes;
     this.fields = {};
     this.inlineFragments = {};
     this.fragmentSpreads = {};
     this.filepath = args.filepath;
-    for (const selection2 of args.selections) {
-      this.add(selection2);
+    for (const selection of args.selections) {
+      this.add(selection);
     }
   }
   get size() {
     return Object.keys(this.fields).length + Object.keys(this.inlineFragments).length + Object.keys(this.fragmentSpreads).length;
   }
-  add(selection2) {
-    if (selection2.kind === "Field") {
-      const key = selection2.alias?.value || selection2.name.value;
+  add(selection) {
+    if (selection.kind === "Field") {
+      const key = selection.alias?.value || selection.name.value;
       if (!this.fields[key]) {
         this.fields[key] = {
-          astNode: selection2,
+          astNode: selection,
           selection: this.empty()
         };
       }
-      for (const subselect of selection2.selectionSet?.selections || []) {
+      for (const subselect of selection.selectionSet?.selections || []) {
         this.fields[key].selection.add(subselect);
       }
+      this.fields[key].selection.fragmentSpreads = {
+        ...this.collectFragmentSpreads(selection.selectionSet?.selections ?? []),
+        ...this.fields[key].selection.fragmentSpreads
+      };
       return;
     }
-    if (selection2.kind === "InlineFragment" && !selection2.typeCondition) {
-      for (const subselect of selection2.selectionSet.selections) {
+    if (selection.kind === "InlineFragment" && !selection.typeCondition) {
+      for (const subselect of selection.selectionSet.selections) {
         this.add(subselect);
       }
     }
-    if (selection2.kind === "InlineFragment" && selection2.typeCondition) {
-      this.walkInlineFragment(selection2);
+    if (selection.kind === "InlineFragment" && selection.typeCondition) {
+      this.walkInlineFragment(selection);
       return;
     }
-    if (selection2.kind === "FragmentSpread") {
-      this.fragmentSpreads[selection2.name.value] = selection2;
+    if (selection.kind === "FragmentSpread") {
       let includeFragments = this.config.defaultFragmentMasking === "disable";
-      const maskEnableDirective = selection2.directives?.find(
+      const maskEnableDirective = selection.directives?.find(
         ({ name }) => name.value === this.config.maskEnableDirective
       );
       if (maskEnableDirective) {
         includeFragments = false;
       }
-      const maskDisableDirective = selection2.directives?.find(
+      const maskDisableDirective = selection.directives?.find(
         ({ name }) => name.value === this.config.maskDisableDirective
       );
       if (maskDisableDirective) {
@@ -70246,14 +70425,17 @@ var FieldCollection = class {
       if (this.ignoreMaskDisable) {
         includeFragments = true;
       }
-      if (!includeFragments || !this.applyFragments) {
+      if (this.keepFragmentSpreadNodes) {
+        this.fragmentSpreads[selection.name.value] = selection;
+      }
+      if (!includeFragments) {
         return;
       }
-      const definition = this.fragmentDefinitions[selection2.name.value];
+      const definition = this.fragmentDefinitions[selection.name.value];
       if (!definition) {
         throw new HoudiniError({
           filepath: this.filepath,
-          message: "Could not find referenced fragment definition: " + selection2.name.value
+          message: "Could not find referenced fragment definition: " + selection.name.value + "\n" + JSON.stringify(Object.keys(this.fragmentDefinitions), null, 4)
         });
       }
       this.add({
@@ -70272,37 +70454,67 @@ var FieldCollection = class {
       });
     }
   }
+  collectFragmentSpreads(selections, result = {}) {
+    for (const selection of selections) {
+      if (selection.kind === "Field") {
+        continue;
+      }
+      if (selection.kind === "InlineFragment") {
+        this.collectFragmentSpreads(selection.selectionSet.selections, result);
+        continue;
+      }
+      if (selection.kind === "FragmentSpread") {
+        result[selection.name.value] = selection;
+        continue;
+      }
+    }
+    return result;
+  }
   toSelectionSet() {
-    return Object.values(this.inlineFragments).flatMap((fragment) => {
-      if (fragment.selection.size === 0) {
+    return Object.values(this.inlineFragments).flatMap((fragment2) => {
+      if (fragment2.selection.size === 0) {
         return [];
       }
-      fragment.astNode = {
-        ...fragment.astNode,
+      fragment2.astNode = {
+        ...fragment2.astNode,
         selectionSet: {
-          ...fragment.astNode.selectionSet,
-          selections: fragment.selection.toSelectionSet()
+          ...fragment2.astNode.selectionSet,
+          selections: fragment2.selection.toSelectionSet()
         }
       };
-      return [fragment.astNode];
+      return [fragment2.astNode];
     }).concat(
       Object.values(this.fields).map((field) => {
-        if (field.astNode.selectionSet) {
-          field.astNode.selectionSet.selections = field.selection.toSelectionSet();
-        }
-        return field.astNode;
+        return {
+          ...field.astNode,
+          selectionSet: field.astNode.selectionSet ? {
+            kind: "SelectionSet",
+            selections: field.selection.toSelectionSet()
+          } : void 0
+        };
       })
-    ).concat(Object.values(this.fragmentSpreads));
+    ).concat(
+      Object.values(this.fragmentSpreads).map((spread) => {
+        return {
+          kind: "FragmentSpread",
+          name: {
+            kind: "Name",
+            value: spread.name.value
+          },
+          directives: spread.directives
+        };
+      })
+    );
   }
-  walkInlineFragment(selection2) {
-    const key = selection2.typeCondition.name.value;
+  walkInlineFragment(selection) {
+    const key = selection.typeCondition.name.value;
     if (!this.inlineFragments[key]) {
       this.inlineFragments[key] = {
-        astNode: selection2,
+        astNode: selection,
         selection: this.empty()
       };
     }
-    for (const subselect of selection2.selectionSet.selections || []) {
+    for (const subselect of selection.selectionSet.selections || []) {
       if (subselect.kind !== "InlineFragment" || !subselect.typeCondition) {
         this.inlineFragments[key].selection.add(subselect);
         continue;
@@ -70316,8 +70528,8 @@ var FieldCollection = class {
       fragmentDefinitions: this.fragmentDefinitions,
       selections: [],
       filepath: this.filepath,
-      applyFragments: this.applyFragments,
-      ignoreMaskDisable: this.ignoreMaskDisable
+      ignoreMaskDisable: this.ignoreMaskDisable,
+      keepFragmentSpreadNodes: this.keepFragmentSpreadNodes
     });
   }
 };
@@ -70395,13 +70607,13 @@ function murmurHash(str) {
 // src/codegen/transforms/fragmentVariables.ts
 var graphql5 = __toESM(require_graphql2(), 1);
 
-// src/codegen/transforms/composeQueries.ts
+// src/codegen/transforms/collectDefinitions.ts
 var import_graphql30 = __toESM(require_graphql2(), 1);
 async function includeFragmentDefinitions(config4, documents) {
-  const fragments = collectFragments(config4, documents);
+  const fragments = collectDefinitions(config4, documents);
   for (const [index, { name, document, filename }] of documents.entries()) {
     const operation = document.definitions.find(
-      ({ kind }) => kind === import_graphql30.Kind.OPERATION_DEFINITION
+      (def) => def.kind === import_graphql30.Kind.OPERATION_DEFINITION || def.kind === "FragmentDefinition"
     );
     if (!operation) {
       continue;
@@ -70420,7 +70632,7 @@ async function includeFragmentDefinitions(config4, documents) {
     };
   }
 }
-function collectFragments(config4, docs) {
+function collectDefinitions(config4, docs) {
   return docs.reduce((acc, doc) => {
     const definitions = doc.document.definitions.reduce(
       (prev, definition) => definition.kind !== "FragmentDefinition" ? prev : {
@@ -70444,11 +70656,11 @@ function findRequiredFragments(selectionSet) {
     return [];
   }
   const referencedFragments = [];
-  for (const selection2 of selectionSet.selections) {
-    if (selection2.kind === import_graphql30.Kind.FRAGMENT_SPREAD) {
-      referencedFragments.push(selection2.name.value);
-    } else if (selection2.selectionSet) {
-      referencedFragments.push(...findRequiredFragments(selection2.selectionSet));
+  for (const selection of selectionSet.selections) {
+    if (selection.kind === import_graphql30.Kind.FRAGMENT_SPREAD) {
+      referencedFragments.push(selection.name.value);
+    } else if (selection.selectionSet) {
+      referencedFragments.push(...findRequiredFragments(selection.selectionSet));
     }
   }
   return referencedFragments;
@@ -70481,7 +70693,7 @@ function flattenFragments(filepath, operation, fragments) {
 // src/codegen/transforms/fragmentVariables.ts
 var GraphqlKinds2 = graphql5.Kind;
 async function fragmentVariables(config4, documents) {
-  const fragments = collectFragments(config4, documents);
+  const fragments = collectDefinitions(config4, documents);
   const generatedFragments = {};
   const visitedFragments = /* @__PURE__ */ new Set();
   for (const doc2 of documents) {
@@ -70541,9 +70753,17 @@ function inlineFragmentArgs({
   ).reduce((acc, arg) => ({ ...acc, [arg.name]: arg }), {});
   const result = graphql5.visit(document, {
     FragmentSpread(node) {
+      if (!fragmentDefinitions[node.name.value]) {
+        throw new Error("Could not find definition for fragment" + node.name.value);
+      }
       const { definition } = fragmentDefinitions[node.name.value];
       let { args, hash } = collectWithArguments(config4, filepath, node, scope);
       const newFragmentName = `${node.name.value}${hash}`;
+      config4.registerFragmentVariablesHash({
+        hash: newFragmentName,
+        fragment: node.name.value,
+        args
+      });
       if (!visitedFragments.has(newFragmentName)) {
         visitedFragments.add(newFragmentName);
         const defaultArguments = collectDefaultArgumentValues(config4, filepath, definition);
@@ -70942,7 +71162,7 @@ function operationObject({
   listName,
   operationKind,
   type,
-  selection: selection2,
+  selection,
   filepath
 }) {
   let parentID;
@@ -70950,7 +71170,7 @@ function operationObject({
   let position = config4.internalListPosition;
   let allLists = config4.defaultListTarget ?? void 0;
   let operationWhen;
-  const internalDirectives = selection2.directives?.filter(
+  const internalDirectives = selection.directives?.filter(
     (directive) => config4.isInternalDirective(directive.name.value)
   );
   if (internalDirectives && internalDirectives.length > 0) {
@@ -71192,7 +71412,7 @@ async function paginate(config4, documents) {
       let fragmentName = "";
       let refetchQueryName = "";
       let nodeQuery = false;
-      let fragment = "";
+      let fragment2 = "";
       let paginateMode = config4.defaultPaginateMode;
       doc.document = graphql10.visit(doc.document, {
         OperationDefinition(node) {
@@ -71235,7 +71455,7 @@ async function paginate(config4, documents) {
           };
         },
         FragmentDefinition(node) {
-          fragment = node.typeCondition.name.value;
+          fragment2 = node.typeCondition.name.value;
           fragmentName = node.name.value;
           refetchQueryName = config4.paginationQueryName(fragmentName);
           nodeQuery = node.typeCondition.name.value !== config4.schema.getQueryType()?.name;
@@ -71282,17 +71502,17 @@ async function paginate(config4, documents) {
         }
       });
       let targetType = config4.schema.getQueryType()?.name || "";
-      if (fragment) {
+      if (fragment2) {
         const nodeInterface = config4.schema.getType("Node");
         if (nodeInterface) {
           const { objects, interfaces } = config4.schema.getImplementations(nodeInterface);
-          if (objects.find((obj) => obj.name === fragment) || interfaces.find((int) => int.name === fragment)) {
+          if (objects.find((obj) => obj.name === fragment2) || interfaces.find((int) => int.name === fragment2)) {
             targetType = "Node";
           } else {
-            targetType = fragment;
+            targetType = fragment2;
           }
         } else {
-          targetType = fragment;
+          targetType = fragment2;
         }
       }
       const pageSize = flags.first.defaultValue ?? flags.last.defaultValue ?? flags.limit.defaultValue;
@@ -71314,7 +71534,7 @@ async function paginate(config4, documents) {
         start,
         mode: paginateMode
       };
-      if (!fragment) {
+      if (!fragment2) {
         continue;
       }
       const paginationArgs = Object.entries(flags).filter(([_, { enabled }]) => enabled).map(([key, value]) => ({ name: key, ...value }));
@@ -71335,15 +71555,22 @@ async function paginate(config4, documents) {
               ["arguments"]: paginationArgs.map(
                 ({ name }) => variableAsArgument(name)
               )
+            },
+            {
+              kind: graphql10.Kind.DIRECTIVE,
+              name: {
+                kind: "Name",
+                value: config4.maskDisableDirective
+              }
             }
           ]
         }
       ];
-      const keys = config4.keyFieldsForType(!nodeQuery ? config4.schema.getQueryType()?.name || "" : fragment).flatMap((key) => {
-        if (fragment === config4.schema.getQueryType()?.name) {
+      const keys = config4.keyFieldsForType(!nodeQuery ? config4.schema.getQueryType()?.name || "" : fragment2).flatMap((key) => {
+        if (fragment2 === config4.schema.getQueryType()?.name) {
           return [];
         }
-        const fragmentType = config4.schema.getType(fragment);
+        const fragmentType = config4.schema.getType(fragment2);
         const { type, wrappers } = unwrapType(
           config4,
           fragmentType.getFields()[key].type
@@ -71355,7 +71582,7 @@ async function paginate(config4, documents) {
           }
         ];
       });
-      const typeConfig = config4.typeConfig?.[fragment];
+      const typeConfig = config4.typeConfig?.[fragment2];
       const queryDoc = {
         kind: graphql10.Kind.DOCUMENT,
         definitions: [
@@ -71697,7 +71924,7 @@ async function addListFragments(config4, documents) {
           );
           const targetField = ancestors[ancestors.length - 1];
           const targetFieldDefinition = parentType.getFields()[targetField.name.value];
-          const { selection: selection2, type, connection } = connectionSelection(
+          const { selection, type, connection } = connectionSelection(
             config4,
             targetFieldDefinition,
             parentTypeFromAncestors(
@@ -71708,7 +71935,7 @@ async function addListFragments(config4, documents) {
             ancestors[ancestors.length - 1].selectionSet
           );
           lists[nameArg.value.value] = {
-            selection: selection2,
+            selection,
             type,
             filename: doc.filename
           };
@@ -71786,14 +72013,14 @@ async function addListFragments(config4, documents) {
   const generatedDoc = {
     kind: graphql11.Kind.DOCUMENT,
     definitions: Object.entries(lists).flatMap(
-      ([name, { selection: selection2, type }]) => {
+      ([name, { selection, type }]) => {
         const schemaType = config4.schema.getType(type.name);
-        if (!selection2) {
+        if (!selection) {
           throw new HoudiniError({ message: "Lists must have a selection" });
         }
         const fragmentSelection = {
           kind: graphql11.Kind.SELECTION_SET,
-          selections: [...selection2.selections]
+          selections: [...selection.selections]
         };
         if (schemaType && fragmentSelection && !fragmentSelection?.selections.find(
           (field) => field.kind === "Field" && config4.keyFieldsForType(type.name).includes(field.name.value)
@@ -71885,7 +72112,7 @@ async function addListFragments(config4, documents) {
     artifact: null
   });
 }
-function connectionSelection(config4, field, type, selection2) {
+function connectionSelection(config4, field, type, selection) {
   const fieldArgs = field.args.reduce(
     (args, arg) => ({
       ...args,
@@ -71894,34 +72121,34 @@ function connectionSelection(config4, field, type, selection2) {
     {}
   );
   if (fieldArgs["limit"]) {
-    return { selection: selection2, type, connection: false, error: null };
+    return { selection, type, connection: false, error: null };
   }
   const forwardPagination = fieldArgs["first"] === "Int" && ["Cursor", "String"].includes(fieldArgs["after"]);
   const backwardsPagination = fieldArgs["last"] === "Int" && ["Cursor", "String"].includes(fieldArgs["before"]);
   if (!forwardPagination && !backwardsPagination) {
-    return { selection: selection2, type, connection: false, error: missingPaginationArgMessage(config4) };
+    return { selection, type, connection: false, error: missingPaginationArgMessage(config4) };
   }
-  const edgesField = selection2?.selections.find(
-    (selection3) => selection3.kind === "Field" && selection3.name.value === "edges"
+  const edgesField = selection?.selections.find(
+    (selection2) => selection2.kind === "Field" && selection2.name.value === "edges"
   );
   if (!edgesField) {
-    return { selection: selection2, type, connection: false, error: missingEdgeSelectionMessage(config4) };
+    return { selection, type, connection: false, error: missingEdgeSelectionMessage(config4) };
   }
   const nodeSelection = edgesField.selectionSet?.selections.find(
-    (selection3) => selection3.kind === "Field" && selection3.name.value === "node"
+    (selection2) => selection2.kind === "Field" && selection2.name.value === "node"
   );
   if (!nodeSelection.selectionSet) {
-    return { selection: selection2, type, connection: false, error: missingNodeSelectionMessage(config4) };
+    return { selection, type, connection: false, error: missingNodeSelectionMessage(config4) };
   }
   const edgeField = unwrapType(config4, field.type).type.getFields()["edges"];
   const { wrappers, type: edgeFieldType } = unwrapType(config4, edgeField.type);
   const list = wrappers[wrappers.length - 2] === "List" /* List */;
   if (!list) {
-    return { selection: selection2, type, connection: false, error: edgeInvalidTypeMessage(config4) };
+    return { selection, type, connection: false, error: edgeInvalidTypeMessage(config4) };
   }
   const nodeField = edgeFieldType.getFields()["node"];
   if (!nodeField) {
-    return { selection: selection2, type, connection: false, error: nodeNotDefinedMessage(config4) };
+    return { selection, type, connection: false, error: nodeNotDefinedMessage(config4) };
   }
   return {
     selection: nodeSelection.selectionSet,
@@ -72000,59 +72227,45 @@ function fieldKey(config4, field) {
 }
 
 // src/codegen/generators/artifacts/selection.ts
-function selection({
+function selection_default(args) {
+  const typeMap = {};
+  const abstractTypes = [];
+  return mergeSelection({
+    object: prepareSelection({ ...args, typeMap, abstractTypes }),
+    filepath: args.filepath,
+    typeMap,
+    abstractTypes
+  });
+}
+function prepareSelection({
   config: config4,
   filepath,
   rootType,
   selections,
   operations,
   path: path2 = [],
-  includeFragments,
   document,
-  inConnection
+  inConnection,
+  typeMap,
+  abstractTypes
 }) {
   let object = {};
-  const typeMap = {};
-  const abstractTypes = [];
   for (const field of selections) {
-    if (field.kind === "FragmentSpread" && includeFragments) {
-      const fragmentDefinition = document.document.definitions.find(
-        (defn) => defn.kind === "FragmentDefinition" && defn.name.value === field.name.value
-      );
-      if (!fragmentDefinition) {
-        throw new HoudiniError({
-          filepath,
-          message: "selection: could not find definition for fragment " + field.name.value
-        });
-      }
-      object = deepMerge(
-        filepath,
-        object,
-        selection({
-          config: config4,
-          filepath,
-          rootType: fragmentDefinition.typeCondition.name.value,
-          operations,
-          selections: fragmentDefinition.selectionSet.selections,
-          path: path2,
-          includeFragments,
-          document
-        })
-      );
-    } else if (field.kind === "InlineFragment") {
+    if (field.kind === "InlineFragment") {
       if (!field.typeCondition || field.typeCondition.name.value === rootType) {
         object.fields = deepMerge(
           filepath,
           object.fields || {},
-          selection({
+          prepareSelection({
             config: config4,
             filepath,
             rootType: field.typeCondition?.name.value || rootType,
             operations,
             selections: field.selectionSet.selections,
             path: path2,
-            includeFragments,
-            document
+            document,
+            typeMap,
+            abstractTypes
           }).fields || {}
         );
       } else {
@@ -72090,15 +72303,16 @@ function selection({
         }
         object.abstractFields.fields = {
           ...object.abstractFields.fields,
-          [field.typeCondition.name.value]: selection({
+          [field.typeCondition.name.value]: prepareSelection({
             config: config4,
             filepath,
             rootType: field.typeCondition?.name.value || rootType,
             operations,
             selections: field.selectionSet.selections,
             path: path2,
-            includeFragments,
-            document
+            document,
+            typeMap,
+            abstractTypes
           }).fields
         };
       }
@@ -72119,10 +72333,14 @@ function selection({
       }
       const typeName = fieldType.toString();
       const pathSoFar = path2.concat(attributeName);
-      const fieldObj = {
+      const keys = config4.keyFieldsForType(rootType);
+      let fieldObj = {
         type: typeName,
         keyRaw: fieldKey(config4, field)
       };
+      if (keys.includes(field.name.value)) {
+        fieldObj.visible = true;
+      }
       if (nullable) {
         fieldObj.nullable = true;
       }
@@ -72170,16 +72388,17 @@ function selection({
       }
       if (field.selectionSet) {
         const connectionState = paginated && document.refetch?.method === "cursor" || continueConnection;
-        fieldObj.selection = selection({
+        fieldObj.selection = prepareSelection({
           config: config4,
           filepath,
           rootType: typeName,
           selections: field.selectionSet.selections,
           operations,
           path: pathSoFar,
-          includeFragments,
           document,
-          inConnection: connectionState
+          inConnection: connectionState,
+          typeMap,
+          abstractTypes
         });
       }
       if (field.arguments?.length && fieldObj.list) {
@@ -72194,12 +72413,29 @@ function selection({
       if (graphql13.isInterfaceType(fieldType) || graphql13.isUnionType(fieldType)) {
         fieldObj.abstract = true;
       }
+      if (object.fields?.[attributeName]) {
+        fieldObj = deepMerge(filepath, object.fields[attributeName], fieldObj);
+      }
       object.fields = {
         ...object.fields,
         [attributeName]: fieldObj
       };
+    } else if (field.kind === "FragmentSpread") {
+      const { fragment: fragment2, args } = config4.getFragmentVariablesHash(field.name.value);
+      object.fragments = {
+        ...object.fragments,
+        [fragment2]: args ?? {}
+      };
     }
   }
+  return object;
+}
+function mergeSelection({
+  filepath,
+  object,
+  typeMap,
+  abstractTypes
+}) {
   if (Object.keys(object.fields || {}).length > 0 && object.abstractFields && Object.keys(object.abstractFields.fields).length > 0) {
     for (const [typeName, possibles] of Object.entries(typeMap)) {
       let overlap = false;
@@ -72207,8 +72443,8 @@ function selection({
         if (object.abstractFields.fields[typeName]) {
           object.abstractFields.fields[typeName] = deepMerge(
             filepath,
-            object.abstractFields.fields[typeName] || {},
-            object.abstractFields.fields[possible]
+            object.abstractFields.fields[typeName] ?? {},
+            object.abstractFields.fields[possible] ?? {}
           );
           overlap = true;
         }
@@ -72239,6 +72475,30 @@ function selection({
       }
     }
   }
+  for (const [key, value] of Object.entries(object.fields ?? {})) {
+    const selection = value.selection;
+    if (selection) {
+      mergeSelection({
+        filepath,
+        typeMap,
+        abstractTypes,
+        object: selection
+      });
+    }
+  }
+  for (const [type, selection] of Object.entries(object.abstractFields?.fields ?? {})) {
+    for (const [key, value] of Object.entries(selection ?? {})) {
+      const selection2 = value.selection;
+      if (selection2) {
+        mergeSelection({
+          filepath,
+          typeMap,
+          abstractTypes,
+          object: selection2
+        });
+      }
+    }
+  }
   return object;
 }
 
@@ -72303,7 +72563,12 @@ function artifactGenerator(stats) {
         writeIndexFile(config4, docs)
       ].concat(
         docs.map(async (doc) => {
-          const { document, name, generateArtifact } = doc;
+          const {
+            document,
+            name,
+            generateArtifact,
+            originalParsed
+          } = doc;
           if (!generateArtifact) {
             return;
           }
@@ -72342,6 +72607,16 @@ function artifactGenerator(stats) {
           );
           let rootType = "";
           let selectionSet;
+          let originalSelectionSet = null;
+          const fragmentDefinitions = doc.document.definitions.filter(
+            (definition) => definition.kind === "FragmentDefinition"
+          ).reduce(
+            (prev, definition) => ({
+              ...prev,
+              [definition.name.value]: definition
+            }),
+            {}
+          );
           if (docKind !== ArtifactKind.Fragment) {
             const operation = operations[0];
             if (operation.operation === "query") {
@@ -72358,9 +72633,12 @@ function artifactGenerator(stats) {
               });
             }
             selectionSet = operation.selectionSet;
+            if (originalParsed.definitions[0].kind === "OperationDefinition") {
+              originalSelectionSet = originalParsed.definitions[0].selectionSet;
+            }
           } else {
             const matchingFragment = fragments.find(
-              (fragment) => fragment.name.value === name
+              (fragment2) => fragment2.name.value === name
             );
             if (!matchingFragment) {
               throw new HoudiniError({
@@ -72370,6 +72648,12 @@ function artifactGenerator(stats) {
             }
             rootType = matchingFragment.typeCondition.name.value;
             selectionSet = matchingFragment.selectionSet;
+            if (originalParsed.definitions[0].kind === "FragmentDefinition") {
+              originalSelectionSet = originalParsed.definitions[0].selectionSet;
+            }
+          }
+          if (!originalSelectionSet) {
+            throw new Error("Not original selection set!");
           }
           let inputs = operations[0]?.variableDefinitions;
           let directive = fragments[0]?.directives?.find(
@@ -72378,21 +72662,18 @@ function artifactGenerator(stats) {
           if (docKind === ArtifactKind.Fragment && directive) {
             inputs = fragmentArgumentsDefinitions(config4, doc.filename, fragments[0]);
           }
-          const mergedSelection = flattenSelections({
+          const mask = selection_default({
             config: config4,
             filepath: doc.filename,
-            selections: selectionSet.selections,
-            fragmentDefinitions: doc.document.definitions.filter(
-              (definition) => definition.kind === "FragmentDefinition"
-            ).reduce(
-              (prev, definition) => ({
-                ...prev,
-                [definition.name.value]: definition
-              }),
-              {}
-            ),
-            ignoreMaskDisable: docKind === "HoudiniQuery",
-            applyFragments: docKind !== "HoudiniFragment"
+            rootType,
+            operations: {},
+            document: doc,
+            selections: flattenSelections({
+              config: config4,
+              filepath: doc.filename,
+              selections: selectionSet.selections,
+              fragmentDefinitions
+            })
           });
           let artifact = {
             name,
@@ -72401,21 +72682,29 @@ function artifactGenerator(stats) {
             refetch: doc.refetch,
             raw: rawString,
             rootType,
-            selection: selection({
+            selection: selection_default({
               config: config4,
               filepath: doc.filename,
               rootType,
-              selections: mergedSelection,
+              selections: flattenSelections({
+                config: config4,
+                filepath: doc.filename,
+                selections: selectionSet.selections,
+                fragmentDefinitions,
+                ignoreMaskDisable: docKind !== "HoudiniFragment",
+                keepFragmentSpreadNodes: true
+              }),
               operations: operationsByPath(
                 config4,
                 doc.filename,
                 operations[0],
                 filterTypes
               ),
-              includeFragments: docKind !== "HoudiniFragment",
               document: doc
-            })
+            }),
+            pluginData: {}
           };
+          applyMask(config4, artifact.selection, mask);
           artifact.pluginData = {};
           for (const plugin2 of config4.plugins) {
             if (!plugin2.artifactData) {
@@ -72492,6 +72781,49 @@ function artifactGenerator(stats) {
     stats.deleted = await cleanupFiles(config4.artifactDirectory, listOfArtifacts);
   };
 }
+function applyMask(config4, target, mask) {
+  for (const [fieldName, value] of Object.entries(mask.fields ?? {})) {
+    const targetSelection = target.fields?.[fieldName];
+    if (!targetSelection || !mask.fields) {
+      continue;
+    }
+    targetSelection.visible = true;
+    if (targetSelection.selection && value.selection) {
+      applyMask(config4, targetSelection.selection, value.selection);
+    }
+  }
+  for (const [type, selection] of Object.entries(mask.abstractFields?.fields ?? {})) {
+    if (!selection) {
+      continue;
+    }
+    if (target.abstractFields?.fields[type]) {
+      applyMask(config4, { fields: target.abstractFields.fields[type] }, { fields: selection });
+    }
+    const targetType = config4.schema.getType(type);
+    if (!targetType) {
+      continue;
+    }
+    if (graphql14.isAbstractType(targetType)) {
+      for (const possible of config4.schema.getPossibleTypes(targetType)) {
+        if (target.abstractFields?.fields[possible.name]) {
+          applyMask(
+            config4,
+            { fields: target.abstractFields.fields[possible.name] },
+            { fields: selection }
+          );
+        }
+      }
+    }
+    const mappedType = target.abstractFields?.typeMap[type];
+    if (target.abstractFields && mappedType && target.abstractFields.fields[mappedType]) {
+      applyMask(
+        config4,
+        { fields: target.abstractFields.fields[mappedType] },
+        { fields: selection }
+      );
+    }
+  }
+}
 
 // src/codegen/generators/runtime/graphqlFunction.ts
 var recast6 = __toESM(require_main2(), 1);
@@ -72817,7 +73149,7 @@ function addReferencedInputTypes(config4, filepath, body, visitedTypes, missingS
 var graphql18 = __toESM(require_graphql2(), 1);
 var recast10 = __toESM(require_main2(), 1);
 var AST10 = recast10.types.builders;
-var fragmentKey = "$fragments";
+var fragmentKey2 = " $fragments";
 function inlineType({
   config: config4,
   filepath,
@@ -72857,24 +73189,24 @@ function inlineType({
     const rootObj = type;
     const inlineFragments = {};
     const selectedFields = [];
-    for (const selection2 of selections) {
-      if (selection2.kind === "InlineFragment" && selection2.typeCondition) {
-        const fragmentType = config4.schema.getType(selection2.typeCondition.name.value);
+    for (const selection of selections) {
+      if (selection.kind === "InlineFragment" && selection.typeCondition) {
+        const fragmentType = config4.schema.getType(selection.typeCondition.name.value);
         if (!graphql18.isInterfaceType(type) && !graphql18.isUnionType(type)) {
-          selectedFields.push(...selection2.selectionSet.selections);
+          selectedFields.push(...selection.selectionSet.selections);
           continue;
         }
         if (!graphql18.isInterfaceType(fragmentType) && !graphql18.isUnionType(fragmentType)) {
           if (!inlineFragments[fragmentType.name]) {
             inlineFragments[fragmentType.name] = [];
           }
-          inlineFragments[fragmentType.name].push(...selection2.selectionSet.selections);
+          inlineFragments[fragmentType.name].push(...selection.selectionSet.selections);
           continue;
         }
         const possibleParents = config4.schema.getPossibleTypes(type).map((t2) => t2.name);
         const freeSelections = [];
         const typeSpecificSelections = {};
-        for (const node of selection2.selectionSet.selections) {
+        for (const node of selection.selectionSet.selections) {
           if (node.kind !== "InlineFragment") {
             freeSelections.push(node);
           } else if (node.typeCondition) {
@@ -72897,23 +73229,30 @@ function inlineType({
             );
           }
         }
-      } else if (selection2.kind === "InlineFragment" && !selection2.typeCondition) {
-        selectedFields.push(...selection2.selectionSet.selections);
+      } else if (selection.kind === "InlineFragment" && !selection.typeCondition) {
+        selectedFields.push(...selection.selectionSet.selections);
       } else {
-        selectedFields.push(selection2);
+        selectedFields.push(selection);
       }
     }
+    const fields = Object.values(
+      selectedFields.filter((field) => field.kind === "Field").reduce(
+        (sel, field) => ({
+          ...sel,
+          [field.alias?.value ?? field.name.value]: field
+        }),
+        {}
+      )
+    );
     result = AST10.tsTypeLiteral([
-      ...(selectedFields || []).filter(
-        (field) => field.kind === "Field"
-      ).map((selection2) => {
-        const { field } = selectionTypeInfo(config4.schema, filepath, rootObj, selection2);
-        const attributeName = selection2.alias?.value || selection2.name.value;
+      ...fields.map((selection) => {
+        const { field } = selectionTypeInfo(config4.schema, filepath, rootObj, selection);
+        const attributeName = selection.alias?.value || selection.name.value;
         let attributeType = inlineType({
           config: config4,
           filepath,
           rootType: field.type,
-          selections: selection2.selectionSet?.selections,
+          selections: selection.selectionSet?.selections,
           root: false,
           allowReadonly,
           visitedTypes,
@@ -72922,7 +73261,7 @@ function inlineType({
           includeFragments,
           allOptional
         });
-        const hasIncludeOrSkipDirective = selection2.directives && selection2.directives.filter(
+        const hasIncludeOrSkipDirective = selection.directives && selection.directives.filter(
           (directive) => directive.name.value === "include" || directive.name.value === "skip"
         ).length > 0;
         if (hasIncludeOrSkipDirective) {
@@ -72946,15 +73285,13 @@ function inlineType({
       result.members.push(
         readonlyProperty(
           AST10.tsPropertySignature(
-            AST10.identifier(fragmentKey),
+            AST10.stringLiteral(fragmentKey2),
             AST10.tsTypeAnnotation(
               AST10.tsTypeLiteral(
                 (fragmentSpreads || []).map(
                   (fragmentSpread) => AST10.tsPropertySignature(
                     AST10.identifier(fragmentSpread.name.value),
-                    AST10.tsTypeAnnotation(
-                      AST10.tsLiteralType(AST10.booleanLiteral(true))
-                    )
+                    AST10.tsTypeAnnotation(AST10.tsTypeLiteral([]))
                   )
                 )
               )
@@ -72964,7 +73301,7 @@ function inlineType({
         )
       );
     }
-    const inlineFragmentSelections = Object.entries(inlineFragments).flatMap(([typeName, fragment]) => {
+    const inlineFragmentSelections = Object.entries(inlineFragments).flatMap(([typeName, fragment2]) => {
       const fragmentRootType = config4.schema.getType(typeName);
       if (!fragmentRootType) {
         return [];
@@ -72973,7 +73310,7 @@ function inlineType({
         config: config4,
         filepath,
         rootType: fragmentRootType,
-        selections: fragment,
+        selections: fragment2,
         allowReadonly,
         visitedTypes,
         root,
@@ -73045,10 +73382,10 @@ function inlineType({
   }
   return result;
 }
-function selectionTypeInfo(schema, filepath, rootType, selection2) {
-  const selectionName = selection2.name.value;
+function selectionTypeInfo(schema, filepath, rootType, selection) {
+  const selectionName = selection.name.value;
   let fields = {};
-  if (selection2.kind === "Field" && selection2.name.value === "__typename") {
+  if (selection.kind === "Field" && selection.name.value === "__typename") {
     return {
       field: {
         name: "__typename",
@@ -73119,7 +73456,7 @@ async function generateDocumentTypes(config4, docs) {
           filepath: filename,
           selections: definition.selectionSet.selections,
           fragmentDefinitions,
-          applyFragments: definition.kind === "OperationDefinition"
+          keepFragmentSpreadNodes: true
         });
         if (definition?.kind === "OperationDefinition") {
           await generateOperationTypeDefs(
@@ -73343,39 +73680,26 @@ async function generateFragmentTypeDefs(config4, filepath, body, selections, def
     if (!type) {
       throw new Error("Should not get here");
     }
-    let extraExports = [];
     let directive = definition.directives?.find(
       (directive2) => directive2.name.value === config4.argumentsDirective
     );
-    if (directive) {
-      extraExports.push(
-        AST11.exportNamedDeclaration(
-          AST11.tsTypeAliasDeclaration(
-            AST11.identifier(inputTypeName),
-            AST11.tsTypeLiteral(
-              (fragmentArgumentsDefinitions(config4, filepath, definition) || []).map(
-                (definition2) => {
-                  return AST11.tsPropertySignature(
-                    AST11.identifier(definition2.variable.name.value),
-                    AST11.tsTypeAnnotation(
-                      tsTypeReference(
-                        config4,
-                        missingScalars,
-                        definition2,
-                        body
-                      )
-                    ),
-                    definition2.type.kind !== "NonNullType"
-                  );
-                }
-              )
-            )
-          )
-        )
-      );
-    }
+    let inputValue = !directive ? AST11.tsTypeLiteral([]) : AST11.tsTypeLiteral(
+      (fragmentArgumentsDefinitions(config4, filepath, definition) || []).map(
+        (definition2) => {
+          return AST11.tsPropertySignature(
+            AST11.identifier(definition2.variable.name.value),
+            AST11.tsTypeAnnotation(
+              tsTypeReference(config4, missingScalars, definition2, body)
+            ),
+            definition2.type.kind !== "NonNullType"
+          );
+        }
+      )
+    );
     body.push(
-      ...extraExports,
+      AST11.exportNamedDeclaration(
+        AST11.tsTypeAliasDeclaration(AST11.identifier(inputTypeName), inputValue)
+      ),
       AST11.exportNamedDeclaration(
         AST11.tsTypeAliasDeclaration(
           AST11.identifier(propTypeName),
@@ -73391,14 +73715,12 @@ async function generateFragmentTypeDefs(config4, filepath, body, selections, def
             ),
             readonlyProperty(
               AST11.tsPropertySignature(
-                AST11.stringLiteral(fragmentKey),
+                AST11.stringLiteral(fragmentKey2),
                 AST11.tsTypeAnnotation(
                   AST11.tsTypeLiteral([
                     AST11.tsPropertySignature(
                       AST11.stringLiteral(propTypeName),
-                      AST11.tsTypeAnnotation(
-                        AST11.tsLiteralType(AST11.booleanLiteral(true))
-                      )
+                      AST11.tsTypeAnnotation(AST11.tsAnyKeyword())
                     )
                   ])
                 )
@@ -74110,6 +74432,13 @@ async function addID(config4, documents) {
           return;
         }
         return addKeysToSelection(config4, node, fragmentType);
+      },
+      FragmentDefinition(node) {
+        const fragmentType = config4.schema.getType(node.typeCondition.name.value);
+        if (!fragmentType) {
+          return;
+        }
+        return addKeysToSelection(config4, node, fragmentType);
       }
     });
   }
@@ -74128,7 +74457,7 @@ function addKeysToSelection(config4, node, fieldType) {
   const selections = [...node.selectionSet.selections];
   for (const keyField of keyFields) {
     if (node.selectionSet.selections.find(
-      (selection2) => selection2.kind === "Field" && !selection2.alias && selection2.name.value === keyField
+      (selection) => selection.kind === "Field" && !selection.alias && selection.name.value === keyField
     )) {
       continue;
     }