houdini 1.2.44 → 1.2.45

package/build/vite-cjs/index.js

@@ -61321,7 +61321,7 @@ function watchAndRun(params) {
 }
 
 // src/codegen/index.ts
-var graphql33 = __toESM(require("graphql"), 1);
+var graphql32 = __toESM(require("graphql"), 1);
 
 // src/lib/pipeline.ts
 async function runPipeline(config2, pipeline2, target) {
@@ -64582,47 +64582,6 @@ function deepMerge(...objects) {
   return mergedObj;
 }
 
-// src/runtime/lib/scalars.ts
-async function marshalSelection({
-  selection,
-  data
-}) {
-  const config2 = getCurrentConfig();
-  if (data === null || typeof data === "undefined") {
-    return data;
-  }
-  if (Array.isArray(data)) {
-    return await Promise.all(data.map((val) => marshalSelection({ selection, data: val })));
-  }
-  const targetSelection = getFieldsForType(selection, data["__typename"], false);
-  return Object.fromEntries(
-    await Promise.all(
-      Object.entries(data).map(async ([fieldName, value]) => {
-        const { type, selection: selection2 } = targetSelection[fieldName];
-        if (!type) {
-          return [fieldName, value];
-        }
-        if (selection2) {
-          return [fieldName, await marshalSelection({ selection: selection2, data: value })];
-        }
-        if (config2.scalars?.[type]) {
-          const marshalFn = config2.scalars[type].marshal;
-          if (!marshalFn) {
-            throw new Error(
-              `scalar type ${type} is missing a \`marshal\` function. see https://github.com/AlecAivazis/houdini#%EF%B8%8Fcustom-scalars`
-            );
-          }
-          if (Array.isArray(value)) {
-            return [fieldName, value.map(marshalFn)];
-          }
-          return [fieldName, marshalFn(value)];
-        }
-        return [fieldName, value];
-      })
-    )
-  );
-}
-
 // src/runtime/lib/types.ts
 var CachePolicy = {
   CacheOrNetwork: "CacheOrNetwork",
@@ -64650,11 +64609,6 @@ var RefetchUpdateMode = {
   prepend: "prepend",
   replace: "replace"
 };
-var DataSource = {
-  Cache: "cache",
-  Network: "network",
-  Ssr: "ssr"
-};
 var fragmentKey = " $fragments";
 var PendingValue = Symbol("houdini_loading");
 
@@ -68425,202 +68379,6 @@ 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 () => {
-    const sourceHandlers = source();
-    const enterWrapper = (handler) => {
-      return !handler ? void 0 : (ctx, handlers) => {
-        if (ctx.artifact.kind !== kind) {
-          return handlers.next(ctx);
-        }
-        return handler(ctx, handlers);
-      };
-    };
-    const exitWrapper = (handler) => {
-      return !handler ? void 0 : (ctx, handlers) => {
-        if (ctx.artifact.kind !== kind) {
-          return handlers.resolve(ctx);
-        }
-        return handler(ctx, handlers);
-      };
-    };
-    return {
-      start: enterWrapper(sourceHandlers.start),
-      network: enterWrapper(sourceHandlers.network),
-      afterNetwork: exitWrapper(sourceHandlers.afterNetwork),
-      end: exitWrapper(sourceHandlers.end),
-      catch: sourceHandlers.catch ? (ctx, handlers) => sourceHandlers.catch(ctx, handlers) : void 0,
-      cleanup: (...args) => sourceHandlers.cleanup?.(...args)
-    };
-  };
-};
-
-// src/runtime/client/plugins/query.ts
-var query = documentPlugin(ArtifactKind.Query, function() {
-  let subscriptionSpec = null;
-  let lastVariables = null;
-  return {
-    start(ctx, { next }) {
-      const runtimeScalarPayload = {
-        session: ctx.session
-      };
-      ctx.variables = {
-        ...lastVariables,
-        ...Object.fromEntries(
-          Object.entries(ctx.artifact.input?.runtimeScalars ?? {}).map(
-            ([field, type]) => {
-              const runtimeScalar = ctx.config.features?.runtimeScalars?.[type];
-              if (!runtimeScalar) {
-                return [field, type];
-              }
-              return [field, runtimeScalar.resolve(runtimeScalarPayload)];
-            }
-          )
-        ),
-        ...ctx.variables
-      };
-      next(ctx);
-    },
-    end(ctx, { resolve: resolve2, marshalVariables, variablesChanged }) {
-      if (variablesChanged(ctx) && !ctx.cacheParams?.disableSubscriptions) {
-        if (subscriptionSpec) {
-          cache_default.unsubscribe(subscriptionSpec, subscriptionSpec.variables?.() || {});
-        }
-        lastVariables = { ...marshalVariables(ctx) };
-        const variables = lastVariables;
-        subscriptionSpec = {
-          rootType: ctx.artifact.rootType,
-          selection: ctx.artifact.selection,
-          variables: () => variables,
-          set: (newValue) => {
-            resolve2(ctx, {
-              data: newValue,
-              errors: null,
-              fetching: false,
-              partial: false,
-              stale: false,
-              source: DataSource.Cache,
-              variables: ctx.variables ?? {}
-            });
-          }
-        };
-        cache_default.subscribe(subscriptionSpec, lastVariables);
-      }
-      resolve2(ctx);
-    },
-    cleanup() {
-      if (subscriptionSpec) {
-        cache_default.unsubscribe(subscriptionSpec, subscriptionSpec.variables?.());
-        lastVariables = null;
-      }
-    }
-  };
-});
-
-// src/runtime/client/plugins/fragment.ts
-var fragment = documentPlugin(ArtifactKind.Fragment, function() {
-  let subscriptionSpec = null;
-  let lastReference = null;
-  return {
-    start(ctx, { next, resolve: resolve2, variablesChanged, marshalVariables }) {
-      if (!ctx.stuff.parentID) {
-        return next(ctx);
-      }
-      const currentReference = {
-        parent: ctx.stuff.parentID,
-        variables: marshalVariables(ctx)
-      };
-      if (!ctx.cacheParams?.disableSubscriptions && (!deepEquals(lastReference, currentReference) || variablesChanged(ctx))) {
-        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);
-        lastReference = currentReference;
-      }
-      next(ctx);
-    },
-    cleanup() {
-      if (subscriptionSpec) {
-        cache_default.unsubscribe(subscriptionSpec, subscriptionSpec.variables?.());
-      }
-    }
-  };
-});
-
-// src/runtime/client/plugins/mutation.ts
-var mutation = documentPlugin(ArtifactKind.Mutation, () => {
-  return {
-    async start(ctx, { next, marshalVariables }) {
-      const layerOptimistic = cache_default._internal_unstable.storage.createLayer(true);
-      const optimisticResponse = ctx.stuff.optimisticResponse;
-      let toNotify = [];
-      if (optimisticResponse) {
-        toNotify = cache_default.write({
-          selection: ctx.artifact.selection,
-          data: await marshalSelection({
-            selection: ctx.artifact.selection,
-            data: optimisticResponse
-          }),
-          variables: marshalVariables(ctx),
-          layer: layerOptimistic.id
-        });
-      }
-      ctx.cacheParams = {
-        ...ctx.cacheParams,
-        layer: layerOptimistic,
-        notifySubscribers: toNotify,
-        forceNotify: true
-      };
-      next(ctx);
-    },
-    afterNetwork(ctx, { resolve: resolve2 }) {
-      if (ctx.cacheParams?.layer) {
-        cache_default.clearLayer(ctx.cacheParams.layer.id);
-      }
-      resolve2(ctx);
-    },
-    end(ctx, { resolve: resolve2, value }) {
-      const hasErrors = value.errors && value.errors.length > 0;
-      if (hasErrors) {
-        if (ctx.cacheParams?.layer) {
-          cache_default.clearLayer(ctx.cacheParams.layer.id);
-        }
-      }
-      if (ctx.cacheParams?.layer) {
-        cache_default._internal_unstable.storage.resolveLayer(ctx.cacheParams.layer.id);
-      }
-      resolve2(ctx);
-    },
-    catch(ctx, { error }) {
-      if (ctx.cacheParams?.layer) {
-        const { layer } = ctx.cacheParams;
-        cache_default.clearLayer(layer.id);
-        cache_default._internal_unstable.storage.resolveLayer(layer.id);
-      }
-      throw error;
-    }
-  };
-});
-
 // src/lib/types.ts
 var LogLevel = {
   Full: "full",
@@ -69634,7 +69392,7 @@ function formatErrors(e2, afterError) {
     afterError?.(e2);
   }
 }
