houdini 1.0.11 → 1.1.1-next.0

package/build/codegen-cjs/index.js

@@ -3363,7 +3363,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 = GraphQLList2;
     exports.GraphQLNonNull = GraphQLNonNull2;
@@ -3534,11 +3534,11 @@ var require_definition = __commonJS({
       }
       return type;
     }
-    function isAbstractType3(type) {
+    function isAbstractType4(type) {
       return isInterfaceType6(type) || isUnionType7(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;
@@ -6802,8 +6802,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));
           }
         }
@@ -6839,8 +6839,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++) {
@@ -6930,13 +6930,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;
         }
@@ -7757,11 +7757,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;
       }
@@ -7932,38 +7932,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;
           }
         }
@@ -8499,11 +8499,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);
               }
             }
           }
@@ -8524,10 +8524,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);
                 }
               }
             }
@@ -9440,37 +9440,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;
           }
         }
@@ -9488,8 +9488,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;
       }
@@ -54209,14 +54209,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;
@@ -54224,7 +54224,7 @@ function getFieldsForType(selection2, __typename) {
 
 // src/runtime/lib/scalars.ts
 async function marshalSelection({
-  selection: selection2,
+  selection,
   data
 }) {
   const config2 = getCurrentConfig();
@@ -54232,18 +54232,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 (config2.scalars?.[type]) {
           const marshalFn = config2.scalars[type].marshal;
@@ -54294,6 +54294,7 @@ var DataSource = {
   Network: "network",
   Ssr: "ssr"
 };
+var fragmentKey = " $fragments";
 
 // src/runtime/lib/key.ts
 var computeKey = ({ field, args }) => {
@@ -54780,7 +54781,7 @@ var List = class {
     recordType,
     key,
     listType,
-    selection: selection2,
+    selection,
     when,
     filters,
     connection,
@@ -54792,7 +54793,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;
@@ -54803,19 +54804,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 = {
@@ -54835,9 +54836,9 @@ var List = class {
                         type: listType,
                         keyRaw: "node",
                         selection: {
-                          ...selection2,
+                          ...selection,
                           fields: {
-                            ...selection2.fields,
+                            ...selection.fields,
                             __typename: {
                               keyRaw: "__typename",
                               type: "String"
@@ -54866,9 +54867,9 @@ var List = class {
             type: listType,
             updates: ["append", "prepend"],
             selection: {
-              ...selection2,
+              ...selection,
               fields: {
-                ...selection2.fields,
+                ...selection.fields,
                 __typename: {
                   keyRaw: "__typename",
                   type: "String"
@@ -54943,7 +54944,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
       );
     }
@@ -54979,9 +54981,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]() {
@@ -55556,14 +55558,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) {
@@ -55611,10 +55623,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] = {};
     }
@@ -55626,7 +55638,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] = {};
@@ -55637,14 +55649,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
   }) {
@@ -55655,7 +55666,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,
@@ -55671,14 +55682,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({
@@ -55698,7 +55709,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);
@@ -55725,11 +55736,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);
@@ -55791,7 +55802,7 @@ var InMemorySubscriptions = class {
 // src/runtime/cache/cache.ts
 var Cache = class {
   _internal_unstable;
-  constructor(config2) {
+  constructor({ disabled, ...config2 } = {}) {
     this._internal_unstable = new CacheInternal({
       cache: this,
       storage: new InMemoryStorage(),
@@ -55799,9 +55810,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 (config2) {
+    if (Object.keys(config2).length > 0) {
       this.setConfig(defaultConfigValues(config2));
     }
   }
@@ -55820,7 +55832,8 @@ var Cache = class {
           this._internal_unstable.getSelection({
             parent: spec.parentID || rootID,
             selection: spec.selection,
-            variables: spec.variables?.() || {}
+            variables: spec.variables?.() || {},
+            ignoreMasking: false
           }).data
         );
       }
@@ -55895,16 +55908,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;
@@ -55919,7 +55929,9 @@ var CacheInternal = class {
     cache,
     lifetimes,
     staleManager,
-    schema
+    schema,
+    disabled,
+    config: config2
   }) {
     this.storage = storage;
     this.subscriptions = subscriptions;
@@ -55928,7 +55940,8 @@ var CacheInternal = class {
     this.lifetimes = lifetimes;
     this.staleManager = staleManager;
     this.schema = schema;
-    this._disabled = typeof globalThis.window === "undefined";
+    this._config = config2;
+    this._disabled = disabled;
     try {
       if (process.env.HOUDINI_TEST === "true") {
         this._disabled = false;
@@ -55936,12 +55949,15 @@ var CacheInternal = class {
     } catch {
     }
   }
+  get config() {
+    return this._config ?? getCurrentConfig();
+  }
   setConfig(config2) {
-    this.config = config2;
+    this._config = config2;
   }
   writeSelection({
     data,
-    selection: selection2,
+    selection,
     variables = {},
     parent = rootID,
     applyUpdates,
@@ -55953,9 +55969,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 {
@@ -56211,25 +56227,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);
@@ -56269,7 +56300,8 @@ var CacheInternal = class {
           fields: fieldSelection,
           variables,
           linkedList: value,
-          stepsFromConnection: nextStep
+          stepsFromConnection: nextStep,
+          ignoreMasking: !!ignoreMasking
         });
         target[attributeName] = listValue.data;
         if (listValue.partial) {
@@ -56286,7 +56318,8 @@ var CacheInternal = class {
           parent: value,
           selection: fieldSelection,
           variables,
-          stepsFromConnection: nextStep
+          stepsFromConnection: nextStep,
+          ignoreMasking
         });
         target[attributeName] = objectFields.data;
         if (objectFields.partial) {
@@ -56330,7 +56363,8 @@ var CacheInternal = class {
     fields,
     variables,
     linkedList,
-    stepsFromConnection
+    stepsFromConnection,
+    ignoreMasking
   }) {
     const result = [];
     let partialData = false;
@@ -56342,7 +56376,8 @@ var CacheInternal = class {
           fields,
           variables,
           linkedList: entry,
-          stepsFromConnection
+          stepsFromConnection,
+          ignoreMasking
         });
         result.push(nestedValue.data);
         if (nestedValue.partial) {
@@ -56363,7 +56398,8 @@ var CacheInternal = class {
         parent: entry,
         selection: fields,
         variables,
-        stepsFromConnection
+        stepsFromConnection,
+        ignoreMasking
       });
       result.push(data);
       if (partial) {
@@ -56466,11 +56502,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 () => {
@@ -56506,7 +56585,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 = {
@@ -56516,8 +56594,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?.() || {});
         }
@@ -56538,19 +56615,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 {
@@ -56827,11 +56946,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 (e) {
-    throw new HoudiniError({ filepath, message: "could not merge: " + targets });
+    throw new HoudiniError({
+      filepath,
+      message: "could not merge: " + targets,
+      description: e.message
+    });
   }
 }
 
@@ -57059,16 +57184,16 @@ function flattenSelections({
   filepath,
   selections,
   fragmentDefinitions,
-  applyFragments,
-  ignoreMaskDisable
+  ignoreMaskDisable,
+  keepFragmentSpreadNodes
 }) {
   const fields = new FieldCollection({
     config: config2,
     filepath,
     selections,
     fragmentDefinitions,
-    applyFragments,
-    ignoreMaskDisable: !!ignoreMaskDisable
+    ignoreMaskDisable: !!ignoreMaskDisable,
+    keepFragmentSpreadNodes: !!keepFragmentSpreadNodes
   });
   return fields.toSelectionSet();
 }
@@ -57079,57 +57204,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) {
@@ -57138,14 +57266,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({
@@ -57164,37 +57295,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).map((spread) => {
+        return {
+          kind: "FragmentSpread",
+          name: {
+            kind: "Name",
+            value: spread.name.value
+          },
+          directives: spread.directives
+        };
       })
-    ).concat(Object.values(this.fragmentSpreads));
+    );
   }
-  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;
@@ -57208,8 +57369,8 @@ var FieldCollection = class {
       fragmentDefinitions: this.fragmentDefinitions,
       selections: [],
       filepath: this.filepath,
-      applyFragments: this.applyFragments,
-      ignoreMaskDisable: this.ignoreMaskDisable
+      ignoreMaskDisable: this.ignoreMaskDisable,
+      keepFragmentSpreadNodes: this.keepFragmentSpreadNodes
     });
   }
 };
@@ -57287,13 +57448,13 @@ function murmurHash(str) {
 // src/codegen/transforms/fragmentVariables.ts
 var graphql4 = __toESM(require_graphql2(), 1);
 
-// src/codegen/transforms/composeQueries.ts
+// src/codegen/transforms/collectDefinitions.ts
 var import_graphql = __toESM(require_graphql2(), 1);
 async function includeFragmentDefinitions(config2, documents) {
-  const fragments = collectFragments(config2, documents);
+  const fragments = collectDefinitions(config2, documents);
   for (const [index, { name, document, filename }] of documents.entries()) {
     const operation = document.definitions.find(
-      ({ kind }) => kind === import_graphql.Kind.OPERATION_DEFINITION
+      (def) => def.kind === import_graphql.Kind.OPERATION_DEFINITION || def.kind === "FragmentDefinition"
     );
     if (!operation) {
       continue;
@@ -57312,7 +57473,7 @@ async function includeFragmentDefinitions(config2, documents) {
     };
   }
 }
-function collectFragments(config2, docs) {
+function collectDefinitions(config2, docs) {
   return docs.reduce((acc, doc) => {
     const definitions = doc.document.definitions.reduce(
       (prev, definition) => definition.kind !== "FragmentDefinition" ? prev : {
@@ -57336,11 +57497,11 @@ function findRequiredFragments(selectionSet) {
     return [];
   }
   const referencedFragments = [];
-  for (const selection2 of selectionSet.selections) {
-    if (selection2.kind === import_graphql.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_graphql.Kind.FRAGMENT_SPREAD) {
+      referencedFragments.push(selection.name.value);
+    } else if (selection.selectionSet) {
+      referencedFragments.push(...findRequiredFragments(selection.selectionSet));
     }
   }
   return referencedFragments;
@@ -57373,7 +57534,7 @@ function flattenFragments(filepath, operation, fragments) {
 // src/codegen/transforms/fragmentVariables.ts
 var GraphqlKinds2 = graphql4.Kind;
 async function fragmentVariables(config2, documents) {
-  const fragments = collectFragments(config2, documents);
+  const fragments = collectDefinitions(config2, documents);
   const generatedFragments = {};
   const visitedFragments = /* @__PURE__ */ new Set();
   for (const doc2 of documents) {
@@ -57433,9 +57594,17 @@ function inlineFragmentArgs({
   ).reduce((acc, arg) => ({ ...acc, [arg.name]: arg }), {});
   const result = graphql4.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(config2, filepath, node, scope);
       const newFragmentName = `${node.name.value}${hash}`;
+      config2.registerFragmentVariablesHash({
+        hash: newFragmentName,
+        fragment: node.name.value,
+        args
+      });
       if (!visitedFragments.has(newFragmentName)) {
         visitedFragments.add(newFragmentName);
         const defaultArguments = collectDefaultArgumentValues(config2, filepath, definition);
@@ -57834,7 +58003,7 @@ function operationObject({
   listName,
   operationKind,
   type,
-  selection: selection2,
+  selection,
   filepath
 }) {
   let parentID;
@@ -57842,7 +58011,7 @@ function operationObject({
   let position = config2.internalListPosition;
   let allLists = config2.defaultListTarget ?? void 0;
   let operationWhen;
-  const internalDirectives = selection2.directives?.filter(
+  const internalDirectives = selection.directives?.filter(
     (directive) => config2.isInternalDirective(directive.name.value)
   );
   if (internalDirectives && internalDirectives.length > 0) {
@@ -58078,7 +58247,7 @@ async function paginate(config2, documents) {
       let fragmentName = "";
       let refetchQueryName = "";
       let nodeQuery = false;
-      let fragment = "";
+      let fragment2 = "";
       let paginateMode = config2.defaultPaginateMode;
       doc.document = graphql9.visit(doc.document, {
         OperationDefinition(node) {
@@ -58121,7 +58290,7 @@ async function paginate(config2, documents) {
           };
         },
         FragmentDefinition(node) {
-          fragment = node.typeCondition.name.value;
+          fragment2 = node.typeCondition.name.value;
           fragmentName = node.name.value;
           refetchQueryName = config2.paginationQueryName(fragmentName);
           nodeQuery = node.typeCondition.name.value !== config2.schema.getQueryType()?.name;
@@ -58168,17 +58337,17 @@ async function paginate(config2, documents) {
         }
       });
       let targetType = config2.schema.getQueryType()?.name || "";
-      if (fragment) {
+      if (fragment2) {
         const nodeInterface = config2.schema.getType("Node");
         if (nodeInterface) {
           const { objects, interfaces } = config2.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;
@@ -58200,7 +58369,7 @@ async function paginate(config2, documents) {
         start,
         mode: paginateMode
       };
-      if (!fragment) {
+      if (!fragment2) {
         continue;
       }
       const paginationArgs = Object.entries(flags).filter(([_, { enabled }]) => enabled).map(([key, value]) => ({ name: key, ...value }));
@@ -58221,15 +58390,22 @@ async function paginate(config2, documents) {
               ["arguments"]: paginationArgs.map(
                 ({ name }) => variableAsArgument(name)
               )
+            },
+            {
+              kind: graphql9.Kind.DIRECTIVE,
+              name: {
+                kind: "Name",
+                value: config2.maskDisableDirective
+              }
             }
           ]
         }
       ];
-      const keys = config2.keyFieldsForType(!nodeQuery ? config2.schema.getQueryType()?.name || "" : fragment).flatMap((key) => {
-        if (fragment === config2.schema.getQueryType()?.name) {
+      const keys = config2.keyFieldsForType(!nodeQuery ? config2.schema.getQueryType()?.name || "" : fragment2).flatMap((key) => {
+        if (fragment2 === config2.schema.getQueryType()?.name) {
           return [];
         }
-        const fragmentType = config2.schema.getType(fragment);
+        const fragmentType = config2.schema.getType(fragment2);
         const { type, wrappers } = unwrapType(
           config2,
           fragmentType.getFields()[key].type
@@ -58241,7 +58417,7 @@ async function paginate(config2, documents) {
           }
         ];
       });
-      const typeConfig = config2.typeConfig?.[fragment];
+      const typeConfig = config2.typeConfig?.[fragment2];
       const queryDoc = {
         kind: graphql9.Kind.DOCUMENT,
         definitions: [
@@ -58583,7 +58759,7 @@ async function addListFragments(config2, 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(
             config2,
             targetFieldDefinition,
             parentTypeFromAncestors(
@@ -58594,7 +58770,7 @@ async function addListFragments(config2, documents) {
             ancestors[ancestors.length - 1].selectionSet
           );
           lists[nameArg.value.value] = {
-            selection: selection2,
+            selection,
             type,
             filename: doc.filename
           };
@@ -58672,14 +58848,14 @@ async function addListFragments(config2, documents) {
   const generatedDoc = {
     kind: graphql10.Kind.DOCUMENT,
     definitions: Object.entries(lists).flatMap(
-      ([name, { selection: selection2, type }]) => {
+      ([name, { selection, type }]) => {
         const schemaType = config2.schema.getType(type.name);
-        if (!selection2) {
+        if (!selection) {
           throw new HoudiniError({ message: "Lists must have a selection" });
         }
         const fragmentSelection = {
           kind: graphql10.Kind.SELECTION_SET,
-          selections: [...selection2.selections]
+          selections: [...selection.selections]
         };
         if (schemaType && fragmentSelection && !fragmentSelection?.selections.find(
           (field) => field.kind === "Field" && config2.keyFieldsForType(type.name).includes(field.name.value)
@@ -58771,7 +58947,7 @@ async function addListFragments(config2, documents) {
     artifact: null
   });
 }
-function connectionSelection(config2, field, type, selection2) {
+function connectionSelection(config2, field, type, selection) {
   const fieldArgs = field.args.reduce(
     (args, arg) => ({
       ...args,
@@ -58780,34 +58956,34 @@ function connectionSelection(config2, 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(config2) };
+    return { selection, type, connection: false, error: missingPaginationArgMessage(config2) };
   }
-  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(config2) };
+    return { selection, type, connection: false, error: missingEdgeSelectionMessage(config2) };
   }
   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(config2) };
+    return { selection, type, connection: false, error: missingNodeSelectionMessage(config2) };
   }
   const edgeField = unwrapType(config2, field.type).type.getFields()["edges"];
   const { wrappers, type: edgeFieldType } = unwrapType(config2, edgeField.type);
   const list = wrappers[wrappers.length - 2] === "List" /* List */;
   if (!list) {
-    return { selection: selection2, type, connection: false, error: edgeInvalidTypeMessage(config2) };
+    return { selection, type, connection: false, error: edgeInvalidTypeMessage(config2) };
   }
   const nodeField = edgeFieldType.getFields()["node"];
   if (!nodeField) {
-    return { selection: selection2, type, connection: false, error: nodeNotDefinedMessage(config2) };
+    return { selection, type, connection: false, error: nodeNotDefinedMessage(config2) };
   }
   return {
     selection: nodeSelection.selectionSet,
@@ -58886,59 +59062,45 @@ function fieldKey(config2, 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: config2,
   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: config2,
-          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: config2,
             filepath,
             rootType: field.typeCondition?.name.value || rootType,
             operations,
             selections: field.selectionSet.selections,
             path: path2,
-            includeFragments,
-            document
+            document,
+            typeMap,
+            abstractTypes
           }).fields || {}
         );
       } else {
@@ -58976,15 +59138,16 @@ function selection({
         }
         object.abstractFields.fields = {
           ...object.abstractFields.fields,
-          [field.typeCondition.name.value]: selection({
+          [field.typeCondition.name.value]: prepareSelection({
             config: config2,
             filepath,
             rootType: field.typeCondition?.name.value || rootType,
             operations,
             selections: field.selectionSet.selections,
             path: path2,
-            includeFragments,
-            document
+            document,
+            typeMap,
+            abstractTypes
           }).fields
         };
       }
@@ -59005,10 +59168,14 @@ function selection({
       }
       const typeName = fieldType.toString();
       const pathSoFar = path2.concat(attributeName);
-      const fieldObj = {
+      const keys = config2.keyFieldsForType(rootType);
+      let fieldObj = {
         type: typeName,
         keyRaw: fieldKey(config2, field)
       };
+      if (keys.includes(field.name.value)) {
+        fieldObj.visible = true;
+      }
       if (nullable) {
         fieldObj.nullable = true;
       }
@@ -59056,16 +59223,17 @@ function selection({
       }
       if (field.selectionSet) {
         const connectionState = paginated && document.refetch?.method === "cursor" || continueConnection;
-        fieldObj.selection = selection({
+        fieldObj.selection = prepareSelection({
           config: config2,
           filepath,
           rootType: typeName,
           selections: field.selectionSet.selections,
           operations,
           path: pathSoFar,
-          includeFragments,
           document,
-          inConnection: connectionState
+          inConnection: connectionState,
+          typeMap,
+          abstractTypes
         });
       }
       if (field.arguments?.length && fieldObj.list) {
@@ -59080,12 +59248,29 @@ function selection({
       if (graphql12.isInterfaceType(fieldType) || graphql12.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 } = config2.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;
@@ -59093,8 +59278,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;
         }
@@ -59125,6 +59310,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;
 }
 
@@ -59189,7 +59398,12 @@ function artifactGenerator(stats) {
         writeIndexFile(config2, docs)
       ].concat(
         docs.map(async (doc) => {
-          const { document, name, generateArtifact } = doc;
+          const {
+            document,
+            name,
+            generateArtifact,
+            originalParsed
+          } = doc;
           if (!generateArtifact) {
             return;
           }
@@ -59228,6 +59442,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") {
@@ -59244,9 +59468,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({
@@ -59256,6 +59483,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(
@@ -59264,21 +59497,18 @@ function artifactGenerator(stats) {
           if (docKind === ArtifactKind.Fragment && directive) {
             inputs = fragmentArgumentsDefinitions(config2, doc.filename, fragments[0]);
           }
-          const mergedSelection = flattenSelections({
+          const mask = selection_default({
             config: config2,
             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: config2,
+              filepath: doc.filename,
+              selections: selectionSet.selections,
+              fragmentDefinitions
+            })
           });
           let artifact = {
             name,
@@ -59287,21 +59517,29 @@ function artifactGenerator(stats) {
             refetch: doc.refetch,
             raw: rawString,
             rootType,
-            selection: selection({
+            selection: selection_default({
               config: config2,
               filepath: doc.filename,
               rootType,
-              selections: mergedSelection,
+              selections: flattenSelections({
+                config: config2,
+                filepath: doc.filename,
+                selections: selectionSet.selections,
+                fragmentDefinitions,
+                ignoreMaskDisable: docKind !== "HoudiniFragment",
+                keepFragmentSpreadNodes: true
+              }),
               operations: operationsByPath(
                 config2,
                 doc.filename,
                 operations[0],
                 filterTypes
               ),
-              includeFragments: docKind !== "HoudiniFragment",
               document: doc
-            })
+            }),
+            pluginData: {}
           };
+          applyMask(config2, artifact.selection, mask);
           artifact.pluginData = {};
           for (const plugin2 of config2.plugins) {
             if (!plugin2.artifactData) {
@@ -59378,6 +59616,49 @@ function artifactGenerator(stats) {
     stats.deleted = await cleanupFiles(config2.artifactDirectory, listOfArtifacts);
   };
 }
+function applyMask(config2, 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(config2, targetSelection.selection, value.selection);
+    }
+  }
+  for (const [type, selection] of Object.entries(mask.abstractFields?.fields ?? {})) {
+    if (!selection) {
+      continue;
+    }
+    if (target.abstractFields?.fields[type]) {
+      applyMask(config2, { fields: target.abstractFields.fields[type] }, { fields: selection });
+    }
+    const targetType = config2.schema.getType(type);
+    if (!targetType) {
+      continue;
+    }
+    if (graphql13.isAbstractType(targetType)) {
+      for (const possible of config2.schema.getPossibleTypes(targetType)) {
+        if (target.abstractFields?.fields[possible.name]) {
+          applyMask(
+            config2,
+            { fields: target.abstractFields.fields[possible.name] },
+            { fields: selection }
+          );
+        }
+      }
+    }
+    const mappedType = target.abstractFields?.typeMap[type];
+    if (target.abstractFields && mappedType && target.abstractFields.fields[mappedType]) {
+      applyMask(
+        config2,
+        { fields: target.abstractFields.fields[mappedType] },
+        { fields: selection }
+      );
+    }
+  }
+}
 
 // src/codegen/generators/runtime/graphqlFunction.ts
 var recast6 = __toESM(require_main2(), 1);
@@ -59703,7 +59984,7 @@ function addReferencedInputTypes(config2, filepath, body, visitedTypes, missingS
 var graphql17 = __toESM(require_graphql2(), 1);
 var recast10 = __toESM(require_main2(), 1);
 var AST10 = recast10.types.builders;
-var fragmentKey = "$fragments";
+var fragmentKey2 = " $fragments";
 function inlineType({
   config: config2,
   filepath,
@@ -59743,24 +60024,24 @@ function inlineType({
     const rootObj = type;
     const inlineFragments = {};
     const selectedFields = [];
-    for (const selection2 of selections) {
-      if (selection2.kind === "InlineFragment" && selection2.typeCondition) {
-        const fragmentType = config2.schema.getType(selection2.typeCondition.name.value);
+    for (const selection of selections) {
+      if (selection.kind === "InlineFragment" && selection.typeCondition) {
+        const fragmentType = config2.schema.getType(selection.typeCondition.name.value);
         if (!graphql17.isInterfaceType(type) && !graphql17.isUnionType(type)) {
-          selectedFields.push(...selection2.selectionSet.selections);
+          selectedFields.push(...selection.selectionSet.selections);
           continue;
         }
         if (!graphql17.isInterfaceType(fragmentType) && !graphql17.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 = config2.schema.getPossibleTypes(type).map((t) => t.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) {
@@ -59783,23 +60064,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(config2.schema, filepath, rootObj, selection2);
-        const attributeName = selection2.alias?.value || selection2.name.value;
+      ...fields.map((selection) => {
+        const { field } = selectionTypeInfo(config2.schema, filepath, rootObj, selection);
+        const attributeName = selection.alias?.value || selection.name.value;
         let attributeType = inlineType({
           config: config2,
           filepath,
           rootType: field.type,
-          selections: selection2.selectionSet?.selections,
+          selections: selection.selectionSet?.selections,
           root: false,
           allowReadonly,
           visitedTypes,
@@ -59808,7 +60096,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) {
@@ -59832,15 +60120,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([]))
                   )
                 )
               )
@@ -59850,7 +60136,7 @@ function inlineType({
         )
       );
     }
-    const inlineFragmentSelections = Object.entries(inlineFragments).flatMap(([typeName, fragment]) => {
+    const inlineFragmentSelections = Object.entries(inlineFragments).flatMap(([typeName, fragment2]) => {
       const fragmentRootType = config2.schema.getType(typeName);
       if (!fragmentRootType) {
         return [];
@@ -59859,7 +60145,7 @@ function inlineType({
         config: config2,
         filepath,
         rootType: fragmentRootType,
-        selections: fragment,
+        selections: fragment2,
         allowReadonly,
         visitedTypes,
         root,
@@ -59931,10 +60217,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",
@@ -60005,7 +60291,7 @@ async function generateDocumentTypes(config2, docs) {
           filepath: filename,
           selections: definition.selectionSet.selections,
           fragmentDefinitions,
-          applyFragments: definition.kind === "OperationDefinition"
+          keepFragmentSpreadNodes: true
         });
         if (definition?.kind === "OperationDefinition") {
           await generateOperationTypeDefs(
@@ -60229,39 +60515,26 @@ async function generateFragmentTypeDefs(config2, filepath, body, selections, def
     if (!type) {
       throw new Error("Should not get here");
     }
-    let extraExports = [];
     let directive = definition.directives?.find(
       (directive2) => directive2.name.value === config2.argumentsDirective
     );
-    if (directive) {
-      extraExports.push(
-        AST11.exportNamedDeclaration(
-          AST11.tsTypeAliasDeclaration(
-            AST11.identifier(inputTypeName),
-            AST11.tsTypeLiteral(
-              (fragmentArgumentsDefinitions(config2, filepath, definition) || []).map(
-                (definition2) => {
-                  return AST11.tsPropertySignature(
-                    AST11.identifier(definition2.variable.name.value),
-                    AST11.tsTypeAnnotation(
-                      tsTypeReference(
-                        config2,
-                        missingScalars,
-                        definition2,
-                        body
-                      )
-                    ),
-                    definition2.type.kind !== "NonNullType"
-                  );
-                }
-              )
-            )
-          )
-        )
-      );
-    }
+    let inputValue = !directive ? AST11.tsTypeLiteral([]) : AST11.tsTypeLiteral(
+      (fragmentArgumentsDefinitions(config2, filepath, definition) || []).map(
+        (definition2) => {
+          return AST11.tsPropertySignature(
+            AST11.identifier(definition2.variable.name.value),
+            AST11.tsTypeAnnotation(
+              tsTypeReference(config2, 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),
@@ -60277,14 +60550,12 @@ async function generateFragmentTypeDefs(config2, 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())
                     )
                   ])
                 )
@@ -60996,6 +61267,13 @@ async function addID(config2, documents) {
           return;
         }
         return addKeysToSelection(config2, node, fragmentType);
+      },
+      FragmentDefinition(node) {
+        const fragmentType = config2.schema.getType(node.typeCondition.name.value);
+        if (!fragmentType) {
+          return;
+        }
+        return addKeysToSelection(config2, node, fragmentType);
       }
     });
   }
@@ -61014,7 +61292,7 @@ function addKeysToSelection(config2, 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;
     }