-function unwrapType(config2, type, wrappers = []) {
+function unwrapType(config2, type, wrappers = [], convertRuntimeScalars) {
   if (type.kind === "NonNullType") {
     return unwrapType(config2, type.type, [TypeWrapper.NonNull, ...wrappers]);
   }
@@ -69650,6 +69408,11 @@ function unwrapType(config2, type, wrappers = []) {
   if (type instanceof graphql3.GraphQLList) {
     return unwrapType(config2, type.ofType, [TypeWrapper.List, ...wrappers]);
   }
+  if (convertRuntimeScalars && config2.configFile.features?.runtimeScalars?.[type.name.value]) {
+    type = config2.schema.getType(
+      config2.configFile.features?.runtimeScalars?.[type.name.value].type
+    );
+  }
   const namedType = config2.schema.getType(type.name.value || type.name);
   if (!namedType) {
     throw new Error("Unknown type: " + type.name.value || type.name);
@@ -69789,6 +69552,231 @@ async function cleanupFiles(pathFolder, listOfObj) {
   return allFilesNotInList;
 }
 
+// src/runtime/router/match.ts
+var param_pattern = /^(\[)?(\.\.\.)?(\w+)(?:=(\w+))?(\])?$/;
+function parse_page_pattern(id) {
+  const params = [];
+  const pattern = id === "/" ? /^\/$/ : new RegExp(
+    `^${get_route_segments(id).map((segment) => {
+      const rest_match = /^\[\.\.\.(\w+)(?:=(\w+))?\]$/.exec(segment);
+      if (rest_match) {
+        params.push({
+          name: rest_match[1],
+          matcher: rest_match[2],
+          optional: false,
+          rest: true,
+          chained: true
+        });
+        return "(?:/(.*))?";
+      }
+      const optional_match = /^\[\[(\w+)(?:=(\w+))?\]\]$/.exec(segment);
+      if (optional_match) {
+        params.push({
+          name: optional_match[1],
+          matcher: optional_match[2],
+          optional: true,
+          rest: false,
+          chained: true
+        });
+        return "(?:/([^/]+))?";
+      }
+      if (!segment) {
+        return;
+      }
+      const parts = segment.split(/\[(.+?)\](?!\])/);
+      const result = parts.map((content, i2) => {
+        if (i2 % 2) {
+          if (content.startsWith("x+")) {
+            return escape2(
+              String.fromCharCode(parseInt(content.slice(2), 16))
+            );
+          }
+          if (content.startsWith("u+")) {
+            return escape2(
+              String.fromCharCode(
+                ...content.slice(2).split("-").map((code) => parseInt(code, 16))
+              )
+            );
+          }
+          const match = param_pattern.exec(content);
+          if (!match) {
+            throw new Error(
+              `Invalid param: ${content}. Params and matcher names can only have underscores and alphanumeric characters.`
+            );
+          }
+          const [, is_optional, is_rest, name, matcher] = match;
+          params.push({
+            name,
+            matcher,
+            optional: !!is_optional,
+            rest: !!is_rest,
+            chained: is_rest ? i2 === 1 && parts[0] === "" : false
+          });
+          return is_rest ? "(.*?)" : is_optional ? "([^/]*)?" : "([^/]+?)";
+        }
+        return escape2(content);
+      }).join("");
+      return "/" + result;
+    }).join("")}/?$`
+  );
+  return { pattern, params, page_id: id };
+}
+function affects_path(segment) {
+  return !/^\([^)]+\)$/.test(segment);
+}
+function get_route_segments(route) {
+  return route.slice(1).split("/").filter(affects_path);
+}
+function escape2(str) {
+  return str.normalize().replace(/[[\]]/g, "\\$&").replace(/%/g, "%25").replace(/\//g, "%2[Ff]").replace(/\?/g, "%3[Ff]").replace(/#/g, "%23").replace(/[.*+?^${}()|\\]/g, "\\$&");
+}
+
+// src/lib/typescript.ts
+var graphql4 = __toESM(require("graphql"), 1);
+var recast2 = __toESM(require_main2(), 1);
+var AST2 = recast2.types.builders;
+function unwrappedTsTypeReference(config2, filepath, missingScalars, {
+  type,
+  wrappers
+}, body) {
+  let result;
+  if (graphql4.isScalarType(type)) {
+    result = scalarPropertyValue(config2, filepath, missingScalars, type, body, null);
+  } else if (graphql4.isEnumType(type)) {
+    result = enumReference(config2, body, type.name);
+  } else {
+    result = AST2.tsTypeReference(AST2.identifier(type.name));
+  }
+  for (const toWrap of wrappers) {
+    if (toWrap === "NonNull" /* NonNull */) {
+      continue;
+    } else if (toWrap === "Nullable" /* Nullable */) {
+      result = nullableField(result, true);
+    } else if (toWrap === "List" /* List */) {
+      result = AST2.tsArrayType(AST2.tsParenthesizedType(result));
+    }
+  }
+  return result;
+}
+function tsTypeReference(config2, filepath, missingScalars, definition, body) {
+  const { type, wrappers } = unwrapType(config2, definition.type);
+  return unwrappedTsTypeReference(
+    config2,
+    filepath,
+    missingScalars,
+    { type, wrappers },
+    body
+  );
+}
+function enumReference(config2, body, name) {
+  ensureImports({
+    config: config2,
+    body,
+    import: ["ValueOf"],
+    importKind: "type",
+    sourceModule: "$houdini/runtime/lib/types"
+  });
+  return AST2.tsTypeReference(
+    AST2.identifier("ValueOf"),
+    AST2.tsTypeParameterInstantiation([AST2.tsTypeQuery(AST2.identifier(name))])
+  );
+}
+function readonlyProperty(prop, enable = true) {
+  if (enable) {
+    prop.readonly = true;
+  }
+  return prop;
+}
+function nullableField(inner, input = false) {
+  const members = [inner, AST2.tsNullKeyword()];
+  if (input) {
+    members.push(AST2.tsUndefinedKeyword());
+  }
+  return AST2.tsUnionType(members);
+}
+function scalarPropertyValue(config2, filepath, missingScalars, target, body, field) {
+  if (config2.configFile.features?.componentFields && target.name === config2.componentScalar) {
+    if (!field) {
+      return AST2.tsNeverKeyword();
+    }
+    const component = config2.componentFields[field.parent][field.field];
+    const sourcePathRelative = path_exports.relative(
+      path_exports.join(config2.projectRoot, "src"),
+      component.filepath
+    );
+    let sourcePathParsed = path_exports.parse(sourcePathRelative);
+    let sourcePath = path_exports.join(sourcePathParsed.dir, sourcePathParsed.name);
+    const localImport = ensureImports({
+      config: config2,
+      body,
+      import: "__component__" + component.fragment,
+      sourceModule: path_exports.join(
+        path_exports.relative(path_exports.dirname(filepath), config2.projectRoot),
+        "src",
+        sourcePath
+      )
+    }) ?? "__component__" + component.fragment;
+    const parameters = AST2.tsTypeReference(AST2.identifier("Parameters"));
+    parameters.typeParameters = AST2.tsTypeParameterInstantiation([
+      AST2.tsTypeQuery(AST2.identifier(localImport))
+    ]);
+    const indexed = AST2.tsIndexedAccessType(
+      parameters,
+      AST2.tsLiteralType(AST2.numericLiteral(0))
+    );
+    const omit = AST2.tsTypeReference(AST2.identifier("Omit"));
+    omit.typeParameters = AST2.tsTypeParameterInstantiation([
+      indexed,
+      AST2.tsLiteralType(AST2.stringLiteral(component.prop))
+    ]);
+    const arg = AST2.identifier("props");
+    arg.typeAnnotation = AST2.tsTypeAnnotation(omit);
+    const returnType = AST2.tsTypeReference(AST2.identifier("ReturnType"));
+    returnType.typeParameters = AST2.tsTypeParameterInstantiation([
+      AST2.tsTypeQuery(AST2.identifier(localImport))
+    ]);
+    const fnType = AST2.tsFunctionType([arg]);
+    fnType.typeAnnotation = AST2.tsTypeAnnotation(returnType);
+    return fnType;
+  }
+  switch (target.name) {
+    case "String": {
+      return AST2.tsStringKeyword();
+    }
+    case "Int": {
+      return AST2.tsNumberKeyword();
+    }
+    case "Float": {
+      return AST2.tsNumberKeyword();
+    }
+    case "Boolean": {
+      return AST2.tsBooleanKeyword();
+    }
+    case "ID": {
+      return AST2.tsStringKeyword();
+    }
+    default: {
+      if (graphql4.isNonNullType(target) && "ofType" in target) {
+        return scalarPropertyValue(
+          config2,
+          filepath,
+          missingScalars,
+          target.ofType,
+          body,
+          field
+        );
+      }
+      if (config2.scalars?.[target.name]) {
+        return AST2.tsTypeReference(AST2.identifier(config2.scalars?.[target.name].type));
+      }
+      if (target.name !== config2.componentScalar) {
+        missingScalars.add(target.name);
+      }
+      return AST2.tsAnyKeyword();
+    }
+  }
+}
+
 // ../../node_modules/.pnpm/estree-walker@3.0.1/node_modules/estree-walker/src/walker.js
 var WalkerBase = class {
   constructor() {
@@ -69902,7 +69890,7 @@ async function asyncWalk(ast, { enter, leave }) {
 }
 
 // src/lib/walk.ts
-var graphql4 = __toESM(require("graphql"), 1);
+var graphql5 = __toESM(require("graphql"), 1);
 async function find_graphql(config2, parsedScript, walker) {
   await asyncWalk(parsedScript, {
     async enter(node, parent2) {
@@ -69957,7 +69945,7 @@ async function find_graphql(config2, parsedScript, walker) {
       } else if (!documentString) {
         return;
       }
-      const parsedTag = graphql4.parse(documentString);
+      const parsedTag = graphql5.parse(documentString);
       if (walker.where && !walker.where(parsedTag, { node, parent: parent2 })) {
         return;
       }
@@ -70089,7 +70077,7 @@ function extractAnonymousQuery(config2, raw, expr, propName) {
       };
       return defs.concat([
         {
-          raw: graphql4.print(parsed),
+          raw: graphql5.print(parsed),
           parsed
         }
       ]);
@@ -70230,7 +70218,7 @@ function serialized_manifest_path(config2, base = base_dir(config2)) {
 
 // src/lib/router/manifest.ts
 var t2 = __toESM(require_lib6(), 1);
-var graphql5 = __toESM(require("graphql"), 1);
+var graphql6 = __toESM(require("graphql"), 1);
 async function load_manifest(args) {
   const manifest = await walk_routes({
     config: args.config,
@@ -70247,7 +70235,8 @@ async function load_manifest(args) {
       local_yoga: false
     },
     queries: [],
-    layouts: []
+    layouts: [],
+    variables: {}
   });
   if (args.includeArtifacts) {
     try {
@@ -70278,6 +70267,7 @@ async function walk_routes(args) {
   const directory_contents = await fs_exports.readdir(args.filepath, {
     withFileTypes: true
   });
+  const variables = { ...args.variables };
   let newLayouts = args.layouts;
   let newLayoutQueries = args.queries;
   let layout = null;
@@ -70301,7 +70291,8 @@ async function walk_routes(args) {
       url: args.url,
       project: args.project,
       type: "layout",
-      contents: layoutQueryContents
+      contents: layoutQueryContents,
+      variables
     });
     newLayoutQueries = [...args.queries, layoutQuery.name];
   }
@@ -70314,7 +70305,8 @@ async function walk_routes(args) {
       contents: layoutViewContents,
       layouts: args.layouts,
       queries: newLayoutQueries,
-      config: args.config
+      config: args.config,
+      variables
     });
     newLayouts = [...args.layouts, page_id(layout.url)];
   }
@@ -70325,7 +70317,8 @@ async function walk_routes(args) {
       url: args.url,
       project: args.project,
       type: "page",
-      contents: pageQueryContents
+      contents: pageQueryContents,
+      variables
     });
   }
   if (pageViewContents) {
@@ -70337,7 +70330,8 @@ async function walk_routes(args) {
       contents: pageViewContents,
       layouts: newLayouts,
       queries: pageQuery ? [...newLayoutQueries, pageQuery.name] : newLayoutQueries,
-      config: args.config
+      config: args.config,
+      variables
     });
   }
   await Promise.all(
@@ -70350,7 +70344,8 @@ async function walk_routes(args) {
         filepath: path_exports.join(args.filepath, dir.name),
         url: `${args.url}${dir.name}/`,
         queries: newLayoutQueries,
-        layouts: newLayouts
+        layouts: newLayouts,
+        variables
       });
     })
   );
@@ -70372,12 +70367,18 @@ async function add_view(args) {
     url: args.url,
     layouts: args.layouts,
     path: path_exports.relative(args.config.projectRoot, args.path),
-    query_options: args.queries
+    query_options: args.queries,
+    params: Object.fromEntries(
+      parse_page_pattern(args.url).params.map((param) => [
+        param.name,
+        args.variables[param.name] ?? null
+      ])
+    )
   };
   return target[id];
 }
 async function add_query(args) {
-  const parsed = graphql5.parse(args.contents);
+  const parsed = graphql6.parse(args.contents);
   const query2 = parsed.definitions.find(
     (def) => def.kind === "OperationDefinition" && def.operation === "query"
   );
@@ -70385,20 +70386,30 @@ async function add_query(args) {
     throw new Error("No query found");
   }
   let loading = false;
-  await graphql5.visit(parsed, {
+  await graphql6.visit(parsed, {
     Directive(node) {
       if (node.name.value === args.config.loadingDirective) {
         loading = true;
       }
     }
   });
+  const queryVariables = Object.fromEntries(
+    query2.variableDefinitions?.map((variable) => {
+      const { type, wrappers } = unwrapType(args.config, variable.type, [], true);
+      return [
+        variable.variable.name.value,
+        { wrappers, type: type.name }
+      ];
+    }) ?? []
+  );
+  Object.assign(args.variables, queryVariables);
   const target = args.type === "page" ? args.project.page_queries : args.project.layout_queries;
   target[page_id(args.url)] = {
     path: path_exports.relative(args.config.routesDir, args.path),
     name: query2.name.value,
     url: args.url,
     loading,
-    variables: query2.variableDefinitions?.map((variable) => variable.variable.name.value) ?? []
+    variables: queryVariables
   };
   return target[page_id(args.url)];
 }
@@ -70494,8 +70505,8 @@ async function loadLocalSchema(config2) {
 }
 
 // src/codegen/generators/artifacts/index.ts
-var graphql16 = __toESM(require("graphql"), 1);
-var recast4 = __toESM(require_main2(), 1);
+var graphql17 = __toESM(require("graphql"), 1);
+var recast5 = __toESM(require_main2(), 1);
 
 // src/codegen/utils/commonjs.ts
 var cjsIndexFilePreamble = `"use strict";
@@ -70737,19 +70748,19 @@ var FieldCollection = class {
 };
 
 // src/codegen/utils/moduleExport.ts
-var recast2 = __toESM(require_main2(), 1);
-var AST2 = recast2.types.builders;
+var recast3 = __toESM(require_main2(), 1);
+var AST3 = recast3.types.builders;
 function moduleExport(config2, key, value) {
   if (config2.module === "commonjs") {
-    let target = AST2.memberExpression(AST2.identifier("module"), AST2.identifier("exports"));
+    let target = AST3.memberExpression(AST3.identifier("module"), AST3.identifier("exports"));
     if (key !== "default") {
-      target = AST2.memberExpression(target, AST2.identifier(key));
+      target = AST3.memberExpression(target, AST3.identifier(key));
     }
-    return AST2.expressionStatement(AST2.assignmentExpression("=", target, value));
+    return AST3.expressionStatement(AST3.assignmentExpression("=", target, value));
   }
-  return key === "default" ? AST2.exportDefaultDeclaration(value) : AST2.exportNamedDeclaration(
-    AST2.variableDeclaration("const", [
-      AST2.variableDeclarator(AST2.identifier(key), value)
+  return key === "default" ? AST3.exportDefaultDeclaration(value) : AST3.exportNamedDeclaration(
+    AST3.variableDeclaration("const", [
+      AST3.variableDeclarator(AST3.identifier(key), value)
     ])
   );
 }
@@ -71006,7 +71017,7 @@ var serialize = (value, { json, lossy } = {}) => {
 var esm_default = typeof structuredClone === "function" ? (any, options) => options && ("json" in options || "lossy" in options) ? deserialize(serialize(any, options)) : structuredClone(any) : (any, options) => deserialize(serialize(any, options));
 
 // src/codegen/transforms/fragmentVariables.ts
-var graphql7 = __toESM(require("graphql"), 1);
+var graphql8 = __toESM(require("graphql"), 1);
 
 // src/codegen/utils/stripLoc.ts
 function stripLoc(value) {
@@ -71027,13 +71038,13 @@ function stripLoc(value) {
 }
 
 // src/codegen/transforms/collectDefinitions.ts
-var graphql6 = __toESM(require("graphql"), 1);
-var import_graphql31 = require("graphql");
+var graphql7 = __toESM(require("graphql"), 1);
+var import_graphql32 = require("graphql");
 async function includeFragmentDefinitions(config2, documents) {
   const fragments = collectDefinitions(config2, documents);
   for (const [index, { name, document, filename }] of documents.entries()) {
     const operation = document.definitions.find(
-      (def) => def.kind === import_graphql31.Kind.OPERATION_DEFINITION || def.kind === "FragmentDefinition"
+      (def) => def.kind === import_graphql32.Kind.OPERATION_DEFINITION || def.kind === "FragmentDefinition"
     );
     if (!operation) {
       continue;
@@ -71077,10 +71088,10 @@ function collectDefinitions(config2, docs) {
 }
 function findRequiredFragments(config2, definition) {
   const referencedFragments = [];
-  const typeInfo = new graphql6.TypeInfo(config2.schema);
-  definition.selectionSet = graphql6.visit(
+  const typeInfo = new graphql7.TypeInfo(config2.schema);
+  definition.selectionSet = graphql7.visit(
     definition,
-    graphql6.visitWithTypeInfo(typeInfo, {
+    graphql7.visitWithTypeInfo(typeInfo, {
       FragmentSpread(node) {
         referencedFragments.push(node.name.value);
       }
@@ -71114,7 +71125,7 @@ function flattenFragments(filepath, operation, fragments) {
 }
 
 // src/codegen/transforms/fragmentVariables.ts
-var GraphqlKinds2 = graphql7.Kind;
+var GraphqlKinds2 = graphql8.Kind;
 async function fragmentVariables(config2, documents) {
   const fragments = collectDefinitions(config2, documents);
   const generatedFragments = {};
@@ -71137,7 +71148,7 @@ async function fragmentVariables(config2, documents) {
     });
   }
   const doc = {
-    kind: graphql7.Kind.DOCUMENT,
+    kind: graphql8.Kind.DOCUMENT,
     definitions: Object.values(generatedFragments)
   };
   documents.push({
@@ -71208,7 +71219,7 @@ function inlineFragmentArgs({
     return null;
   };
   const result = esm_default(
-    graphql7.visit(document, {
+    graphql8.visit(document, {
       FragmentSpread(node) {
         if (!fragmentDefinitions[node.name.value]) {
           throw new Error("Could not find definition for fragment" + node.name.value);
@@ -71294,7 +71305,7 @@ function inlineFragmentArgs({
   );
   if (newName) {
     result.name = {
-      kind: graphql7.Kind.NAME,
+      kind: graphql8.Kind.NAME,
       value: newName
     };
   }
@@ -71461,7 +71472,7 @@ ${exportDefaultFrom(`./${doc.name}`, doc.name)}`,
 }
 
 // src/codegen/generators/artifacts/inputs.ts
-var graphql8 = __toESM(require("graphql"), 1);
+var graphql9 = __toESM(require("graphql"), 1);
 function inputObject(config2, inputs, runtimeScalars) {
   const visitedTypes = /* @__PURE__ */ new Set();
   const inputObj = {
@@ -71491,10 +71502,10 @@ function walkInputs(config2, visitedTypes, inputObj, rootType) {
   if (visitedTypes.has(type.name)) {
     return;
   }
-  if (graphql8.isEnumType(type) || graphql8.isScalarType(type)) {
+  if (graphql9.isEnumType(type) || graphql9.isScalarType(type)) {
     return;
   }
-  if (graphql8.isUnionType(type)) {
+  if (graphql9.isUnionType(type)) {
     return;
   }
   visitedTypes.add(type.name);
@@ -71512,50 +71523,50 @@ function walkInputs(config2, visitedTypes, inputObj, rootType) {
 }
 
 // src/codegen/generators/artifacts/operations.ts
-var graphql10 = __toESM(require("graphql"), 1);
+var graphql11 = __toESM(require("graphql"), 1);
 
 // src/codegen/generators/artifacts/utils.ts
-var graphql9 = __toESM(require("graphql"), 1);
-var recast3 = __toESM(require_main2(), 1);
-var AST3 = recast3.types.builders;
+var graphql10 = __toESM(require("graphql"), 1);
+var recast4 = __toESM(require_main2(), 1);
+var AST4 = recast4.types.builders;
 function serializeValue(value) {
   if (Array.isArray(value)) {
-    return AST3.arrayExpression(value.map(serializeValue));
+    return AST4.arrayExpression(value.map(serializeValue));
   }
   if (typeof value === "object" && value !== null) {
-    return AST3.objectExpression(
+    return AST4.objectExpression(
       Object.entries(value).filter(([key, value2]) => typeof value2 !== "undefined").map(([key, val]) => {
-        return AST3.objectProperty(AST3.stringLiteral(key), serializeValue(val));
+        return AST4.objectProperty(AST4.stringLiteral(key), serializeValue(val));
       })
     );
   }
   if (typeof value === "string") {
     if (value.indexOf("\n") !== -1) {
-      return AST3.templateLiteral(
-        [AST3.templateElement({ raw: value, cooked: value }, true)],
+      return AST4.templateLiteral(
+        [AST4.templateElement({ raw: value, cooked: value }, true)],
         []
       );
     }
-    return AST3.stringLiteral(value);
+    return AST4.stringLiteral(value);
   }
-  return AST3.literal(value);
+  return AST4.literal(value);
 }
 function convertValue(config2, val) {
   let value;
   let kind;
-  if (val.kind === graphql9.Kind.INT) {
+  if (val.kind === graphql10.Kind.INT) {
     value = parseInt(val.value, 10);
     kind = "Int";
-  } else if (val.kind === graphql9.Kind.FLOAT) {
+  } else if (val.kind === graphql10.Kind.FLOAT) {
     value = parseFloat(val.value);
     kind = "Float";
-  } else if (val.kind === graphql9.Kind.BOOLEAN) {
+  } else if (val.kind === graphql10.Kind.BOOLEAN) {
     value = val.value;
     kind = "Boolean";
-  } else if (val.kind === graphql9.Kind.VARIABLE) {
+  } else if (val.kind === graphql10.Kind.VARIABLE) {
     value = val.name.value;
     kind = "Variable";
-  } else if (val.kind === graphql9.Kind.STRING) {
+  } else if (val.kind === graphql10.Kind.STRING) {
     value = val.value;
     kind = "String";
   }
@@ -71568,7 +71579,7 @@ function operationsByPath(config2, filepath, definition, filterTypes) {
     return {};
   }
   const pathOperations = {};
-  graphql10.visit(definition, {
+  graphql11.visit(definition, {
     FragmentSpread(node, _, __, ___, ancestors) {
       if (!config2.isListFragment(node.name.value)) {
         return;
@@ -71727,19 +71738,19 @@ function ancestorKey(ancestors) {
 }
 
 // src/codegen/generators/artifacts/selection.ts
-var graphql15 = __toESM(require("graphql"), 1);
+var graphql16 = __toESM(require("graphql"), 1);
 
 // src/codegen/transforms/list.ts
-var graphql13 = __toESM(require("graphql"), 1);
+var graphql14 = __toESM(require("graphql"), 1);
 
 // src/codegen/utils/objectIdentificationSelection.ts
-var graphql11 = __toESM(require("graphql"), 1);
+var graphql12 = __toESM(require("graphql"), 1);
 var objectIdentificationSelection = (config2, type) => {
   return config2.keyFieldsForType(type.name).map((key) => {
     return {
-      kind: graphql11.Kind.FIELD,
+      kind: graphql12.Kind.FIELD,
       name: {
-        kind: graphql11.Kind.NAME,
+        kind: graphql12.Kind.NAME,
         value: key
       }
     };
@@ -71747,7 +71758,7 @@ var objectIdentificationSelection = (config2, type) => {
 };
 
 // src/codegen/transforms/paginate.ts
-var graphql12 = __toESM(require("graphql"), 1);
+var graphql13 = __toESM(require("graphql"), 1);
 async function paginate(config2, documents) {
   const newDocs = [];
   for (const doc of documents) {
@@ -71780,7 +71791,7 @@ async function paginate(config2, documents) {
     };
     let cursorType = "String";
     let paginationPath = [];
-    doc.document = graphql12.visit(doc.document, {
+    doc.document = graphql13.visit(doc.document, {
       Field(node, _, __, ___, ancestors) {
         const paginateDirective = node.directives?.find(
           (directive) => directive.name.value === config2.paginateDirective
@@ -71806,7 +71817,7 @@ async function paginate(config2, documents) {
         flags.offset.enabled = offsetPagination;
         flags.limit.enabled = offsetPagination;
         paginationPath = ancestors.filter(
-          (ancestor) => !Array.isArray(ancestor) && ancestor.kind === graphql12.Kind.FIELD
+          (ancestor) => !Array.isArray(ancestor) && ancestor.kind === graphql13.Kind.FIELD
         ).concat(node).map((field) => field.alias?.value || field.name.value);
         return {
           ...node,
@@ -71825,7 +71836,7 @@ async function paginate(config2, documents) {
       let fragment2 = "";
       let paginateMode = config2.defaultPaginateMode;
       const requiredArgs = [];
-      doc.document = graphql12.visit(doc.document, {
+      doc.document = graphql13.visit(doc.document, {
         OperationDefinition(node) {
           if (node.operation !== "query") {
             throw new HoudiniError({
@@ -71884,9 +71895,9 @@ async function paginate(config2, documents) {
               directives: [
                 ...node.directives || [],
                 {
-                  kind: graphql12.Kind.DIRECTIVE,
+                  kind: graphql13.Kind.DIRECTIVE,
                   name: {
-                    kind: graphql12.Kind.NAME,
+                    kind: graphql13.Kind.NAME,
                     value: config2.argumentsDirective
                   }
                 }
@@ -71956,22 +71967,22 @@ async function paginate(config2, documents) {
       const paginationArgs = Object.entries(flags).filter(([_, { enabled }]) => enabled).map(([key, value]) => ({ name: key, ...value }));
       const fragmentSpreadSelection = [
         {
-          kind: graphql12.Kind.FRAGMENT_SPREAD,
+          kind: graphql13.Kind.FRAGMENT_SPREAD,
           name: {
-            kind: graphql12.Kind.NAME,
+            kind: graphql13.Kind.NAME,
             value: fragmentName
           },
           directives: [
             {
-              kind: graphql12.Kind.DIRECTIVE,
+              kind: graphql13.Kind.DIRECTIVE,
               name: {
-                kind: graphql12.Kind.NAME,
+                kind: graphql13.Kind.NAME,
                 value: config2.withDirective
               },
               ["arguments"]: requiredArgs.map((arg) => variableAsArgument(arg.name)).concat(paginationArgs.map(({ name }) => variableAsArgument(name)))
             },
             {
-              kind: graphql12.Kind.DIRECTIVE,
+              kind: graphql13.Kind.DIRECTIVE,
               name: {
                 kind: "Name",
                 value: config2.maskDisableDirective
@@ -71998,23 +72009,23 @@ async function paginate(config2, documents) {
       });
       const typeConfig = config2.typeConfig?.[fragment2];
       const queryDoc = {
-        kind: graphql12.Kind.DOCUMENT,
+        kind: graphql13.Kind.DOCUMENT,
         definitions: [
           {
-            kind: graphql12.Kind.OPERATION_DEFINITION,
+            kind: graphql13.Kind.OPERATION_DEFINITION,
             name: {
-              kind: graphql12.Kind.NAME,
+              kind: graphql13.Kind.NAME,
               value: refetchQueryName
             },
             operation: "query",
             variableDefinitions: requiredArgs.map(
               (arg) => ({
-                kind: graphql12.Kind.VARIABLE_DEFINITION,
+                kind: graphql13.Kind.VARIABLE_DEFINITION,
                 type: arg.type,
                 variable: {
-                  kind: graphql12.Kind.VARIABLE,
+                  kind: graphql13.Kind.VARIABLE,
                   name: {
-                    kind: graphql12.Kind.NAME,
+                    kind: graphql13.Kind.NAME,
                     value: arg.name
                   }
                 }
@@ -72022,18 +72033,18 @@ async function paginate(config2, documents) {
             ).concat(
               paginationArgs.map(
                 (arg) => ({
-                  kind: graphql12.Kind.VARIABLE_DEFINITION,
+                  kind: graphql13.Kind.VARIABLE_DEFINITION,
                   type: {
-                    kind: graphql12.Kind.NAMED_TYPE,
+                    kind: graphql13.Kind.NAMED_TYPE,
                     name: {
-                      kind: graphql12.Kind.NAME,
+                      kind: graphql13.Kind.NAME,
                       value: arg.type
                     }
                   },
                   variable: {
-                    kind: graphql12.Kind.VARIABLE,
+                    kind: graphql13.Kind.VARIABLE,
                     name: {
-                      kind: graphql12.Kind.NAME,
+                      kind: graphql13.Kind.NAME,
                       value: arg.name
                     }
                   },
@@ -72045,12 +72056,12 @@ async function paginate(config2, documents) {
               ).concat(
                 !nodeQuery ? [] : keys2.map(
                   (key) => ({
-                    kind: graphql12.Kind.VARIABLE_DEFINITION,
+                    kind: graphql13.Kind.VARIABLE_DEFINITION,
                     type: key.type,
                     variable: {
-                      kind: graphql12.Kind.VARIABLE,
+                      kind: graphql13.Kind.VARIABLE,
                       name: {
-                        kind: graphql12.Kind.NAME,
+                        kind: graphql13.Kind.NAME,
                         value: key.name
                       }
                     }
@@ -72059,42 +72070,42 @@ async function paginate(config2, documents) {
               )
             ),
             selectionSet: {
-              kind: graphql12.Kind.SELECTION_SET,
+              kind: graphql13.Kind.SELECTION_SET,
               selections: !nodeQuery ? fragmentSpreadSelection : [
                 {
-                  kind: graphql12.Kind.FIELD,
+                  kind: graphql13.Kind.FIELD,
                   name: {
-                    kind: graphql12.Kind.NAME,
+                    kind: graphql13.Kind.NAME,
                     value: typeConfig?.resolve?.queryField || "node"
                   },
                   ["arguments"]: keys2.map((key) => ({
-                    kind: graphql12.Kind.ARGUMENT,
+                    kind: graphql13.Kind.ARGUMENT,
                     name: {
-                      kind: graphql12.Kind.NAME,
+                      kind: graphql13.Kind.NAME,
                       value: key.name
                     },
                     value: {
-                      kind: graphql12.Kind.VARIABLE,
+                      kind: graphql13.Kind.VARIABLE,
                       name: {
-                        kind: graphql12.Kind.NAME,
+                        kind: graphql13.Kind.NAME,
                         value: key.name
                       }
                     }
                   })),
                   selectionSet: {
-                    kind: graphql12.Kind.SELECTION_SET,
+                    kind: graphql13.Kind.SELECTION_SET,
                     selections: [
                       {
-                        kind: graphql12.Kind.FIELD,
+                        kind: graphql13.Kind.FIELD,
                         name: {
-                          kind: graphql12.Kind.NAME,
+                          kind: graphql13.Kind.NAME,
                           value: "__typename"
                         }
                       },
                       ...(typeConfig?.keys || [config2.defaultKeys[0]]).map((key) => ({
-                        kind: graphql12.Kind.FIELD,
+                        kind: graphql13.Kind.FIELD,
                         name: {
-                          kind: graphql12.Kind.NAME,
+                          kind: graphql13.Kind.NAME,
                           value: key
                         }
                       })),
@@ -72151,15 +72162,15 @@ function replaceArgumentsWithVariables(args, flags) {
 }
 function variableAsArgument(name, variable) {
   return {
-    kind: graphql12.Kind.ARGUMENT,
+    kind: graphql13.Kind.ARGUMENT,
     name: {
-      kind: graphql12.Kind.NAME,
+      kind: graphql13.Kind.NAME,
       value: name
     },
     value: {
-      kind: graphql12.Kind.VARIABLE,
+      kind: graphql13.Kind.VARIABLE,
       name: {
-        kind: graphql12.Kind.NAME,
+        kind: graphql13.Kind.NAME,
         value: variable ?? name
       }
     }
@@ -72167,18 +72178,18 @@ function variableAsArgument(name, variable) {
 }
 function staticVariableDefinition(name, type, defaultValue, variableName) {
   return {
-    kind: graphql12.Kind.VARIABLE_DEFINITION,
+    kind: graphql13.Kind.VARIABLE_DEFINITION,
     type: {
-      kind: graphql12.Kind.NAMED_TYPE,
+      kind: graphql13.Kind.NAMED_TYPE,
       name: {
-        kind: graphql12.Kind.NAME,
+        kind: graphql13.Kind.NAME,
         value: type
       }
     },
     variable: {
-      kind: graphql12.Kind.VARIABLE,
+      kind: graphql13.Kind.VARIABLE,
       name: {
-        kind: graphql12.Kind.NAME,
+        kind: graphql13.Kind.NAME,
         value: variableName ?? name
       }
     },
@@ -72190,9 +72201,9 @@ function staticVariableDefinition(name, type, defaultValue, variableName) {
 }
 function argumentNode(name, value) {
   return {
-    kind: graphql12.Kind.ARGUMENT,
+    kind: graphql13.Kind.ARGUMENT,
     name: {
-      kind: graphql12.Kind.NAME,
+      kind: graphql13.Kind.NAME,
       value: name
     },
     value: objectNode(value)
@@ -72200,16 +72211,16 @@ function argumentNode(name, value) {
 }
 function objectNode([type, defaultValue]) {
   const node = {
-    kind: graphql12.Kind.OBJECT,
+    kind: graphql13.Kind.OBJECT,
     fields: [
       {
-        kind: graphql12.Kind.OBJECT_FIELD,
+        kind: graphql13.Kind.OBJECT_FIELD,
         name: {
-          kind: graphql12.Kind.NAME,
+          kind: graphql13.Kind.NAME,
           value: "type"
         },
         value: {
-          kind: graphql12.Kind.STRING,
+          kind: graphql13.Kind.STRING,
           value: type
         }
       }
@@ -72217,8 +72228,8 @@ function objectNode([type, defaultValue]) {
   };
   if (defaultValue) {
     node.fields.push({
-      kind: graphql12.Kind.OBJECT_FIELD,
-      name: { kind: graphql12.Kind.NAME, value: "default" },
+      kind: graphql13.Kind.OBJECT_FIELD,
+      name: { kind: graphql13.Kind.NAME, value: "default" },
       value: {
         kind: typeof defaultValue === "number" ? "IntValue" : "StringValue",
         value: defaultValue.toString()
@@ -72229,34 +72240,34 @@ function objectNode([type, defaultValue]) {
 }
 var pageInfoSelection = [
   {
-    kind: graphql12.Kind.FIELD,
+    kind: graphql13.Kind.FIELD,
     name: {
-      kind: graphql12.Kind.NAME,
+      kind: graphql13.Kind.NAME,
       value: "edges"
     },
     selectionSet: {
-      kind: graphql12.Kind.SELECTION_SET,
+      kind: graphql13.Kind.SELECTION_SET,
       selections: [
         {
-          kind: graphql12.Kind.FIELD,
+          kind: graphql13.Kind.FIELD,
           name: {
-            kind: graphql12.Kind.NAME,
+            kind: graphql13.Kind.NAME,
             value: "cursor"
           }
         },
         {
-          kind: graphql12.Kind.FIELD,
+          kind: graphql13.Kind.FIELD,
           name: {
-            kind: graphql12.Kind.NAME,
+            kind: graphql13.Kind.NAME,
             value: "node"
           },
           selectionSet: {
-            kind: graphql12.Kind.SELECTION_SET,
+            kind: graphql13.Kind.SELECTION_SET,
             selections: [
               {
-                kind: graphql12.Kind.FIELD,
+                kind: graphql13.Kind.FIELD,
                 name: {
-                  kind: graphql12.Kind.NAME,
+                  kind: graphql13.Kind.NAME,
                   value: "__typename"
                 }
               }
@@ -72267,39 +72278,39 @@ var pageInfoSelection = [
     }
   },
   {
-    kind: graphql12.Kind.FIELD,
+    kind: graphql13.Kind.FIELD,
     name: {
-      kind: graphql12.Kind.NAME,
+      kind: graphql13.Kind.NAME,
       value: "pageInfo"
     },
     selectionSet: {
-      kind: graphql12.Kind.SELECTION_SET,
+      kind: graphql13.Kind.SELECTION_SET,
       selections: [
         {
-          kind: graphql12.Kind.FIELD,
+          kind: graphql13.Kind.FIELD,
           name: {
-            kind: graphql12.Kind.NAME,
+            kind: graphql13.Kind.NAME,
             value: "hasPreviousPage"
           }
         },
         {
-          kind: graphql12.Kind.FIELD,
+          kind: graphql13.Kind.FIELD,
           name: {
-            kind: graphql12.Kind.NAME,
+            kind: graphql13.Kind.NAME,
             value: "hasNextPage"
           }
         },
         {
-          kind: graphql12.Kind.FIELD,
+          kind: graphql13.Kind.FIELD,
           name: {
-            kind: graphql12.Kind.NAME,
+            kind: graphql13.Kind.NAME,
             value: "startCursor"
           }
         },
         {
-          kind: graphql12.Kind.FIELD,
+          kind: graphql13.Kind.FIELD,
           name: {
-            kind: graphql12.Kind.NAME,
+            kind: graphql13.Kind.NAME,
             value: "endCursor"
           }
         }
@@ -72313,17 +72324,17 @@ async function addListFragments(config2, documents) {
   const lists = {};
   const errors = [];
   for (const doc of documents) {
-    doc.document = graphql13.visit(doc.document, {
+    doc.document = graphql14.visit(doc.document, {
       Directive(node, key, parent2, path3, ancestors) {
         if ([config2.listDirective, config2.paginateDirective].includes(node.name.value)) {
           const nameArg = node.arguments?.find(
             (arg) => arg.name.value === config2.listOrPaginateNameArg
           );
           let error = {
-            ...new graphql13.GraphQLError(
+            ...new graphql14.GraphQLError(
               "",
               node,
-              new graphql13.Source(""),
+              new graphql14.Source(""),
               node.loc ? [node.loc.start, node.loc.end] : null,
               path3
             ),
@@ -72375,7 +72386,7 @@ async function addListFragments(config2, documents) {
                 {
                   kind: "Argument",
                   name: {
-                    kind: graphql13.Kind.NAME,
+                    kind: graphql14.Kind.NAME,
                     value: "connection"
                   },
                   value: {
@@ -72425,7 +72436,7 @@ async function addListFragments(config2, documents) {
   const validDeletes = [
     ...new Set(
       Object.values(lists).map(({ type }) => {
-        if (!(type instanceof graphql13.GraphQLObjectType)) {
+        if (!(type instanceof graphql14.GraphQLObjectType)) {
           return "";
         }
         if (config2.keyFieldsForType(type.name).length !== 1) {
@@ -72439,7 +72450,7 @@ async function addListFragments(config2, documents) {
     return;
   }
   const generatedDoc = {
-    kind: graphql13.Kind.DOCUMENT,
+    kind: graphql14.Kind.DOCUMENT,
     definitions: Object.entries(lists).flatMap(
       ([name, { selection, type }]) => {
         const schemaType = config2.schema.getType(type.name);
@@ -72447,7 +72458,7 @@ async function addListFragments(config2, documents) {
           throw new HoudiniError({ message: "Lists must have a selection" });
         }
         const fragmentSelection = {
-          kind: graphql13.Kind.SELECTION_SET,
+          kind: graphql14.Kind.SELECTION_SET,
           selections: [...selection.selections]
         };
         if (schemaType && fragmentSelection && !fragmentSelection?.selections.find(
@@ -72462,14 +72473,14 @@ async function addListFragments(config2, documents) {
           {
             name: {
               value: config2.listInsertFragment(name),
-              kind: graphql13.Kind.NAME
+              kind: graphql14.Kind.NAME
             },
-            kind: graphql13.Kind.FRAGMENT_DEFINITION,
+            kind: graphql14.Kind.FRAGMENT_DEFINITION,
             selectionSet: fragmentSelection,
             typeCondition: {
-              kind: graphql13.Kind.NAMED_TYPE,
+              kind: graphql14.Kind.NAMED_TYPE,
               name: {
-                kind: graphql13.Kind.NAME,
+                kind: graphql14.Kind.NAME,
                 value: type.name
               }
             }
@@ -72477,32 +72488,32 @@ async function addListFragments(config2, documents) {
           {
             name: {
               value: config2.listToggleFragment(name),
-              kind: graphql13.Kind.NAME
+              kind: graphql14.Kind.NAME
             },
-            kind: graphql13.Kind.FRAGMENT_DEFINITION,
+            kind: graphql14.Kind.FRAGMENT_DEFINITION,
             selectionSet: fragmentSelection,
             typeCondition: {
-              kind: graphql13.Kind.NAMED_TYPE,
+              kind: graphql14.Kind.NAMED_TYPE,
               name: {
-                kind: graphql13.Kind.NAME,
+                kind: graphql14.Kind.NAME,
                 value: type.name
               }
             }
           },
           {
-            kind: graphql13.Kind.FRAGMENT_DEFINITION,
+            kind: graphql14.Kind.FRAGMENT_DEFINITION,
             name: {
               value: config2.listRemoveFragment(name),
-              kind: graphql13.Kind.NAME
+              kind: graphql14.Kind.NAME
             },
             selectionSet: {
-              kind: graphql13.Kind.SELECTION_SET,
+              kind: graphql14.Kind.SELECTION_SET,
               selections: [...objectIdentificationSelection(config2, type)]
             },
             typeCondition: {
-              kind: graphql13.Kind.NAMED_TYPE,
+              kind: graphql14.Kind.NAMED_TYPE,
               name: {
-                kind: graphql13.Kind.NAME,
+                kind: graphql14.Kind.NAME,
                 value: type.name
               }
             }
@@ -72511,14 +72522,14 @@ async function addListFragments(config2, documents) {
       }
     ).concat(
       ...validDeletes.map((typeName) => ({
-        kind: graphql13.Kind.DIRECTIVE_DEFINITION,
+        kind: graphql14.Kind.DIRECTIVE_DEFINITION,
         name: {
-          kind: graphql13.Kind.NAME,
+          kind: graphql14.Kind.NAME,
           value: config2.listDeleteDirective(typeName)
         },
         locations: [
           {
-            kind: graphql13.Kind.NAME,
+            kind: graphql14.Kind.NAME,
             value: "FIELD"
           }
         ],
@@ -72526,8 +72537,8 @@ async function addListFragments(config2, documents) {
       }))
     )
   };
-  config2.newSchema += "\n" + generatedDoc.definitions.filter((c) => c.kind !== "FragmentDefinition").map(graphql13.print).join("\n\n");
-  config2.newDocuments += "\n" + generatedDoc.definitions.filter((c) => c.kind === "FragmentDefinition").map(graphql13.print).join("\n\n");
+  config2.newSchema += "\n" + generatedDoc.definitions.filter((c) => c.kind !== "FragmentDefinition").map(graphql14.print).join("\n\n");
+  config2.newDocuments += "\n" + generatedDoc.definitions.filter((c) => c.kind === "FragmentDefinition").map(graphql14.print).join("\n\n");
   documents.push({
     name: "generated::lists",
     kind: ArtifactKind.Fragment,
@@ -72613,11 +72624,11 @@ var nodeNotDefinedMessage = (config2) => `Looks like you are trying to use the $
 For more information, visit this link: ${siteURL}/guides/pagination`;
 
 // src/codegen/generators/artifacts/fieldKey.ts
-var graphql14 = __toESM(require("graphql"), 1);
+var graphql15 = __toESM(require("graphql"), 1);
 function fieldKey(config2, field) {
   const attributeName = field.alias?.value || field.name.value;
-  const printed = graphql14.print(field);
-  const secondParse = graphql14.parse(`{${printed}}`).definitions[0].selectionSet.selections[0];
+  const printed = graphql15.print(field);
+  const secondParse = graphql15.parse(`{${printed}}`).definitions[0].selectionSet.selections[0];
   let paginateMode = config2.defaultPaginateMode;
   const paginatedDirective = field.directives?.find(
     (directive) => directive.name.value === config2.paginateDirective
@@ -72740,13 +72751,13 @@ function prepareSelection({
       } else if ("getFields" in type) {
         let typeRef = type.getFields()[field.name.value].type;
         fieldType = getRootType(typeRef);
-        nullable = !graphql15.isNonNullType(typeRef);
-      } else if (graphql15.isAbstractType(type)) {
+        nullable = !graphql16.isNonNullType(typeRef);
+      } else if (graphql16.isAbstractType(type)) {
         for (const possible of config2.schema.getPossibleTypes(type)) {
-          if (graphql15.isObjectType(possible)) {
+          if (graphql16.isObjectType(possible)) {
             if (possible.getFields()[field.name.value]) {
               fieldType = possible.getFields()[field.name.value].type;
-              nullable = !graphql15.isNonNullType(fieldType);
+              nullable = !graphql16.isNonNullType(fieldType);
               break;
             }
           }
@@ -72883,7 +72894,7 @@ function prepareSelection({
           kind: "value"
         } : { kind: "continue" };
         const parentType = config2.schema.getType(rootType);
-        if (graphql15.isObjectType(parentType) || graphql15.isInterfaceType(parentType)) {
+        if (graphql16.isObjectType(parentType) || graphql16.isInterfaceType(parentType)) {
           const fieldType2 = parentType.getFields()[field.name.value]?.type;
           if (fieldType2) {
             const listCount = unwrapType(config2, fieldType2).wrappers.filter(
@@ -72906,7 +72917,7 @@ function prepareSelection({
         }
         fieldObj.loading = loadingValue;
       }
-      if (graphql15.isInterfaceType(fieldType) || graphql15.isUnionType(fieldType)) {
+      if (graphql16.isInterfaceType(fieldType) || graphql16.isUnionType(fieldType)) {
         fieldObj.abstract = true;
         if (Object.values(fieldObj.selection?.abstractFields?.fields ?? {}).some(
           (fields) => Object.values(fields ?? {}).some((field2) => field2.required)
@@ -72988,7 +72999,7 @@ function mergeSelection({
         typeSelection,
         abstractSelection.fields[typeName] ?? {}
       );
-      if (graphql15.isAbstractType(gqlType)) {
+      if (graphql16.isAbstractType(gqlType)) {
         for (const possible of config2.schema.getPossibleTypes(gqlType)) {
           if (!possibleSelectionTypes[typeName]) {
             possibleSelectionTypes[typeName] = [];
@@ -73023,7 +73034,7 @@ function mergeSelection({
       }
     }
     const parentType = config2.schema.getType(rootType);
-    const possibleParents = graphql15.isAbstractType(parentType) ? config2.schema.getPossibleTypes(parentType)?.map((t3) => t3.name) : [parentType.name];
+    const possibleParents = graphql16.isAbstractType(parentType) ? config2.schema.getPossibleTypes(parentType)?.map((t3) => t3.name) : [parentType.name];
     for (const key of Object.keys(abstractSelection.typeMap)) {
       if (!possibleParents.includes(key) && rootType !== key || abstractSelection.fields[key]) {
         delete abstractSelection.typeMap[key];
@@ -73080,12 +73091,12 @@ function mergeSelection({
 }
 
 // src/codegen/generators/artifacts/index.ts
-var AST4 = recast4.types.builders;
+var AST5 = recast5.types.builders;
 function artifactGenerator(stats) {
   return async function(config2, docs) {
     const filterTypes = {};
     for (const doc of docs) {
-      graphql16.visit(doc.document, {
+      graphql17.visit(doc.document, {
         Directive(node, _, __, ___, ancestors) {
           if (node.name.value !== config2.listDirective) {
             return;
@@ -73145,7 +73156,7 @@ function artifactGenerator(stats) {
             return;
           }
           const usedVariableNames = /* @__PURE__ */ new Set();
-          let documentWithoutInternalDirectives = graphql16.visit(document, {
+          let documentWithoutInternalDirectives = graphql17.visit(document, {
             Directive(node) {
               if (config2.isInternalDirective(node.name.value)) {
                 return null;
@@ -73158,7 +73169,7 @@ function artifactGenerator(stats) {
               }
             }
           });
-          let documentWithoutExtraVariables = graphql16.visit(
+          let documentWithoutExtraVariables = graphql17.visit(
             documentWithoutInternalDirectives,
             {
               VariableDefinition(variableDefinitionNode) {
@@ -73169,13 +73180,13 @@ function artifactGenerator(stats) {
               }
             }
           );
-          let rawString = graphql16.print(documentWithoutExtraVariables);
+          let rawString = graphql17.print(documentWithoutExtraVariables);
           let docKind = doc.kind;
           const operations = document.definitions.filter(
-            ({ kind }) => kind === graphql16.Kind.OPERATION_DEFINITION
+            ({ kind }) => kind === graphql17.Kind.OPERATION_DEFINITION
           );
           const fragments = document.definitions.filter(
-            ({ kind }) => kind === graphql16.Kind.FRAGMENT_DEFINITION
+            ({ kind }) => kind === graphql17.Kind.FRAGMENT_DEFINITION
           );
           let rootType = "";
           let selectionSet;
@@ -73375,9 +73386,9 @@ function artifactGenerator(stats) {
             plugin2.artifactEnd({ config: config2, document: doc });
           }
           const _houdiniHash = hashOriginal({ document: doc });
-          const file = AST4.program([
+          const file = AST5.program([
             moduleExport(config2, "default", serializeValue(artifact)),
-            AST4.expressionStatement(AST4.stringLiteral(`HoudiniHash=${_houdiniHash}`))
+            AST5.expressionStatement(AST5.stringLiteral(`HoudiniHash=${_houdiniHash}`))
           ]);
           const artifactPath = config2.artifactPath(document);
           const countDocument = doc.generateStore;
@@ -73435,7 +73446,7 @@ function applyMask(config2, target, mask) {
     if (!targetType) {
       continue;
     }
-    if (graphql16.isAbstractType(targetType)) {
+    if (graphql17.isAbstractType(targetType)) {
       for (const possible of config2.schema.getPossibleTypes(targetType)) {
         if (target.abstractFields?.fields[possible.name]) {
           applyMask(
@@ -73458,8 +73469,8 @@ function applyMask(config2, target, mask) {
 }
 
 // src/codegen/generators/runtime/graphqlFunction.ts
-var recast5 = __toESM(require_main2(), 1);
-var AST5 = recast5.types.builders;
+var recast6 = __toESM(require_main2(), 1);
+var AST6 = recast6.types.builders;
 async function generateGraphqlReturnTypes(config2, docs) {
   const indexPath = path_exports.join(config2.runtimeDirectory, "index.d.ts");
   const fileContent = await fs_exports.readFile(indexPath) || "";
@@ -73494,18 +73505,18 @@ async function generateGraphqlReturnTypes(config2, docs) {
         continue;
       }
       for (const [queryString, returnValue] of Object.entries(overloaded_returns)) {
-        const input = AST5.identifier("str");
-        input.typeAnnotation = AST5.tsTypeAnnotation(
-          AST5.tsLiteralType(AST5.stringLiteral(queryString))
+        const input = AST6.identifier("str");
+        input.typeAnnotation = AST6.tsTypeAnnotation(
+          AST6.tsLiteralType(AST6.stringLiteral(queryString))
         );
         script.body.splice(
           i2,
           0,
-          AST5.exportNamedDeclaration(
-            AST5.tsDeclareFunction(
-              AST5.identifier("graphql"),
+          AST6.exportNamedDeclaration(
+            AST6.tsDeclareFunction(
+              AST6.identifier("graphql"),
               [input],
-              AST5.tsTypeAnnotation(AST5.tsTypeReference(AST5.identifier(returnValue)))
+              AST6.tsTypeAnnotation(AST6.tsTypeReference(AST6.identifier(returnValue)))
             )
           )
         );
@@ -73680,165 +73691,22 @@ function moduleStatments(config2) {
 var recast11 = __toESM(require_main2(), 1);
 
 // src/codegen/generators/typescript/addReferencedInputTypes.ts
-var graphql19 = __toESM(require("graphql"), 1);
-var recast8 = __toESM(require_main2(), 1);
-
-// src/codegen/generators/typescript/typeReference.ts
 var graphql18 = __toESM(require("graphql"), 1);
 var recast7 = __toESM(require_main2(), 1);
-
-// src/codegen/generators/typescript/types.ts
-var graphql17 = __toESM(require("graphql"), 1);
-var recast6 = __toESM(require_main2(), 1);
-var AST6 = recast6.types.builders;
-function readonlyProperty(prop, enable = true) {
-  if (enable) {
-    prop.readonly = true;
-  }
-  return prop;
-}
-function nullableField(inner, input = false) {
-  const members = [inner, AST6.tsNullKeyword()];
-  if (input) {
-    members.push(AST6.tsUndefinedKeyword());
-  }
-  return AST6.tsUnionType(members);
-}
-function scalarPropertyValue(config2, filepath, missingScalars, target, body, field) {
-  if (config2.configFile.features?.componentFields && target.name === config2.componentScalar) {
-    if (!field) {
-      return AST6.tsNeverKeyword();
-    }
-    const component = config2.componentFields[field.parent][field.field];
-    const sourcePathRelative = path_exports.relative(
-      path_exports.join(config2.projectRoot, "src"),
-      component.filepath
-    );
-    let sourcePathParsed = path_exports.parse(sourcePathRelative);
-    let sourcePath = path_exports.join(sourcePathParsed.dir, sourcePathParsed.name);
-    const localImport = ensureImports({
-      config: config2,
-      body,
-      import: "__component__" + component.fragment,
-      sourceModule: path_exports.join(
-        path_exports.relative(path_exports.dirname(filepath), config2.projectRoot),
-        "src",
-        sourcePath
-      )
-    });
-    const parameters = AST6.tsTypeReference(AST6.identifier("Parameters"));
-    parameters.typeParameters = AST6.tsTypeParameterInstantiation([
-      AST6.tsTypeQuery(AST6.identifier(localImport))
-    ]);
-    const indexed = AST6.tsIndexedAccessType(
-      parameters,
-      AST6.tsLiteralType(AST6.numericLiteral(0))
-    );
-    const omit = AST6.tsTypeReference(AST6.identifier("Omit"));
-    omit.typeParameters = AST6.tsTypeParameterInstantiation([
-      indexed,
-      AST6.tsLiteralType(AST6.stringLiteral(component.prop))
-    ]);
-    const arg = AST6.identifier("props");
-    arg.typeAnnotation = AST6.tsTypeAnnotation(omit);
-    const returnType = AST6.tsTypeReference(AST6.identifier("ReturnType"));
-    returnType.typeParameters = AST6.tsTypeParameterInstantiation([
-      AST6.tsTypeQuery(AST6.identifier(localImport))
-    ]);
-    const fnType = AST6.tsFunctionType([arg]);
-    fnType.typeAnnotation = AST6.tsTypeAnnotation(returnType);
-    return fnType;
-  }
-  switch (target.name) {
-    case "String": {
-      return AST6.tsStringKeyword();
-    }
-    case "Int": {
-      return AST6.tsNumberKeyword();
-    }
-    case "Float": {
-      return AST6.tsNumberKeyword();
-    }
-    case "Boolean": {
-      return AST6.tsBooleanKeyword();
-    }
-    case "ID": {
-      return AST6.tsStringKeyword();
-    }
-    default: {
-      if (graphql17.isNonNullType(target) && "ofType" in target) {
-        return scalarPropertyValue(
-          config2,
-          filepath,
-          missingScalars,
-          target.ofType,
-          body,
-          field
-        );
-      }
-      if (config2.scalars?.[target.name]) {
-        return AST6.tsTypeReference(AST6.identifier(config2.scalars?.[target.name].type));
-      }
-      if (target.name !== config2.componentScalar) {
-        missingScalars.add(target.name);
-      }
-      return AST6.tsAnyKeyword();
-    }
-  }
-}
-
-// src/codegen/generators/typescript/typeReference.ts
 var AST7 = recast7.types.builders;
-function tsTypeReference(config2, filepath, missingScalars, definition, body) {
-  const { type, wrappers } = unwrapType(config2, definition.type);
-  let result;
-  if (graphql18.isScalarType(type)) {
-    result = scalarPropertyValue(config2, filepath, missingScalars, type, body, null);
-  } else if (graphql18.isEnumType(type)) {
-    result = enumReference(config2, body, type.name);
-  } else {
-    result = AST7.tsTypeReference(AST7.identifier(type.name));
-  }
-  for (const toWrap of wrappers) {
-    if (toWrap === "NonNull" /* NonNull */) {
-      continue;
-    } else if (toWrap === "Nullable" /* Nullable */) {
-      result = nullableField(result, true);
-    } else if (toWrap === "List" /* List */) {
-      result = AST7.tsArrayType(AST7.tsParenthesizedType(result));
-    }
-  }
-  return result;
-}
-function enumReference(config2, body, name) {
-  ensureImports({
-    config: config2,
-    body,
-    import: ["ValueOf"],
-    importKind: "type",
-    sourceModule: "$houdini/runtime/lib/types"
-  });
-  return AST7.tsTypeReference(
-    AST7.identifier("ValueOf"),
-    AST7.tsTypeParameterInstantiation([AST7.tsTypeQuery(AST7.identifier(name))])
-  );
-}
-
-// src/codegen/generators/typescript/addReferencedInputTypes.ts
-var AST8 = recast8.types.builders;
 function addReferencedInputTypes(config2, filepath, body, visitedTypes, missingScalars, rootType) {
   const { type } = unwrapType(config2, rootType);
-  if (graphql19.isScalarType(type)) {
+  if (graphql18.isScalarType(type)) {
     return;
   }
   if (visitedTypes.has(type.name)) {
     return;
   }
-  if (graphql19.isUnionType(type)) {
+  if (graphql18.isUnionType(type)) {
     throw new HoudiniError({ filepath, message: "Input Unions are not supported yet. Sorry!" });
   }
   visitedTypes.add(type.name);
-  if (graphql19.isEnumType(type)) {
+  if (graphql18.isEnumType(type)) {
     ensureImports({
       config: config2,
       body,
@@ -73852,21 +73720,37 @@ function addReferencedInputTypes(config2, filepath, body, visitedTypes, missingS
   for (const field of Object.values(type.getFields())) {
     addReferencedInputTypes(config2, filepath, body, visitedTypes, missingScalars, field.type);
     members.push(
-      AST8.tsPropertySignature(
-        AST8.identifier(field.name),
-        AST8.tsTypeAnnotation(
+      AST7.tsPropertySignature(
+        AST7.identifier(field.name),
+        AST7.tsTypeAnnotation(
           tsTypeReference(config2, filepath, missingScalars, field, body)
         ),
-        graphql19.isNullableType(field.type)
+        graphql18.isNullableType(field.type)
       )
     );
   }
-  body.push(AST8.tsTypeAliasDeclaration(AST8.identifier(type.name), AST8.tsTypeLiteral(members)));
+  body.push(AST7.tsTypeAliasDeclaration(AST7.identifier(type.name), AST7.tsTypeLiteral(members)));
 }
 
 // src/codegen/generators/typescript/inlineType.ts
-var graphql20 = __toESM(require("graphql"), 1);
+var graphql19 = __toESM(require("graphql"), 1);
 var recast9 = __toESM(require_main2(), 1);
+
+// src/codegen/generators/comments/jsdoc.ts
+var recast8 = __toESM(require_main2(), 1);
+var AST8 = recast8.types.builders;
+function jsdocComment(text, deprecated) {
+  let commentContent = `*
+ * ${text}
+`;
+  if (deprecated) {
+    commentContent = `${commentContent} * @deprecated ${deprecated}
+`;
+  }
+  return AST8.commentBlock(commentContent, true);
+}
+
+// src/codegen/generators/typescript/inlineType.ts
 var AST9 = recast9.types.builders;
 var fragmentKey2 = " $fragments";
 function inlineType({
@@ -73887,7 +73771,7 @@ function inlineType({
   const { type, wrappers } = unwrapType(config2, rootType);
   let result;
   let forceNullable = false;
-  if (graphql20.isScalarType(type)) {
+  if (graphql19.isScalarType(type)) {
     result = scalarPropertyValue(
       config2,
       filepath,
@@ -73896,7 +73780,7 @@ function inlineType({
       body,
       field
     );
-  } else if (graphql20.isEnumType(type)) {
+  } else if (graphql19.isEnumType(type)) {
     ensureImports({
       config: config2,
       body,
@@ -73921,11 +73805,11 @@ function inlineType({
     for (const selection of selections) {
       if (selection.kind === "InlineFragment" && selection.typeCondition) {
         const fragmentType = config2.schema.getType(selection.typeCondition.name.value);
-        if (!graphql20.isInterfaceType(type) && !graphql20.isUnionType(type)) {
+        if (!graphql19.isInterfaceType(type) && !graphql19.isUnionType(type)) {
           selectedFields.push(...selection.selectionSet.selections);
           continue;
         }
-        if (!graphql20.isInterfaceType(fragmentType) && !graphql20.isUnionType(fragmentType)) {
+        if (!graphql19.isInterfaceType(fragmentType) && !graphql19.isUnionType(fragmentType)) {
           if (!inlineFragments[fragmentType.name]) {
             inlineFragments[fragmentType.name] = [];
           }
@@ -74017,6 +73901,11 @@ function inlineType({
         if (allOptional) {
           prop.optional = true;
         }
+        if (field2.description || field2.deprecationReason) {
+          prop.comments = [
+            jsdocComment(field2.description ?? "", field2.deprecationReason ?? void 0)
+          ];
+        }
         return prop;
       })
     ]);
@@ -74068,7 +73957,7 @@ function inlineType({
           }
         }
       }
-      if (objectType.type === "TSTypeLiteral" && !graphql20.isInterfaceType(fragmentRootType) && !graphql20.isUnionType(fragmentRootType)) {
+      if (objectType.type === "TSTypeLiteral" && !graphql19.isInterfaceType(fragmentRootType) && !graphql19.isUnionType(fragmentRootType)) {
         const existingTypenameIndex = objectType.members.findIndex(
           (member) => member.type === "TSPropertySignature" && member.key.type === "Identifier" && member.key.name === "__typename"
         );
@@ -74093,11 +73982,11 @@ function inlineType({
         ];
       }
       let coveredTypenames;
-      if (graphql20.isInterfaceType(fragmentRootType)) {
+      if (graphql19.isInterfaceType(fragmentRootType)) {
         coveredTypenames = interfaceCoveredTypenames(fragmentRootType);
-      } else if (graphql20.isUnionType(fragmentRootType)) {
+      } else if (graphql19.isUnionType(fragmentRootType)) {
         coveredTypenames = fragmentRootType.getTypes().map((type2) => type2.name);
-      } else if (graphql20.isObjectType(fragmentRootType)) {
+      } else if (graphql19.isObjectType(fragmentRootType)) {
         coveredTypenames = [fragmentRootType.name];
       } else {
         throw Error("unreachable code");
@@ -74133,7 +74022,7 @@ function inlineType({
           );
         }
       );
-      const parentIsUnionOrInterface = !graphql20.isInterfaceType(type) && !graphql20.isUnionType(type);
+      const parentIsUnionOrInterface = !graphql19.isInterfaceType(type) && !graphql19.isUnionType(type);
       const possibleTypenames = parentIsUnionOrInterface ? [parent.name] : config2.schema.getPossibleTypes(type).map((type2) => type2.name);
       const coveredTypenames = new Set(
         Object.values(inlineFragmentSelections).flatMap((sel) => sel.coveredTypenames)
@@ -74200,7 +74089,7 @@ function selectionTypeInfo(schema, filepath, rootType, selection) {
       },
       type: schema.getType("String")
     };
-  } else if (graphql20.isNonNullType(rootType) && "getFields" in rootType.ofType) {
+  } else if (graphql19.isNonNullType(rootType) && "getFields" in rootType.ofType) {
     fields = rootType.ofType.getFields();
   } else {
     fields = rootType.getFields();
@@ -74212,7 +74101,7 @@ function selectionTypeInfo(schema, filepath, rootType, selection) {
       message: `Could not find type information for field ${rootType.toString()}.${selectionName} ${field}`
     });
   }
-  const fieldType = graphql20.getNamedType(field.type);
+  const fieldType = graphql19.getNamedType(field.type);
   if (!fieldType) {
     throw new HoudiniError({
       filepath,
@@ -74720,7 +74609,7 @@ async function generateFragmentTypeDefs(config2, filepath, body, selections, def
 }
 
 // src/codegen/generators/typescript/imperativeTypeDef.ts
-var graphql21 = __toESM(require("graphql"), 1);
+var graphql20 = __toESM(require("graphql"), 1);
 var recast12 = __toESM(require_main2(), 1);
 var AST12 = recast12.types.builders;
 async function imperativeCacheTypef(config2, docs) {
@@ -74772,7 +74661,7 @@ function typeDefinitions(config2, filepath, body, docs, returnType) {
   const operationTypes = [config2.schema.getMutationType(), config2.schema.getSubscriptionType()].filter(Boolean).map((type) => type?.name);
   const visitedTypes = /* @__PURE__ */ new Set();
   const types17 = Object.values(config2.schema.getTypeMap()).filter(
-    (type) => !graphql21.isAbstractType(type) && !graphql21.isScalarType(type) && !graphql21.isEnumType(type) && !graphql21.isInputObjectType(type) && !type.name.startsWith("__") && !operationTypes.includes(type.name)
+    (type) => !graphql20.isAbstractType(type) && !graphql20.isScalarType(type) && !graphql20.isEnumType(type) && !graphql20.isInputObjectType(type) && !type.name.startsWith("__") && !operationTypes.includes(type.name)
   );
   const fragmentMap = fragmentListMap(
     config2,
@@ -74789,7 +74678,7 @@ function typeDefinitions(config2, filepath, body, docs, returnType) {
       }
       let idFields = AST12.tsNeverKeyword();
       const keys2 = keyFieldsForType(config2.configFile, type.name);
-      if (graphql21.isObjectType(type) && keys2.length > 0 && keys2.every((key) => type.getFields()[key])) {
+      if (graphql20.isObjectType(type) && keys2.length > 0 && keys2.every((key) => type.getFields()[key])) {
         idFields = AST12.tsTypeLiteral(
           keys2.map((key) => {
             const fieldType = type.getFields()[key];
@@ -74816,13 +74705,13 @@ function typeDefinitions(config2, filepath, body, docs, returnType) {
         idFields = AST12.tsTypeLiteral([]);
       }
       let fields = AST12.tsTypeLiteral([]);
-      if (graphql21.isObjectType(type)) {
+      if (graphql20.isObjectType(type)) {
         fields = AST12.tsTypeLiteral(
           Object.entries(type.getFields()).map(
             ([key, fieldType]) => {
               const unwrapped = unwrapType(config2, fieldType.type);
               let typeOptions = AST12.tsUnionType([]);
-              if (graphql21.isScalarType(unwrapped.type)) {
+              if (graphql20.isScalarType(unwrapped.type)) {
                 typeOptions.types.push(
                   scalarPropertyValue(
                     config2,
@@ -74836,11 +74725,11 @@ function typeDefinitions(config2, filepath, body, docs, returnType) {
                     }
                   )
                 );
-              } else if (graphql21.isEnumType(unwrapped.type)) {
+              } else if (graphql20.isEnumType(unwrapped.type)) {
                 typeOptions.types.push(
                   AST12.tsTypeReference(AST12.identifier(unwrapped.type.name))
                 );
-              } else if (!graphql21.isAbstractType(unwrapped.type)) {
+              } else if (!graphql20.isAbstractType(unwrapped.type)) {
                 typeOptions.types.push(record(unwrapped.type.name));
               } else {
                 typeOptions.types.push(
@@ -74936,7 +74825,7 @@ function listDefinitions(config2, filepath, body, docs) {
   const lists = [];
   const visitedLists = /* @__PURE__ */ new Set();
   for (const doc of docs) {
-    graphql21.visit(doc.document, {
+    graphql20.visit(doc.document, {
       Directive(node, key, parent2, path3, ancestors) {
         if (![config2.listDirective, config2.paginateDirective].includes(node.name.value)) {
           return;
@@ -74958,7 +74847,7 @@ function listDefinitions(config2, filepath, body, docs) {
         const targetFieldDefinition = parentType.getFields()[targetField.name.value];
         const { type: listType } = unwrapType(config2, targetFieldDefinition.type);
         const possibleTypes = [];
-        if (graphql21.isAbstractType(listType)) {
+        if (graphql20.isAbstractType(listType)) {
           possibleTypes.push(
             ...config2.schema.getPossibleTypes(listType).map((possible) => possible.name)
           );
@@ -75120,7 +75009,7 @@ async function typescriptGenerator(config2, docs) {
 }
 
 // src/codegen/generators/persistedQueries/index.ts
-var graphql22 = __toESM(require("graphql"), 1);
+var graphql21 = __toESM(require("graphql"), 1);
 async function persistOutputGenerator(config2, docs) {
   if (!config2.persistedQueriesPath.endsWith(".json")) {
     throw new Error('Can write Persisted Queries only in a ".json" file.');
@@ -75130,8 +75019,8 @@ async function persistOutputGenerator(config2, docs) {
     if (!generateArtifact) {
       return acc;
     }
-    let rawString = graphql22.print(
-      graphql22.visit(document, {
+    let rawString = graphql21.print(
+      graphql21.visit(document, {
         Directive(node) {
           if (config2.isInternalDirective(node.name.value)) {
             return null;
@@ -75140,7 +75029,7 @@ async function persistOutputGenerator(config2, docs) {
       })
     );
     const operations = document.definitions.filter(
-      ({ kind }) => kind === graphql22.Kind.OPERATION_DEFINITION
+      ({ kind }) => kind === graphql21.Kind.OPERATION_DEFINITION
     );
     if (operations.length > 0 && operations[0].kind === "OperationDefinition") {
       if (artifact) {
@@ -75155,33 +75044,45 @@ async function persistOutputGenerator(config2, docs) {
 }
 
 // src/codegen/generators/definitions/index.ts
-var graphql24 = __toESM(require("graphql"), 1);
+var graphql23 = __toESM(require("graphql"), 1);
 
 // src/codegen/generators/definitions/enums.ts
-var graphql23 = __toESM(require("graphql"), 1);
+var graphql22 = __toESM(require("graphql"), 1);
 var recast13 = __toESM(require_main2(), 1);
 var AST13 = recast13.types.builders;
 async function definitionsGenerator(config2) {
-  const enums = graphql23.parse(graphql23.printSchema(config2.schema)).definitions.filter(
+  const enums = graphql22.parse(graphql22.printSchema(config2.schema)).definitions.filter(
     (definition) => definition.kind === "EnumTypeDefinition"
   ).filter((def) => !config2.isInternalEnum(def));
   const { code: runtimeDefinitions } = await printJS(
     AST13.program(
       enums.map((defn) => {
         const name = defn.name.value;
-        return moduleExport(
+        const declaration = moduleExport(
           config2,
           name,
           AST13.objectExpression(
             defn.values?.map((value) => {
               const str = value.name.value;
-              return AST13.objectProperty(
+              const prop = AST13.objectProperty(
                 AST13.stringLiteral(str),
                 AST13.stringLiteral(str)
               );
+              const deprecationReason = value.directives?.find((d) => d.name.value === "deprecated")?.arguments?.find((a) => a.name.value === "reason")?.value?.value;
+              if (value.description || deprecationReason)
+                prop.comments = [
+                  jsdocComment(value.description?.value ?? "", deprecationReason)
+                ];
+              return prop;
             }) || []
           )
         );
+        if (defn.description) {
+          declaration.comments = [
+            AST13.commentBlock(`* ${defn.description.value} `, true, false)
+          ];
+        }
+        return declaration;
       })
     )
   );
@@ -75190,11 +75091,19 @@ type ValuesOf<T> = T[keyof T]
 	` + enums.sort((a, b) => a.name.value.localeCompare(b.name.value)).map((definition) => {
     const name = definition.name.value;
     const values = definition.values;
-    return `
+    let jsdoc = "";
+    if (definition.description) {
+      jsdoc = `
+/** ${definition.description.value} */`;
+    }
+    return `${jsdoc}
 export declare const ${name}: {
-${values?.map((value) => `    readonly ${value.name.value}: "${value.name.value}";`).join("\n")}
+${values?.map(
+      (value) => (value.description ? `    /** ${value.description.value} */
+` : "") + `    readonly ${value.name.value}: "${value.name.value}";`
+    ).join("\n")}
 }
-
+${jsdoc}
 export type ${name}$options = ValuesOf<typeof ${name}>
  `;
   }).join("");
@@ -75214,7 +75123,7 @@ async function schemaGenerator(config2) {
   await Promise.all([
     fs_exports.writeFile(
       config2.definitionsSchemaPath,
-      config2.localSchema ? graphql24.printSchema(config2.schema) : config2.newSchema
+      config2.localSchema ? graphql23.printSchema(config2.schema) : config2.newSchema
     ),
     fs_exports.writeFile(config2.definitionsDocumentsPath, config2.newDocuments),
     definitionsGenerator(config2)
@@ -75259,7 +75168,7 @@ async function writeIndexFile2(config2, docs) {
 }
 
 // ../../node_modules/.pnpm/@graphql-tools+utils@10.0.6_graphql@15.5.0/node_modules/@graphql-tools/utils/esm/helpers.js
-var import_graphql32 = require("graphql");
+var import_graphql33 = require("graphql");
 function compareStrings2(a, b) {
   if (String(a) < String(b)) {
     return -1;
@@ -75295,7 +75204,7 @@ function isSome2(input) {
 }
 
 // ../../node_modules/.pnpm/@graphql-tools+utils@10.0.6_graphql@15.5.0/node_modules/@graphql-tools/utils/esm/inspect.js
-var import_graphql33 = require("graphql");
+var import_graphql34 = require("graphql");
 var MAX_RECURSIVE_DEPTH2 = 3;
 function inspect2(value) {
   return formatValue2(value, []);
@@ -75313,7 +75222,7 @@ function formatValue2(value, seenValues) {
   }
 }
 function formatError2(value) {
-  if (value instanceof import_graphql33.GraphQLError) {
+  if (value instanceof import_graphql34.GraphQLError) {
     return value.toString();
   }
   return `${value.name}: ${value.message};
@@ -75396,43 +75305,43 @@ function getDirectivesInExtensions2(node, pathToDirectivesInExtensions = ["direc
 }
 
 // ../../node_modules/.pnpm/@graphql-tools+utils@10.0.6_graphql@15.5.0/node_modules/@graphql-tools/utils/esm/print-schema-with-directives.js
-var import_graphql37 = require("graphql");
+var import_graphql38 = require("graphql");
 
 // ../../node_modules/.pnpm/@graphql-tools+utils@10.0.6_graphql@15.5.0/node_modules/@graphql-tools/utils/esm/astFromType.js
-var import_graphql34 = require("graphql");
+var import_graphql35 = require("graphql");
 function astFromType2(type) {
-  if ((0, import_graphql34.isNonNullType)(type)) {
+  if ((0, import_graphql35.isNonNullType)(type)) {
     const innerType = astFromType2(type.ofType);
-    if (innerType.kind === import_graphql34.Kind.NON_NULL_TYPE) {
+    if (innerType.kind === import_graphql35.Kind.NON_NULL_TYPE) {
       throw new Error(`Invalid type node ${inspect2(type)}. Inner type of non-null type cannot be a non-null type.`);
     }
     return {
-      kind: import_graphql34.Kind.NON_NULL_TYPE,
+      kind: import_graphql35.Kind.NON_NULL_TYPE,
       type: innerType
     };
-  } else if ((0, import_graphql34.isListType)(type)) {
+  } else if ((0, import_graphql35.isListType)(type)) {
     return {
-      kind: import_graphql34.Kind.LIST_TYPE,
+      kind: import_graphql35.Kind.LIST_TYPE,
       type: astFromType2(type.ofType)
     };
   }
   return {
-    kind: import_graphql34.Kind.NAMED_TYPE,
+    kind: import_graphql35.Kind.NAMED_TYPE,
     name: {
-      kind: import_graphql34.Kind.NAME,
+      kind: import_graphql35.Kind.NAME,
       value: type.name
     }
   };
 }
 
 // ../../node_modules/.pnpm/@graphql-tools+utils@10.0.6_graphql@15.5.0/node_modules/@graphql-tools/utils/esm/astFromValue.js
-var import_graphql36 = require("graphql");
+var import_graphql37 = require("graphql");
 
 // ../../node_modules/.pnpm/@graphql-tools+utils@10.0.6_graphql@15.5.0/node_modules/@graphql-tools/utils/esm/astFromValueUntyped.js
-var import_graphql35 = require("graphql");
+var import_graphql36 = require("graphql");
 function astFromValueUntyped2(value) {
   if (value === null) {
-    return { kind: import_graphql35.Kind.NULL };
+    return { kind: import_graphql36.Kind.NULL };
   }
   if (value === void 0) {
     return null;
@@ -75445,7 +75354,7 @@ function astFromValueUntyped2(value) {
         valuesNodes.push(itemNode);
       }
     }
-    return { kind: import_graphql35.Kind.LIST, values: valuesNodes };
+    return { kind: import_graphql36.Kind.LIST, values: valuesNodes };
   }
   if (typeof value === "object") {
     const fieldNodes = [];
@@ -75454,26 +75363,26 @@ function astFromValueUntyped2(value) {
       const ast = astFromValueUntyped2(fieldValue);
       if (ast) {
         fieldNodes.push({
-          kind: import_graphql35.Kind.OBJECT_FIELD,
-          name: { kind: import_graphql35.Kind.NAME, value: fieldName },
+          kind: import_graphql36.Kind.OBJECT_FIELD,
+          name: { kind: import_graphql36.Kind.NAME, value: fieldName },
           value: ast
         });
       }
     }
-    return { kind: import_graphql35.Kind.OBJECT, fields: fieldNodes };
+    return { kind: import_graphql36.Kind.OBJECT, fields: fieldNodes };
   }
   if (typeof value === "boolean") {
-    return { kind: import_graphql35.Kind.BOOLEAN, value };
+    return { kind: import_graphql36.Kind.BOOLEAN, value };
   }
   if (typeof value === "bigint") {
-    return { kind: import_graphql35.Kind.INT, value: String(value) };
+    return { kind: import_graphql36.Kind.INT, value: String(value) };
   }
   if (typeof value === "number" && isFinite(value)) {
     const stringNum = String(value);
-    return integerStringRegExp2.test(stringNum) ? { kind: import_graphql35.Kind.INT, value: stringNum } : { kind: import_graphql35.Kind.FLOAT, value: stringNum };
+    return integerStringRegExp2.test(stringNum) ? { kind: import_graphql36.Kind.INT, value: stringNum } : { kind: import_graphql36.Kind.FLOAT, value: stringNum };
   }
   if (typeof value === "string") {
-    return { kind: import_graphql35.Kind.STRING, value };
+    return { kind: import_graphql36.Kind.STRING, value };
   }
   throw new TypeError(`Cannot convert value to AST: ${value}.`);
 }
@@ -75481,20 +75390,20 @@ var integerStringRegExp2 = /^-?(?:0|[1-9][0-9]*)$/;
 
 // ../../node_modules/.pnpm/@graphql-tools+utils@10.0.6_graphql@15.5.0/node_modules/@graphql-tools/utils/esm/astFromValue.js
 function astFromValue2(value, type) {
-  if ((0, import_graphql36.isNonNullType)(type)) {
+  if ((0, import_graphql37.isNonNullType)(type)) {
     const astValue = astFromValue2(value, type.ofType);
-    if (astValue?.kind === import_graphql36.Kind.NULL) {
+    if (astValue?.kind === import_graphql37.Kind.NULL) {
       return null;
     }
     return astValue;
   }
   if (value === null) {
-    return { kind: import_graphql36.Kind.NULL };
+    return { kind: import_graphql37.Kind.NULL };
   }
   if (value === void 0) {
     return null;
   }
-  if ((0, import_graphql36.isListType)(type)) {
+  if ((0, import_graphql37.isListType)(type)) {
     const itemType = type.ofType;
     if (isIterableObject(value)) {
       const valuesNodes = [];
@@ -75504,11 +75413,11 @@ function astFromValue2(value, type) {
           valuesNodes.push(itemNode);
         }
       }
-      return { kind: import_graphql36.Kind.LIST, values: valuesNodes };
+      return { kind: import_graphql37.Kind.LIST, values: valuesNodes };
     }
     return astFromValue2(value, itemType);
   }
-  if ((0, import_graphql36.isInputObjectType)(type)) {
+  if ((0, import_graphql37.isInputObjectType)(type)) {
     if (!isObjectLike(value)) {
       return null;
     }
@@ -75517,24 +75426,24 @@ function astFromValue2(value, type) {
       const fieldValue = astFromValue2(value[field.name], field.type);
       if (fieldValue) {
         fieldNodes.push({
-          kind: import_graphql36.Kind.OBJECT_FIELD,
-          name: { kind: import_graphql36.Kind.NAME, value: field.name },
+          kind: import_graphql37.Kind.OBJECT_FIELD,
+          name: { kind: import_graphql37.Kind.NAME, value: field.name },
           value: fieldValue
         });
       }
     }
-    return { kind: import_graphql36.Kind.OBJECT, fields: fieldNodes };
+    return { kind: import_graphql37.Kind.OBJECT, fields: fieldNodes };
   }
-  if ((0, import_graphql36.isLeafType)(type)) {
+  if ((0, import_graphql37.isLeafType)(type)) {
     const serialized = type.serialize(value);
     if (serialized == null) {
       return null;
     }
-    if ((0, import_graphql36.isEnumType)(type)) {
-      return { kind: import_graphql36.Kind.ENUM, value: serialized };
+    if ((0, import_graphql37.isEnumType)(type)) {
+      return { kind: import_graphql37.Kind.ENUM, value: serialized };
     }
     if (type.name === "ID" && typeof serialized === "string" && integerStringRegExp3.test(serialized)) {
-      return { kind: import_graphql36.Kind.INT, value: serialized };
+      return { kind: import_graphql37.Kind.INT, value: serialized };
     }
     return astFromValueUntyped2(serialized);
   }
@@ -75590,36 +75499,36 @@ function getDocumentNodeFromSchema2(schema, options = {}) {
   const definitions = schemaNode != null ? [schemaNode] : [];
   const directives = schema.getDirectives();
   for (const directive of directives) {
-    if ((0, import_graphql37.isSpecifiedDirective)(directive)) {
+    if ((0, import_graphql38.isSpecifiedDirective)(directive)) {
       continue;
     }
     definitions.push(astFromDirective2(directive, schema, pathToDirectivesInExtensions));
   }
   for (const typeName in typesMap) {
     const type = typesMap[typeName];
-    const isPredefinedScalar = (0, import_graphql37.isSpecifiedScalarType)(type);
-    const isIntrospection = (0, import_graphql37.isIntrospectionType)(type);
+    const isPredefinedScalar = (0, import_graphql38.isSpecifiedScalarType)(type);
+    const isIntrospection = (0, import_graphql38.isIntrospectionType)(type);
     if (isPredefinedScalar || isIntrospection) {
       continue;
     }
-    if ((0, import_graphql37.isObjectType)(type)) {
+    if ((0, import_graphql38.isObjectType)(type)) {
       definitions.push(astFromObjectType2(type, schema, pathToDirectivesInExtensions));
-    } else if ((0, import_graphql37.isInterfaceType)(type)) {
+    } else if ((0, import_graphql38.isInterfaceType)(type)) {
       definitions.push(astFromInterfaceType2(type, schema, pathToDirectivesInExtensions));
-    } else if ((0, import_graphql37.isUnionType)(type)) {
+    } else if ((0, import_graphql38.isUnionType)(type)) {
       definitions.push(astFromUnionType2(type, schema, pathToDirectivesInExtensions));
-    } else if ((0, import_graphql37.isInputObjectType)(type)) {
+    } else if ((0, import_graphql38.isInputObjectType)(type)) {
       definitions.push(astFromInputObjectType2(type, schema, pathToDirectivesInExtensions));
-    } else if ((0, import_graphql37.isEnumType)(type)) {
+    } else if ((0, import_graphql38.isEnumType)(type)) {
       definitions.push(astFromEnumType2(type, schema, pathToDirectivesInExtensions));
-    } else if ((0, import_graphql37.isScalarType)(type)) {
+    } else if ((0, import_graphql38.isScalarType)(type)) {
       definitions.push(astFromScalarType2(type, schema, pathToDirectivesInExtensions));
     } else {
       throw new Error(`Unknown type ${type}.`);
     }
   }
   return {
-    kind: import_graphql37.Kind.DOCUMENT,
+    kind: import_graphql38.Kind.DOCUMENT,
     definitions
   };
 }
@@ -75654,7 +75563,7 @@ function astFromSchema2(schema, pathToDirectivesInExtensions) {
         operationTypeDefinitionNode.type = rootTypeAST;
       } else {
         operationTypeMap.set(operationTypeNode, {
-          kind: import_graphql37.Kind.OPERATION_TYPE_DEFINITION,
+          kind: import_graphql38.Kind.OPERATION_TYPE_DEFINITION,
           operation: operationTypeNode,
           type: rootTypeAST
         });
@@ -75667,12 +75576,12 @@ function astFromSchema2(schema, pathToDirectivesInExtensions) {
     return null;
   }
   const schemaNode = {
-    kind: operationTypes != null ? import_graphql37.Kind.SCHEMA_DEFINITION : import_graphql37.Kind.SCHEMA_EXTENSION,
+    kind: operationTypes != null ? import_graphql38.Kind.SCHEMA_DEFINITION : import_graphql38.Kind.SCHEMA_EXTENSION,
     operationTypes,
     directives
   };
   schemaNode.description = schema.astNode?.description ?? schema.description != null ? {
-    kind: import_graphql37.Kind.STRING,
+    kind: import_graphql38.Kind.STRING,
     value: schema.description,
     block: true
   } : void 0;
@@ -75680,19 +75589,19 @@ function astFromSchema2(schema, pathToDirectivesInExtensions) {
 }
 function astFromDirective2(directive, schema, pathToDirectivesInExtensions) {
   return {
-    kind: import_graphql37.Kind.DIRECTIVE_DEFINITION,
+    kind: import_graphql38.Kind.DIRECTIVE_DEFINITION,
     description: directive.astNode?.description ?? (directive.description ? {
-      kind: import_graphql37.Kind.STRING,
+      kind: import_graphql38.Kind.STRING,
       value: directive.description
     } : void 0),
     name: {
-      kind: import_graphql37.Kind.NAME,
+      kind: import_graphql38.Kind.NAME,
       value: directive.name
     },
     arguments: directive.args?.map((arg) => astFromArg2(arg, schema, pathToDirectivesInExtensions)),
     repeatable: directive.isRepeatable,
     locations: directive.locations?.map((location) => ({
-      kind: import_graphql37.Kind.NAME,
+      kind: import_graphql38.Kind.NAME,
       value: location
     })) || []
   };
@@ -75742,14 +75651,14 @@ function getDeprecatableDirectiveNodes2(entity, schema, pathToDirectivesInExtens
 }
 function astFromArg2(arg, schema, pathToDirectivesInExtensions) {
   return {
-    kind: import_graphql37.Kind.INPUT_VALUE_DEFINITION,
+    kind: import_graphql38.Kind.INPUT_VALUE_DEFINITION,
     description: arg.astNode?.description ?? (arg.description ? {
-      kind: import_graphql37.Kind.STRING,
+      kind: import_graphql38.Kind.STRING,
       value: arg.description,
       block: true
     } : void 0),
     name: {
-      kind: import_graphql37.Kind.NAME,
+      kind: import_graphql38.Kind.NAME,
       value: arg.name
     },
     type: astFromType2(arg.type),
@@ -75759,14 +75668,14 @@ function astFromArg2(arg, schema, pathToDirectivesInExtensions) {
 }
 function astFromObjectType2(type, schema, pathToDirectivesInExtensions) {
   return {
-    kind: import_graphql37.Kind.OBJECT_TYPE_DEFINITION,
+    kind: import_graphql38.Kind.OBJECT_TYPE_DEFINITION,
     description: type.astNode?.description ?? (type.description ? {
-      kind: import_graphql37.Kind.STRING,
+      kind: import_graphql38.Kind.STRING,
       value: type.description,
       block: true
     } : void 0),
     name: {
-      kind: import_graphql37.Kind.NAME,
+      kind: import_graphql38.Kind.NAME,
       value: type.name
     },
     fields: Object.values(type.getFields()).map((field) => astFromField2(field, schema, pathToDirectivesInExtensions)),
@@ -75776,14 +75685,14 @@ function astFromObjectType2(type, schema, pathToDirectivesInExtensions) {
 }
 function astFromInterfaceType2(type, schema, pathToDirectivesInExtensions) {
   const node = {
-    kind: import_graphql37.Kind.INTERFACE_TYPE_DEFINITION,
+    kind: import_graphql38.Kind.INTERFACE_TYPE_DEFINITION,
     description: type.astNode?.description ?? (type.description ? {
-      kind: import_graphql37.Kind.STRING,
+      kind: import_graphql38.Kind.STRING,
       value: type.description,
       block: true
     } : void 0),
     name: {
-      kind: import_graphql37.Kind.NAME,
+      kind: import_graphql38.Kind.NAME,
       value: type.name
     },
     fields: Object.values(type.getFields()).map((field) => astFromField2(field, schema, pathToDirectivesInExtensions)),
@@ -75796,14 +75705,14 @@ function astFromInterfaceType2(type, schema, pathToDirectivesInExtensions) {
 }
 function astFromUnionType2(type, schema, pathToDirectivesInExtensions) {
   return {
-    kind: import_graphql37.Kind.UNION_TYPE_DEFINITION,
+    kind: import_graphql38.Kind.UNION_TYPE_DEFINITION,
     description: type.astNode?.description ?? (type.description ? {
-      kind: import_graphql37.Kind.STRING,
+      kind: import_graphql38.Kind.STRING,
       value: type.description,
       block: true
     } : void 0),
     name: {
-      kind: import_graphql37.Kind.NAME,
+      kind: import_graphql38.Kind.NAME,
       value: type.name
     },
     directives: getDirectiveNodes2(type, schema, pathToDirectivesInExtensions),
@@ -75812,14 +75721,14 @@ function astFromUnionType2(type, schema, pathToDirectivesInExtensions) {
 }
 function astFromInputObjectType2(type, schema, pathToDirectivesInExtensions) {
   return {
-    kind: import_graphql37.Kind.INPUT_OBJECT_TYPE_DEFINITION,
+    kind: import_graphql38.Kind.INPUT_OBJECT_TYPE_DEFINITION,
     description: type.astNode?.description ?? (type.description ? {
-      kind: import_graphql37.Kind.STRING,
+      kind: import_graphql38.Kind.STRING,
       value: type.description,
       block: true
     } : void 0),
     name: {
-      kind: import_graphql37.Kind.NAME,
+      kind: import_graphql38.Kind.NAME,
       value: type.name
     },
     fields: Object.values(type.getFields()).map((field) => astFromInputField2(field, schema, pathToDirectivesInExtensions)),
@@ -75828,14 +75737,14 @@ function astFromInputObjectType2(type, schema, pathToDirectivesInExtensions) {
 }
 function astFromEnumType2(type, schema, pathToDirectivesInExtensions) {
   return {
-    kind: import_graphql37.Kind.ENUM_TYPE_DEFINITION,
+    kind: import_graphql38.Kind.ENUM_TYPE_DEFINITION,
     description: type.astNode?.description ?? (type.description ? {
-      kind: import_graphql37.Kind.STRING,
+      kind: import_graphql38.Kind.STRING,
       value: type.description,
       block: true
     } : void 0),
     name: {
-      kind: import_graphql37.Kind.NAME,
+      kind: import_graphql38.Kind.NAME,
       value: type.name
     },
     values: Object.values(type.getValues()).map((value) => astFromEnumValue2(value, schema, pathToDirectivesInExtensions)),
@@ -75853,14 +75762,14 @@ function astFromScalarType2(type, schema, pathToDirectivesInExtensions) {
     directives.push(makeDirectiveNode2("specifiedBy", specifiedByArgs));
   }
   return {
-    kind: import_graphql37.Kind.SCALAR_TYPE_DEFINITION,
+    kind: import_graphql38.Kind.SCALAR_TYPE_DEFINITION,
     description: type.astNode?.description ?? (type.description ? {
-      kind: import_graphql37.Kind.STRING,
+      kind: import_graphql38.Kind.STRING,
       value: type.description,
       block: true
     } : void 0),
     name: {
-      kind: import_graphql37.Kind.NAME,
+      kind: import_graphql38.Kind.NAME,
       value: type.name
     },
     directives
@@ -75868,14 +75777,14 @@ function astFromScalarType2(type, schema, pathToDirectivesInExtensions) {
 }
 function astFromField2(field, schema, pathToDirectivesInExtensions) {
   return {
-    kind: import_graphql37.Kind.FIELD_DEFINITION,
+    kind: import_graphql38.Kind.FIELD_DEFINITION,
     description: field.astNode?.description ?? (field.description ? {
-      kind: import_graphql37.Kind.STRING,
+      kind: import_graphql38.Kind.STRING,
       value: field.description,
       block: true
     } : void 0),
     name: {
-      kind: import_graphql37.Kind.NAME,
+      kind: import_graphql38.Kind.NAME,
       value: field.name
     },
     arguments: field.args.map((arg) => astFromArg2(arg, schema, pathToDirectivesInExtensions)),
@@ -75885,14 +75794,14 @@ function astFromField2(field, schema, pathToDirectivesInExtensions) {
 }
 function astFromInputField2(field, schema, pathToDirectivesInExtensions) {
   return {
-    kind: import_graphql37.Kind.INPUT_VALUE_DEFINITION,
+    kind: import_graphql38.Kind.INPUT_VALUE_DEFINITION,
     description: field.astNode?.description ?? (field.description ? {
-      kind: import_graphql37.Kind.STRING,
+      kind: import_graphql38.Kind.STRING,
       value: field.description,
       block: true
     } : void 0),
     name: {
-      kind: import_graphql37.Kind.NAME,
+      kind: import_graphql38.Kind.NAME,
       value: field.name
     },
     type: astFromType2(field.type),
@@ -75902,21 +75811,21 @@ function astFromInputField2(field, schema, pathToDirectivesInExtensions) {
 }
 function astFromEnumValue2(value, schema, pathToDirectivesInExtensions) {
   return {
-    kind: import_graphql37.Kind.ENUM_VALUE_DEFINITION,
+    kind: import_graphql38.Kind.ENUM_VALUE_DEFINITION,
     description: value.astNode?.description ?? (value.description ? {
-      kind: import_graphql37.Kind.STRING,
+      kind: import_graphql38.Kind.STRING,
       value: value.description,
       block: true
     } : void 0),
     name: {
-      kind: import_graphql37.Kind.NAME,
+      kind: import_graphql38.Kind.NAME,
       value: value.name
     },
     directives: getDeprecatableDirectiveNodes2(value, schema, pathToDirectivesInExtensions)
   };
 }
 function makeDeprecatedDirective2(deprecationReason) {
-  return makeDirectiveNode2("deprecated", { reason: deprecationReason }, import_graphql37.GraphQLDeprecatedDirective);
+  return makeDirectiveNode2("deprecated", { reason: deprecationReason }, import_graphql38.GraphQLDeprecatedDirective);
 }
 function makeDirectiveNode2(name, args, directive) {
   const directiveArguments = [];
@@ -75928,9 +75837,9 @@ function makeDirectiveNode2(name, args, directive) {
         const value = astFromValue2(argValue, arg.type);
         if (value) {
           directiveArguments.push({
-            kind: import_graphql37.Kind.ARGUMENT,
+            kind: import_graphql38.Kind.ARGUMENT,
             name: {
-              kind: import_graphql37.Kind.NAME,
+              kind: import_graphql38.Kind.NAME,
               value: argName
             },
             value
@@ -75944,9 +75853,9 @@ function makeDirectiveNode2(name, args, directive) {
       const value = astFromValueUntyped2(argValue);
       if (value) {
         directiveArguments.push({
-          kind: import_graphql37.Kind.ARGUMENT,
+          kind: import_graphql38.Kind.ARGUMENT,
           name: {
-            kind: import_graphql37.Kind.NAME,
+            kind: import_graphql38.Kind.NAME,
             value: argName
           },
           value
@@ -75955,9 +75864,9 @@ function makeDirectiveNode2(name, args, directive) {
     }
   }
   return {
-    kind: import_graphql37.Kind.DIRECTIVE,
+    kind: import_graphql38.Kind.DIRECTIVE,
     name: {
-      kind: import_graphql37.Kind.NAME,
+      kind: import_graphql38.Kind.NAME,
       value: name
     },
     arguments: directiveArguments
@@ -75980,7 +75889,7 @@ function makeDirectiveNodes2(schema, directiveValues) {
 }
 
 // ../../node_modules/.pnpm/@graphql-tools+utils@10.0.6_graphql@15.5.0/node_modules/@graphql-tools/utils/esm/comments.js
-var import_graphql38 = require("graphql");
+var import_graphql39 = require("graphql");
 var MAX_LINE_LENGTH2 = 80;
 var commentsRegistry2 = {};
 function resetComments2() {
@@ -76225,7 +76134,7 @@ var printDocASTReducerWithComments2 = Object.keys(printDocASTReducer2).reduce((p
   }
 }), {});
 function printWithComments2(ast) {
-  return (0, import_graphql38.visit)(ast, printDocASTReducerWithComments2);
+  return (0, import_graphql39.visit)(ast, printDocASTReducerWithComments2);
 }
 function isFieldDefinitionNode2(node) {
   return node.kind === "FieldDefinition";
@@ -76244,7 +76153,7 @@ function getLeadingCommentBlock2(node) {
   }
   const comments = [];
   let token = loc.startToken.prev;
-  while (token != null && token.kind === import_graphql38.TokenKind.COMMENT && token.next != null && token.prev != null && token.line + 1 === token.next.line && token.line !== token.prev.line) {
+  while (token != null && token.kind === import_graphql39.TokenKind.COMMENT && token.next != null && token.prev != null && token.line + 1 === token.next.line && token.line !== token.prev.line) {
     const value = String(token.value);
     comments.push(value);
     token = token.prev;
@@ -76296,9 +76205,9 @@ function isBlank2(str) {
 }
 
 // ../../node_modules/.pnpm/@graphql-tools+utils@10.0.6_graphql@15.5.0/node_modules/@graphql-tools/utils/esm/isDocumentNode.js
-var import_graphql39 = require("graphql");
+var import_graphql40 = require("graphql");
 function isDocumentNode2(object) {
-  return object && typeof object === "object" && "kind" in object && object.kind === import_graphql39.Kind.DOCUMENT;
+  return object && typeof object === "object" && "kind" in object && object.kind === import_graphql40.Kind.DOCUMENT;
 }
 
 // ../../node_modules/.pnpm/@graphql-tools+merge@9.0.0_graphql@15.5.0/node_modules/@graphql-tools/merge/esm/typedefs-mergers/arguments.js
@@ -76322,7 +76231,7 @@ function deduplicateArguments2(args, config2) {
 }
 
 // ../../node_modules/.pnpm/@graphql-tools+merge@9.0.0_graphql@15.5.0/node_modules/@graphql-tools/merge/esm/typedefs-mergers/directives.js
-var import_graphql40 = require("graphql");
+var import_graphql41 = require("graphql");
 function directiveAlreadyExists2(directivesArr, otherDirective) {
   return !!directivesArr.find((directive) => directive.name.value === otherDirective.name.value);
 }
@@ -76382,11 +76291,11 @@ function mergeDirectives2(d1 = [], d2 = [], config2, directives) {
   return result;
 }
 function validateInputs2(node, existingNode) {
-  const printedNode = (0, import_graphql40.print)({
+  const printedNode = (0, import_graphql41.print)({
     ...node,
     description: void 0
   });
-  const printedExistingNode = (0, import_graphql40.print)({
+  const printedExistingNode = (0, import_graphql41.print)({
     ...existingNode,
     description: void 0
   });
@@ -76453,7 +76362,7 @@ function mergeEnumValues2(first, second, config2, directives) {
 }
 
 // ../../node_modules/.pnpm/@graphql-tools+merge@9.0.0_graphql@15.5.0/node_modules/@graphql-tools/merge/esm/typedefs-mergers/enum.js
-var import_graphql41 = require("graphql");
+var import_graphql42 = require("graphql");
 function mergeEnum2(e1, e2, config2, directives) {
   if (e2) {
     return {
@@ -76467,33 +76376,33 @@ function mergeEnum2(e1, e2, config2, directives) {
   }
   return config2?.convertExtensions ? {
     ...e1,
-    kind: import_graphql41.Kind.ENUM_TYPE_DEFINITION
+    kind: import_graphql42.Kind.ENUM_TYPE_DEFINITION
   } : e1;
 }
 
 // ../../node_modules/.pnpm/@graphql-tools+merge@9.0.0_graphql@15.5.0/node_modules/@graphql-tools/merge/esm/typedefs-mergers/utils.js
-var import_graphql42 = require("graphql");
+var import_graphql43 = require("graphql");
 function isStringTypes2(types17) {
   return typeof types17 === "string";
 }
 function isSourceTypes2(types17) {
-  return types17 instanceof import_graphql42.Source;
+  return types17 instanceof import_graphql43.Source;
 }
 function extractType2(type) {
   let visitedType = type;
-  while (visitedType.kind === import_graphql42.Kind.LIST_TYPE || visitedType.kind === "NonNullType") {
+  while (visitedType.kind === import_graphql43.Kind.LIST_TYPE || visitedType.kind === "NonNullType") {
     visitedType = visitedType.type;
   }
   return visitedType;
 }
 function isWrappingTypeNode2(type) {
-  return type.kind !== import_graphql42.Kind.NAMED_TYPE;
+  return type.kind !== import_graphql43.Kind.NAMED_TYPE;
 }
 function isListTypeNode2(type) {
-  return type.kind === import_graphql42.Kind.LIST_TYPE;
+  return type.kind === import_graphql43.Kind.LIST_TYPE;
 }
 function isNonNullTypeNode2(type) {
-  return type.kind === import_graphql42.Kind.NON_NULL_TYPE;
+  return type.kind === import_graphql43.Kind.NON_NULL_TYPE;
 }
 function printTypeNode2(type) {
   if (isListTypeNode2(type)) {
@@ -76596,7 +76505,7 @@ function safeChangeForFieldType2(oldType, newType, ignoreNullability = false) {
 }
 
 // ../../node_modules/.pnpm/@graphql-tools+merge@9.0.0_graphql@15.5.0/node_modules/@graphql-tools/merge/esm/typedefs-mergers/input-type.js
-var import_graphql43 = require("graphql");
+var import_graphql44 = require("graphql");
 function mergeInputType2(node, existingNode, config2, directives) {
   if (existingNode) {
     try {
@@ -76614,12 +76523,12 @@ function mergeInputType2(node, existingNode, config2, directives) {
   }
   return config2?.convertExtensions ? {
     ...node,
-    kind: import_graphql43.Kind.INPUT_OBJECT_TYPE_DEFINITION
+    kind: import_graphql44.Kind.INPUT_OBJECT_TYPE_DEFINITION
   } : node;
 }
 
 // ../../node_modules/.pnpm/@graphql-tools+merge@9.0.0_graphql@15.5.0/node_modules/@graphql-tools/merge/esm/typedefs-mergers/interface.js
-var import_graphql44 = require("graphql");
+var import_graphql45 = require("graphql");
 
 // ../../node_modules/.pnpm/@graphql-tools+merge@9.0.0_graphql@15.5.0/node_modules/@graphql-tools/merge/esm/typedefs-mergers/merge-named-type-array.js
 function alreadyExists2(arr, other) {
@@ -76652,15 +76561,15 @@ function mergeInterface2(node, existingNode, config2, directives) {
   }
   return config2?.convertExtensions ? {
     ...node,
-    kind: import_graphql44.Kind.INTERFACE_TYPE_DEFINITION
+    kind: import_graphql45.Kind.INTERFACE_TYPE_DEFINITION
   } : node;
 }
 
 // ../../node_modules/.pnpm/@graphql-tools+merge@9.0.0_graphql@15.5.0/node_modules/@graphql-tools/merge/esm/typedefs-mergers/merge-nodes.js
-var import_graphql49 = require("graphql");
+var import_graphql50 = require("graphql");
 
 // ../../node_modules/.pnpm/@graphql-tools+merge@9.0.0_graphql@15.5.0/node_modules/@graphql-tools/merge/esm/typedefs-mergers/type.js
-var import_graphql45 = require("graphql");
+var import_graphql46 = require("graphql");
 function mergeType2(node, existingNode, config2, directives) {
   if (existingNode) {
     try {
@@ -76679,12 +76588,12 @@ function mergeType2(node, existingNode, config2, directives) {
   }
   return config2?.convertExtensions ? {
     ...node,
-    kind: import_graphql45.Kind.OBJECT_TYPE_DEFINITION
+    kind: import_graphql46.Kind.OBJECT_TYPE_DEFINITION
   } : node;
 }
 
 // ../../node_modules/.pnpm/@graphql-tools+merge@9.0.0_graphql@15.5.0/node_modules/@graphql-tools/merge/esm/typedefs-mergers/scalar.js
-var import_graphql46 = require("graphql");
+var import_graphql47 = require("graphql");
 function mergeScalar2(node, existingNode, config2, directives) {
   if (existingNode) {
     return {
@@ -76697,31 +76606,31 @@ function mergeScalar2(node, existingNode, config2, directives) {
   }
   return config2?.convertExtensions ? {
     ...node,
-    kind: import_graphql46.Kind.SCALAR_TYPE_DEFINITION
+    kind: import_graphql47.Kind.SCALAR_TYPE_DEFINITION
   } : node;
 }
 
 // ../../node_modules/.pnpm/@graphql-tools+merge@9.0.0_graphql@15.5.0/node_modules/@graphql-tools/merge/esm/typedefs-mergers/union.js
-var import_graphql47 = require("graphql");
+var import_graphql48 = require("graphql");
 function mergeUnion2(first, second, config2, directives) {
   if (second) {
     return {
       name: first.name,
       description: first["description"] || second["description"],
       directives: mergeDirectives2(first.directives, second.directives, config2, directives),
-      kind: config2?.convertExtensions || first.kind === "UnionTypeDefinition" || second.kind === "UnionTypeDefinition" ? import_graphql47.Kind.UNION_TYPE_DEFINITION : import_graphql47.Kind.UNION_TYPE_EXTENSION,
+      kind: config2?.convertExtensions || first.kind === "UnionTypeDefinition" || second.kind === "UnionTypeDefinition" ? import_graphql48.Kind.UNION_TYPE_DEFINITION : import_graphql48.Kind.UNION_TYPE_EXTENSION,
       loc: first.loc,
       types: mergeNamedTypeArray2(first.types, second.types, config2)
     };
   }
   return config2?.convertExtensions ? {
     ...first,
-    kind: import_graphql47.Kind.UNION_TYPE_DEFINITION
+    kind: import_graphql48.Kind.UNION_TYPE_DEFINITION
   } : first;
 }
 
 // ../../node_modules/.pnpm/@graphql-tools+merge@9.0.0_graphql@15.5.0/node_modules/@graphql-tools/merge/esm/typedefs-mergers/schema-def.js
-var import_graphql48 = require("graphql");
+var import_graphql49 = require("graphql");
 var DEFAULT_OPERATION_TYPE_NAME_MAP2 = {
   query: "Query",
   mutation: "Mutation",
@@ -76740,7 +76649,7 @@ function mergeOperationTypes2(opNodeList = [], existingOpNodeList = []) {
 function mergeSchemaDefs2(node, existingNode, config2, directives) {
   if (existingNode) {
     return {
-      kind: node.kind === import_graphql48.Kind.SCHEMA_DEFINITION || existingNode.kind === import_graphql48.Kind.SCHEMA_DEFINITION ? import_graphql48.Kind.SCHEMA_DEFINITION : import_graphql48.Kind.SCHEMA_EXTENSION,
+      kind: node.kind === import_graphql49.Kind.SCHEMA_DEFINITION || existingNode.kind === import_graphql49.Kind.SCHEMA_DEFINITION ? import_graphql49.Kind.SCHEMA_DEFINITION : import_graphql49.Kind.SCHEMA_EXTENSION,
       description: node["description"] || existingNode["description"],
       directives: mergeDirectives2(node.directives, existingNode.directives, config2, directives),
       operationTypes: mergeOperationTypes2(node.operationTypes, existingNode.operationTypes)
@@ -76748,7 +76657,7 @@ function mergeSchemaDefs2(node, existingNode, config2, directives) {
   }
   return config2?.convertExtensions ? {
     ...node,
-    kind: import_graphql48.Kind.SCHEMA_DEFINITION
+    kind: import_graphql49.Kind.SCHEMA_DEFINITION
   } : node;
 }
 
@@ -76772,36 +76681,36 @@ function mergeGraphQLNodes2(nodes, config2, directives = {}) {
         delete mergedResultMap[name];
       } else {
         switch (nodeDefinition.kind) {
-          case import_graphql49.Kind.OBJECT_TYPE_DEFINITION:
-          case import_graphql49.Kind.OBJECT_TYPE_EXTENSION:
+          case import_graphql50.Kind.OBJECT_TYPE_DEFINITION:
+          case import_graphql50.Kind.OBJECT_TYPE_EXTENSION:
             mergedResultMap[name] = mergeType2(nodeDefinition, mergedResultMap[name], config2, directives);
             break;
-          case import_graphql49.Kind.ENUM_TYPE_DEFINITION:
-          case import_graphql49.Kind.ENUM_TYPE_EXTENSION:
+          case import_graphql50.Kind.ENUM_TYPE_DEFINITION:
+          case import_graphql50.Kind.ENUM_TYPE_EXTENSION:
             mergedResultMap[name] = mergeEnum2(nodeDefinition, mergedResultMap[name], config2, directives);
             break;
-          case import_graphql49.Kind.UNION_TYPE_DEFINITION:
-          case import_graphql49.Kind.UNION_TYPE_EXTENSION:
+          case import_graphql50.Kind.UNION_TYPE_DEFINITION:
+          case import_graphql50.Kind.UNION_TYPE_EXTENSION:
             mergedResultMap[name] = mergeUnion2(nodeDefinition, mergedResultMap[name], config2, directives);
             break;
-          case import_graphql49.Kind.SCALAR_TYPE_DEFINITION:
-          case import_graphql49.Kind.SCALAR_TYPE_EXTENSION:
+          case import_graphql50.Kind.SCALAR_TYPE_DEFINITION:
+          case import_graphql50.Kind.SCALAR_TYPE_EXTENSION:
             mergedResultMap[name] = mergeScalar2(nodeDefinition, mergedResultMap[name], config2, directives);
             break;
-          case import_graphql49.Kind.INPUT_OBJECT_TYPE_DEFINITION:
-          case import_graphql49.Kind.INPUT_OBJECT_TYPE_EXTENSION:
+          case import_graphql50.Kind.INPUT_OBJECT_TYPE_DEFINITION:
+          case import_graphql50.Kind.INPUT_OBJECT_TYPE_EXTENSION:
             mergedResultMap[name] = mergeInputType2(nodeDefinition, mergedResultMap[name], config2, directives);
             break;
-          case import_graphql49.Kind.INTERFACE_TYPE_DEFINITION:
-          case import_graphql49.Kind.INTERFACE_TYPE_EXTENSION:
+          case import_graphql50.Kind.INTERFACE_TYPE_DEFINITION:
+          case import_graphql50.Kind.INTERFACE_TYPE_EXTENSION:
             mergedResultMap[name] = mergeInterface2(nodeDefinition, mergedResultMap[name], config2, directives);
             break;
-          case import_graphql49.Kind.DIRECTIVE_DEFINITION:
+          case import_graphql50.Kind.DIRECTIVE_DEFINITION:
             mergedResultMap[name] = mergeDirective2(nodeDefinition, mergedResultMap[name]);
             break;
         }
       }
-    } else if (nodeDefinition.kind === import_graphql49.Kind.SCHEMA_DEFINITION || nodeDefinition.kind === import_graphql49.Kind.SCHEMA_EXTENSION) {
+    } else if (nodeDefinition.kind === import_graphql50.Kind.SCHEMA_DEFINITION || nodeDefinition.kind === import_graphql50.Kind.SCHEMA_EXTENSION) {
       mergedResultMap[schemaDefSymbol2] = mergeSchemaDefs2(nodeDefinition, mergedResultMap[schemaDefSymbol2], config2);
     }
   }
@@ -76809,11 +76718,11 @@ function mergeGraphQLNodes2(nodes, config2, directives = {}) {
 }
 
 // ../../node_modules/.pnpm/@graphql-tools+merge@9.0.0_graphql@15.5.0/node_modules/@graphql-tools/merge/esm/typedefs-mergers/merge-typedefs.js
-var import_graphql50 = require("graphql");
+var import_graphql51 = require("graphql");
 function mergeTypeDefs2(typeSource, config2) {
   resetComments2();
   const doc = {
-    kind: import_graphql50.Kind.DOCUMENT,
+    kind: import_graphql51.Kind.DOCUMENT,
     definitions: mergeGraphQLTypes2(typeSource, {
       useSchemaDefinition: true,
       forceSchemaDefinition: false,
@@ -76840,14 +76749,14 @@ function visitTypeSources2(typeSource, options, allDirectives = [], allNodes = [
       for (const type of typeSource) {
         visitTypeSources2(type, options, allDirectives, allNodes, visitedTypeSources);
       }
-    } else if ((0, import_graphql50.isSchema)(typeSource)) {
+    } else if ((0, import_graphql51.isSchema)(typeSource)) {
       const documentNode = getDocumentNodeFromSchema2(typeSource, options);
       visitTypeSources2(documentNode.definitions, options, allDirectives, allNodes, visitedTypeSources);
     } else if (isStringTypes2(typeSource) || isSourceTypes2(typeSource)) {
-      const documentNode = (0, import_graphql50.parse)(typeSource, options);
+      const documentNode = (0, import_graphql51.parse)(typeSource, options);
       visitTypeSources2(documentNode.definitions, options, allDirectives, allNodes, visitedTypeSources);
-    } else if (typeof typeSource === "object" && (0, import_graphql50.isDefinitionNode)(typeSource)) {
-      if (typeSource.kind === import_graphql50.Kind.DIRECTIVE_DEFINITION) {
+    } else if (typeof typeSource === "object" && (0, import_graphql51.isDefinitionNode)(typeSource)) {
+      if (typeSource.kind === import_graphql51.Kind.DIRECTIVE_DEFINITION) {
         allDirectives.push(typeSource);
       } else {
         allNodes.push(typeSource);
@@ -76867,7 +76776,7 @@ function mergeGraphQLTypes2(typeSource, config2) {
   const mergedNodes = mergeGraphQLNodes2(allNodes, config2, mergedDirectives);
   if (config2?.useSchemaDefinition) {
     const schemaDef = mergedNodes[schemaDefSymbol2] || {
-      kind: import_graphql50.Kind.SCHEMA_DEFINITION,
+      kind: import_graphql51.Kind.SCHEMA_DEFINITION,
       operationTypes: []
     };
     const operationTypes = schemaDef.operationTypes;
@@ -76878,9 +76787,9 @@ function mergeGraphQLTypes2(typeSource, config2) {
         const existingPossibleRootType = mergedNodes[possibleRootTypeName];
         if (existingPossibleRootType != null && existingPossibleRootType.name != null) {
           operationTypes.push({
-            kind: import_graphql50.Kind.OPERATION_TYPE_DEFINITION,
+            kind: import_graphql51.Kind.OPERATION_TYPE_DEFINITION,
             type: {
-              kind: import_graphql50.Kind.NAMED_TYPE,
+              kind: import_graphql51.Kind.NAMED_TYPE,
               name: existingPossibleRootType.name
             },
             operation: opTypeDefNodeType
@@ -76894,15 +76803,15 @@ function mergeGraphQLTypes2(typeSource, config2) {
   }
   if (config2?.forceSchemaDefinition && !mergedNodes[schemaDefSymbol2]?.operationTypes?.length) {
     mergedNodes[schemaDefSymbol2] = {
-      kind: import_graphql50.Kind.SCHEMA_DEFINITION,
+      kind: import_graphql51.Kind.SCHEMA_DEFINITION,
       operationTypes: [
         {
-          kind: import_graphql50.Kind.OPERATION_TYPE_DEFINITION,
+          kind: import_graphql51.Kind.OPERATION_TYPE_DEFINITION,
           operation: "query",
           type: {
-            kind: import_graphql50.Kind.NAMED_TYPE,
+            kind: import_graphql51.Kind.NAMED_TYPE,
             name: {
-              kind: import_graphql50.Kind.NAME,
+              kind: import_graphql51.Kind.NAME,
               value: "Query"
             }
           }
@@ -76919,7 +76828,7 @@ function mergeGraphQLTypes2(typeSource, config2) {
 }
 
 // src/codegen/transforms/schema.ts
-var graphql25 = __toESM(require("graphql"), 1);
+var graphql24 = __toESM(require("graphql"), 1);
 async function graphqlExtensions(config2, documents) {
   let internalSchema = `
 enum CachePolicy {
@@ -77042,7 +76951,7 @@ directive @${config2.componentFieldDirective}(field: String!, prop: String, expo
       const args = fragmentArguments(config2, "", field.parent);
       if (args.length > 0) {
         argString = "(" + args.map((arg) => {
-          const typeName = graphql25.print(arg.type);
+          const typeName = graphql24.print(arg.type);
           return `${arg.name}:${typeName}${arg.required ? "!" : ""}`;
         }).join("\n") + ")";
       }
@@ -77052,20 +76961,20 @@ directive @${config2.componentFieldDirective}(field: String!, prop: String, expo
 	`;
   }).join("\n");
   extensions += `${Object.keys(config2.configFile.features?.runtimeScalars ?? {}).map((scalar) => `scalar ${scalar}`).join("\n")}`;
-  config2.newSchema = graphql25.print(mergeTypeDefs2([internalSchema, config2.newSchema]));
+  config2.newSchema = graphql24.print(mergeTypeDefs2([internalSchema, config2.newSchema]));
   config2.schemaString += extensions;
-  config2.schema = graphql25.buildSchema(
-    graphql25.print(
-      mergeTypeDefs2([graphql25.printSchema(config2.schema), internalSchema, extensions])
+  config2.schema = graphql24.buildSchema(
+    graphql24.print(
+      mergeTypeDefs2([graphql24.printSchema(config2.schema), internalSchema, extensions])
     )
   );
 }
 
 // src/codegen/transforms/typename.ts
-var graphql26 = __toESM(require("graphql"), 1);
+var graphql25 = __toESM(require("graphql"), 1);
 async function addTypename(config2, documents) {
   for (const doc of documents) {
-    doc.document = graphql26.visit(doc.document, {
+    doc.document = graphql25.visit(doc.document, {
       Field(node, key, parent2, path3, ancestors) {
         if (!node.selectionSet) {
           return;
@@ -77077,7 +76986,7 @@ async function addTypename(config2, documents) {
         );
         const field = type.getFields()[node.name.value];
         const fieldType = unwrapType(config2, field.type).type;
-        if (graphql26.isInterfaceType(fieldType) || graphql26.isUnionType(fieldType)) {
+        if (graphql25.isInterfaceType(fieldType) || graphql25.isUnionType(fieldType)) {
           return {
             ...node,
             selectionSet: {
@@ -77085,9 +76994,9 @@ async function addTypename(config2, documents) {
               selections: [
                 ...node.selectionSet.selections,
                 {
-                  kind: graphql26.Kind.FIELD,
+                  kind: graphql25.Kind.FIELD,
                   name: {
-                    kind: graphql26.Kind.NAME,
+                    kind: graphql25.Kind.NAME,
                     value: "__typename"
                   }
                 }
@@ -77104,9 +77013,9 @@ async function addTypename(config2, documents) {
             selections: [
               ...node.selectionSet.selections,
               {
-                kind: graphql26.Kind.FIELD,
+                kind: graphql25.Kind.FIELD,
                 name: {
-                  kind: graphql26.Kind.NAME,
+                  kind: graphql25.Kind.NAME,
                   value: "__typename"
                 }
               }
@@ -77119,10 +77028,10 @@ async function addTypename(config2, documents) {
 }
 
 // src/codegen/transforms/addID.ts
-var graphql27 = __toESM(require("graphql"), 1);
+var graphql26 = __toESM(require("graphql"), 1);
 async function addID(config2, documents) {
   for (const doc of documents) {
-    doc.document = graphql27.visit(doc.document, {
+    doc.document = graphql26.visit(doc.document, {
       Field(node, key, parent2, path3, ancestors) {
         if (!node.selectionSet) {
           return;
@@ -77160,7 +77069,7 @@ function addKeysToSelection(config2, node, fieldType) {
   if (!node.selectionSet || node.selectionSet.selections.length == 0) {
     return;
   }
-  if (!graphql27.isObjectType(fieldType) && !graphql27.isInterfaceType(fieldType)) {
+  if (!graphql26.isObjectType(fieldType) && !graphql26.isInterfaceType(fieldType)) {
     return;
   }
   const keyFields = config2.keyFieldsForType(fieldType.name);
@@ -77175,9 +77084,9 @@ function addKeysToSelection(config2, node, fieldType) {
       continue;
     }
     selections.push({
-      kind: graphql27.Kind.FIELD,
+      kind: graphql26.Kind.FIELD,
       name: {
-        kind: graphql27.Kind.NAME,
+        kind: graphql26.Kind.NAME,
         value: keyField
       }
     });
@@ -77192,13 +77101,13 @@ function addKeysToSelection(config2, node, fieldType) {
 }
 
 // src/codegen/transforms/componentFields.ts
-var graphql28 = __toESM(require("graphql"), 1);
+var graphql27 = __toESM(require("graphql"), 1);
 async function componentFields(config2, documents) {
   for (const document of documents) {
-    const typeInfo = new graphql28.TypeInfo(config2.schema);
-    document.document = graphql28.visit(
+    const typeInfo = new graphql27.TypeInfo(config2.schema);
+    document.document = graphql27.visit(
       document.document,
-      graphql28.visitWithTypeInfo(typeInfo, {
+      graphql27.visitWithTypeInfo(typeInfo, {
         Field(node) {
           const parentType = typeInfo.getParentType();
           if (!parentType) {
@@ -77247,10 +77156,10 @@ async function componentFields(config2, documents) {
 }
 
 // src/codegen/transforms/runtimeScalars.ts
-var graphql29 = __toESM(require("graphql"), 1);
+var graphql28 = __toESM(require("graphql"), 1);
 async function addTypename2(config2, documents) {
   for (const doc of documents) {
-    doc.document = graphql29.visit(doc.document, {
+    doc.document = graphql28.visit(doc.document, {
       VariableDefinition(node) {
         const { type, wrappers } = unwrapType(config2, node.type);
         const runtimeScalar = config2.configFile.features?.runtimeScalars?.[type.name];
@@ -77289,7 +77198,7 @@ async function addTypename2(config2, documents) {
 }
 
 // src/codegen/validators/typeCheck.ts
-var graphql30 = __toESM(require("graphql"), 1);
+var graphql29 = __toESM(require("graphql"), 1);
 async function typeCheck(config2, docs) {
   const errors = [];
   const freeLists = [];
@@ -77297,7 +77206,7 @@ async function typeCheck(config2, docs) {
   const listTypes = [];
   const fragments = {};
   for (const { document: parsed, originalString, filename } of docs) {
-    graphql30.visit(parsed, {
+    graphql29.visit(parsed, {
       FragmentDefinition(definition) {
         fragments[definition.name.value] = definition;
       },
@@ -77342,14 +77251,14 @@ async function typeCheck(config2, docs) {
             );
             return;
           }
-          if (graphql30.isListType(rootType) || graphql30.isNonNullType(rootType) && graphql30.isListType(rootType.ofType)) {
+          if (graphql29.isListType(rootType) || graphql29.isNonNullType(rootType) && graphql29.isListType(rootType.ofType)) {
             needsParent = true;
             break;
           }
-          if (graphql30.isNonNullType(rootType) && "ofType" in rootType) {
+          if (graphql29.isNonNullType(rootType) && "ofType" in rootType) {
             rootType = rootType.ofType;
           }
-          if (graphql30.isScalarType(rootType)) {
+          if (graphql29.isScalarType(rootType)) {
             break;
           }
           rootType = rootType?.getFields()[parent3.name.value]?.type;
@@ -77425,9 +77334,9 @@ async function typeCheck(config2, docs) {
           );
         }
         let targetTypes = [type];
-        if (graphql30.isUnionType(type)) {
+        if (graphql29.isUnionType(type)) {
           targetTypes = config2.schema.getPossibleTypes(type);
-        } else if (graphql30.isInterfaceType(type)) {
+        } else if (graphql29.isInterfaceType(type)) {
           try {
             for (const key of config2.keyFieldsForType(type.name)) {
               if (!type.getFields()[key]) {
@@ -77463,13 +77372,13 @@ async function typeCheck(config2, docs) {
   if (errors.length > 0) {
     throw errors;
   }
-  const rules = (filepath) => [...graphql30.specifiedRules].filter(
+  const rules = (filepath) => [...graphql29.specifiedRules].filter(
     (rule) => ![
-      graphql30.NoUnusedFragmentsRule,
-      graphql30.KnownFragmentNamesRule,
-      graphql30.ExecutableDefinitionsRule,
-      graphql30.KnownDirectivesRule,
-      graphql30.KnownArgumentNamesRule
+      graphql29.NoUnusedFragmentsRule,
+      graphql29.KnownFragmentNamesRule,
+      graphql29.ExecutableDefinitionsRule,
+      graphql29.KnownDirectivesRule,
+      graphql29.KnownArgumentNamesRule
     ].includes(rule)
   ).concat(
     validateLists({
@@ -77490,7 +77399,7 @@ async function typeCheck(config2, docs) {
     validateLoadingDirective(config2)
   );
   for (const { filename, document: parsed, originalString } of docs) {
-    for (const error of graphql30.validate(config2.schema, parsed, rules(filename))) {
+    for (const error of graphql29.validate(config2.schema, parsed, rules(filename))) {
       errors.push(
         new HoudiniError({
           filepath: filename,
@@ -77519,20 +77428,20 @@ function validateRequiredDirective(config2, filepath) {
         if (!node.directives?.some(({ name }) => name.value === config2.requiredDirective))
           return;
         const parentType = parentTypeFromAncestors(config2.schema, filepath, ancestors);
-        if (!graphql30.isObjectType(parentType)) {
+        if (!graphql29.isObjectType(parentType)) {
           ctx.reportError(
-            new graphql30.GraphQLError(
+            new graphql29.GraphQLError(
               `@${config2.requiredDirective} may only be used on objects, not arguments`
             )
           );
           return;
         }
         const type = parentType.getFields()[node.name.value].type;
-        const isServerNullable = !graphql30.isNonNullType(type);
+        const isServerNullable = !graphql29.isNonNullType(type);
         const isAlreadyClientNullable = isClientNullable(node, true);
         if (!isServerNullable && !isAlreadyClientNullable) {
           ctx.reportError(
-            new graphql30.GraphQLError(
+            new graphql29.GraphQLError(
               `@${config2.requiredDirective} may only be used on nullable fields`
             )
           );
@@ -77554,7 +77463,7 @@ var validateLists = ({
       if (!config2.isListFragment(node.name.value)) {
         if (!fragments[node.name.value]) {
           ctx.reportError(
-            new graphql30.GraphQLError(
+            new graphql29.GraphQLError(
               "Encountered unknown fragment: " + node.name.value
             )
           );
@@ -77564,7 +77473,7 @@ var validateLists = ({
       const listName = config2.listNameFromFragment(node.name.value);
       if (!lists.includes(listName)) {
         ctx.reportError(
-          new graphql30.GraphQLError(
+          new graphql29.GraphQLError(
             "Encountered fragment referencing unknown list: " + listName
           )
         );
@@ -77589,7 +77498,7 @@ var validateLists = ({
         );
         if (parentArg) {
           ctx.reportError(
-            new graphql30.GraphQLError(
+            new graphql29.GraphQLError(
               `@${config2.deprecatedlistDirectiveParentIDArg} should be defined only in it's own directive now`
             )
           );
@@ -77605,7 +77514,7 @@ var validateLists = ({
         return;
       }
       ctx.reportError(
-        new graphql30.GraphQLError(
+        new graphql29.GraphQLError(
           `For this list fragment, you need to add or @${config2.listParentDirective} or @${config2.listAllListsDirective} directive to specify the behavior`
         )
       );
@@ -77615,7 +77524,7 @@ var validateLists = ({
       const directiveName = node.name.value;
       if (directiveName === "connection") {
         ctx.reportError(
-          new graphql30.GraphQLError(
+          new graphql29.GraphQLError(
             "@connection was renamed to @list. Please change your components. If you were using `cache.connection` in your components, you will need to update that to `cache.list` too."
           )
         );
@@ -77624,7 +77533,7 @@ var validateLists = ({
       if (!config2.isInternalDirective(node.name.value)) {
         if (!config2.schema.getDirective(directiveName)) {
           ctx.reportError(
-            new graphql30.GraphQLError(
+            new graphql29.GraphQLError(
               "Encountered unknown directive: " + directiveName
             )
           );
@@ -77633,7 +77542,7 @@ var validateLists = ({
       }
       if (config2.isListOperationDirective(directiveName) && !listTypes.includes(config2.listNameFromDirective(directiveName))) {
         ctx.reportError(
-          new graphql30.GraphQLError(
+          new graphql29.GraphQLError(
             "Encountered directive referencing unknown list: " + directiveName
           )
         );
@@ -77644,7 +77553,7 @@ var validateLists = ({
 };
 function knownArguments(config2) {
   return function(ctx) {
-    const nativeValidator = graphql30.KnownArgumentNamesRule(ctx);
+    const nativeValidator = graphql29.KnownArgumentNamesRule(ctx);
     return {
       ...nativeValidator,
       Directive(directiveNode) {
@@ -77679,7 +77588,7 @@ function validateFragmentArguments(config2, filepath, fragments) {
         for (const arg of node.arguments || []) {
           if (arg.value.kind !== "ObjectValue") {
             ctx.reportError(
-              new graphql30.GraphQLError("values in @arguments must be an object")
+              new graphql29.GraphQLError("values in @arguments must be an object")
             );
             return;
           }
@@ -77689,13 +77598,13 @@ function validateFragmentArguments(config2, filepath, fragments) {
           );
           if (!typeArg) {
             ctx.reportError(
-              new graphql30.GraphQLError("missing type field for @arguments directive")
+              new graphql29.GraphQLError("missing type field for @arguments directive")
             );
             return;
           }
-          if (typeArg.value.kind !== graphql30.Kind.STRING) {
+          if (typeArg.value.kind !== graphql29.Kind.STRING) {
             ctx.reportError(
-              new graphql30.GraphQLError("type field to @arguments must be a string")
+              new graphql29.GraphQLError("type field to @arguments must be a string")
             );
             return;
           }
@@ -77708,7 +77617,7 @@ function validateFragmentArguments(config2, filepath, fragments) {
           );
           if (typeArg.value.value !== defaultValueType) {
             ctx.reportError(
-              new graphql30.GraphQLError(
+              new graphql29.GraphQLError(
                 `Invalid default value provided for ${arg.name.value}. Expected ${typeArg.value.value}, found ${defaultValueType}`
               )
             );
@@ -77726,7 +77635,7 @@ function validateFragmentArguments(config2, filepath, fragments) {
           try {
             args = fragmentArguments(config2, filepath, fragments[fragmentName]);
           } catch (e2) {
-            ctx.reportError(new graphql30.GraphQLError(e2.message));
+            ctx.reportError(new graphql29.GraphQLError(e2.message));
             return;
           }
           fragmentArguments2[fragmentName] = args;
@@ -77749,7 +77658,7 @@ function validateFragmentArguments(config2, filepath, fragments) {
         );
         if (missing.length > 0) {
           ctx.reportError(
-            new graphql30.GraphQLError(
+            new graphql29.GraphQLError(
               `The following arguments are missing from the "${fragmentName}" fragment: ` + JSON.stringify(missing)
             )
           );
@@ -77760,7 +77669,7 @@ function validateFragmentArguments(config2, filepath, fragments) {
         );
         if (unknown.length > 0) {
           ctx.reportError(
-            new graphql30.GraphQLError(
+            new graphql29.GraphQLError(
               "Encountered unknown arguments: " + JSON.stringify(unknown)
             )
           );
@@ -77772,7 +77681,7 @@ function validateFragmentArguments(config2, filepath, fragments) {
           for (const [applied, target] of zipped) {
             if (!valueIsType(config2, applied.value, target)) {
               ctx.reportError(
-                new graphql30.GraphQLError(
+                new graphql29.GraphQLError(
                   `Invalid argument type. Expected ${target}, found ${applied.value.kind}`
                 )
               );
@@ -77814,7 +77723,7 @@ function valueIsType(config2, value, targetType) {
   }
   if (value.kind === "EnumValue" && targetType.kind === "NamedType") {
     const enumType = config2.schema.getType(targetType.name.value);
-    if (!graphql30.isEnumType(enumType)) {
+    if (!graphql29.isEnumType(enumType)) {
       return false;
     }
     return enumType.getValues().some((enumValue) => enumValue.value === value.value);
@@ -77834,7 +77743,7 @@ function paginateArgs(config2, filepath) {
         }
         if (alreadyPaginated) {
           ctx.reportError(
-            new graphql30.GraphQLError(
+            new graphql29.GraphQLError(
               `@${config2.paginateDirective} can only appear in a document once.`
             )
           );
@@ -77866,7 +77775,7 @@ function paginateArgs(config2, filepath) {
           const backwards = appliedArgs.has("last");
           if (!forward && !backwards) {
             ctx.reportError(
-              new graphql30.GraphQLError(
+              new graphql29.GraphQLError(
                 "A field with cursor-based pagination must have a first or last argument"
               )
             );
@@ -77880,7 +77789,7 @@ function paginateArgs(config2, filepath) {
           }
           if (forward && backwards && paginateMode === "Infinite") {
             ctx.reportError(
-              new graphql30.GraphQLError(
+              new graphql29.GraphQLError(
                 `A field with cursor pagination cannot go forwards an backwards simultaneously`
               )
             );
@@ -77894,7 +77803,7 @@ function paginateArgs(config2, filepath) {
           );
           if (!appliedLimitArg) {
             ctx.reportError(
-              new graphql30.GraphQLError(
+              new graphql29.GraphQLError(
                 "A field with offset-based pagination must have a limit argument"
               )
             );
@@ -77910,20 +77819,20 @@ function noUnusedFragmentArguments(config2) {
     const args = /* @__PURE__ */ new Set();
     return {
       enter(node) {
-        if (node.kind === graphql30.Kind.FRAGMENT_DEFINITION) {
+        if (node.kind === graphql29.Kind.FRAGMENT_DEFINITION) {
           const definitionArguments = node.directives?.filter((directive) => directive.name.value === config2.argumentsDirective).flatMap((directive) => directive.arguments);
           for (const arg of definitionArguments?.map((arg2) => arg2?.name.value) || []) {
             args.add(arg);
           }
-        } else if (node.kind === graphql30.Kind.VARIABLE) {
+        } else if (node.kind === graphql29.Kind.VARIABLE) {
           args.delete(node.name.value);
         }
       },
       leave(node) {
-        if (node.kind === graphql30.Kind.FRAGMENT_DEFINITION) {
+        if (node.kind === graphql29.Kind.FRAGMENT_DEFINITION) {
           if (args.size > 0) {
             ctx.reportError(
-              new graphql30.GraphQLError(
+              new graphql29.GraphQLError(
                 "Encountered unused fragment arguments: " + [...args].join(",")
               )
             );
@@ -77959,7 +77868,7 @@ function nodeDirectives(config2, directives) {
         if (definition.kind === "OperationDefinition") {
           if (definition.operation !== "query") {
             ctx.reportError(
-              new graphql30.GraphQLError(
+              new graphql29.GraphQLError(
                 `@${node.name.value} must fall on a fragment or query document`
               )
             );
@@ -77971,7 +77880,7 @@ function nodeDirectives(config2, directives) {
         }
         if (!possibleNodes.includes(definitionType)) {
           ctx.reportError(
-            new graphql30.GraphQLError(paginateOnNonNodeMessage(node.name.value))
+            new graphql29.GraphQLError(paginateOnNonNodeMessage(node.name.value))
           );
         }
       }
@@ -77990,7 +77899,7 @@ function checkMutationOperation(config2) {
         );
         if (append && prepend) {
           ctx.reportError(
-            new graphql30.GraphQLError(
+            new graphql29.GraphQLError(
               `You can't apply both @${config2.listPrependDirective} and @${config2.listAppendDirective} at the same time`
             )
           );
@@ -78004,7 +77913,7 @@ function checkMutationOperation(config2) {
         );
         if (parentId && allLists) {
           ctx.reportError(
-            new graphql30.GraphQLError(
+            new graphql29.GraphQLError(
               `You can't apply both @${config2.listParentDirective} and @${config2.listAllListsDirective} at the same time`
             )
           );
@@ -78026,7 +77935,7 @@ function checkMaskDirectives(config2) {
         );
         if (maskEnableDirective && maskDisableDirective) {
           ctx.reportError(
-            new graphql30.GraphQLError(
+            new graphql29.GraphQLError(
               `You can't apply both @${config2.maskEnableDirective} and @${config2.maskDisableDirective} at the same time`
             )
           );
@@ -78068,7 +77977,7 @@ function validateLoadingDirective(config2) {
         );
         if (!parentLoading && !global2) {
           ctx.reportError(
-            new graphql30.GraphQLError(
+            new graphql29.GraphQLError(
               `@${config2.loadingDirective} can only be applied on a field or fragment spread at the root of a document or on one whose parent also has @${config2.loadingDirective}`
             )
           );
@@ -78090,7 +77999,7 @@ function validateLoadingDirective(config2) {
         );
         if (!parentLoading && !global2) {
           ctx.reportError(
-            new graphql30.GraphQLError(
+            new graphql29.GraphQLError(
               `@${config2.loadingDirective} can only be applied on a field or fragment spread at the root of a document or on one whose parent also has @${config2.loadingDirective}`
             )
           );
@@ -78105,7 +78014,7 @@ function getAndVerifyNodeInterface(config2) {
   if (!nodeInterface) {
     return null;
   }
-  if (!graphql30.isInterfaceType(nodeInterface)) {
+  if (!graphql29.isInterfaceType(nodeInterface)) {
     displayInvalidNodeFieldMessage(config2);
     return null;
   }
@@ -78200,11 +78109,11 @@ async function uniqueDocumentNames(config2, docs) {
 }
 
 // src/codegen/validators/noIDAlias.ts
-var graphql31 = __toESM(require("graphql"), 1);
+var graphql30 = __toESM(require("graphql"), 1);
 async function noIDAlias(config2, docs) {
   const errors = [];
   for (const { filename, document } of docs) {
-    graphql31.visit(document, {
+    graphql30.visit(document, {
       Field(node, _, __, ___, ancestors) {
         const fieldType = parentTypeFromAncestors(config2.schema, filename, ancestors).name;
         if (config2.keyFieldsForType(fieldType).includes(node.alias?.value || "")) {
@@ -78243,11 +78152,11 @@ async function validatePlugins(config2, documents) {
 }
 
 // src/codegen/validators/componentFields.ts
-var graphql32 = __toESM(require("graphql"), 1);
+var graphql31 = __toESM(require("graphql"), 1);
 async function componentFields2(config2, docs) {
   const errors = [];
   for (const { filename: filepath, document } of docs) {
-    graphql32.visit(document, {
+    graphql31.visit(document, {
       FragmentDefinition(node, _, __, ___, ancestors) {
         const componentFieldDirective = node.directives?.find(
           (dir) => dir.name.value === config2.componentFieldDirective
@@ -78295,7 +78204,7 @@ async function componentFields2(config2, docs) {
         if (existingField && existingField.filepath !== filepath) {
           conflict = true;
         } else if (parentType && fieldValue) {
-          const fieldDef = graphql32.isObjectType(parentType) && parentType.getFields()[fieldValue];
+          const fieldDef = graphql31.isObjectType(parentType) && parentType.getFields()[fieldValue];
           if (fieldDef && !fieldDef.astNode?.directives?.find(
             (dir) => dir.name.value === config2.componentFieldDirective
           )) {
@@ -78308,7 +78217,7 @@ async function componentFields2(config2, docs) {
             filepath
           });
         }
-        if (parentType && graphql32.isAbstractType(parentType)) {
+        if (parentType && graphql31.isAbstractType(parentType)) {
           errors.push({
             message: `Cannot add component field ${parent2}.${fieldValue} because ${parent2} is an abstract type`,
             filepath
@@ -78529,12 +78438,12 @@ async function processJSFile(config2, contents) {
   return documents;
 }
 async function processGraphQLDocument(config2, filepath, document) {
-  const parsedDoc = graphql33.parse(document);
+  const parsedDoc = graphql32.parse(document);
   const operations = parsedDoc.definitions.filter(
-    ({ kind: kind2 }) => kind2 === graphql33.Kind.OPERATION_DEFINITION
+    ({ kind: kind2 }) => kind2 === graphql32.Kind.OPERATION_DEFINITION
   );
   const fragments = parsedDoc.definitions.filter(
-    ({ kind: kind2 }) => kind2 === graphql33.Kind.FRAGMENT_DEFINITION
+    ({ kind: kind2 }) => kind2 === graphql32.Kind.FRAGMENT_DEFINITION
   );
   if (operations.length > 1) {
     throw new HoudiniError({