houdini 1.5.3 → 1.5.4

package/build/codegen-cjs/index.js

@@ -52330,7 +52330,7 @@ async function runPipeline(config, pipeline, target) {
 }
 
 // src/lib/config.ts
-var graphql4 = __toESM(require("graphql"), 1);
+var graphql5 = __toESM(require("graphql"), 1);
 var import_minimatch8 = __toESM(require_minimatch(), 1);
 var import_node_url3 = require("node:url");
 
@@ -58235,10 +58235,219 @@ var graphql = __toESM(require("graphql"), 1);
 
 // src/lib/router/manifest.ts
 var t = __toESM(require_lib5(), 1);
+var graphql3 = __toESM(require("graphql"), 1);
+
+// src/lib/graphql.ts
 var graphql2 = __toESM(require("graphql"), 1);
+var import_node_crypto = __toESM(require("node:crypto"), 1);
+function getRootType(type) {
+  if (graphql2.isNonNullType(type)) {
+    return getRootType(type.ofType);
+  }
+  if (graphql2.isListType(type)) {
+    return getRootType(type.ofType);
+  }
+  return type;
+}
+function hashOriginal({ document }) {
+  return hashDocument(document.originalString);
+}
+function hashRaw({ document }) {
+  return hashDocument(document.artifact?.raw);
+}
+function hashDocument(str) {
+  return import_node_crypto.default.createHash("sha256").update(str || "").digest("hex");
+}
+function parentField(ancestors) {
+  return walkParentField([...ancestors].sort(() => -1));
+}
+function walkParentField(ancestors) {
+  let head = ancestors.shift();
+  if (Array.isArray(head) || head.kind === "SelectionSet") {
+    return walkParentField(ancestors);
+  }
+  return head;
+}
+function parentTypeFromAncestors(schema, filepath, ancestors) {
+  const parents = [...ancestors];
+  parents.reverse();
+  return walkAncestors(schema, filepath, parents);
+}
+function walkAncestors(schema, filepath, ancestors) {
+  let head = ancestors.shift();
+  if (Array.isArray(head)) {
+    return walkAncestors(schema, filepath, ancestors);
+  }
+  if (!head) {
+    throw new HoudiniError({ filepath, message: "Could not figure out type of field" });
+  }
+  if (head.kind === "OperationDefinition") {
+    const operationType = {
+      query: schema.getQueryType(),
+      mutation: schema.getMutationType(),
+      subscription: schema.getSubscriptionType()
+    }[head.operation];
+    if (!operationType) {
+      throw new HoudiniError({ filepath, message: "Could not find operation type" });
+    }
+    return operationType;
+  }
+  if (head.kind === "FragmentDefinition") {
+    const result = schema.getType(head.typeCondition.name.value);
+    if (!result) {
+      throw new HoudiniError({
+        filepath,
+        message: `Could not find definition for ${head.typeCondition.name.value} in the schema`
+      });
+    }
+    return result;
+  }
+  if (head.kind === "FragmentSpread") {
+    throw new Error("How the hell did this happen?");
+  }
+  const parent2 = walkAncestors(schema, filepath, ancestors);
+  if (head.kind === "InlineFragment") {
+    if (!head.typeCondition) {
+      return parent2;
+    }
+    const wrapper = schema.getType(head.typeCondition.name.value);
+    if (!wrapper) {
+      throw new HoudiniError({
+        filepath,
+        message: "Could not find type with name: " + head.typeCondition.name.value
+      });
+    }
+    return wrapper;
+  }
+  if (head.kind === "SelectionSet") {
+    return parent2;
+  }
+  const field = parent2.getFields()[head.name.value];
+  if (!field) {
+    throw new HoudiniError({
+      filepath,
+      message: `Could not find definition of ${head.name.value} in ${parent2.toString()}`
+    });
+  }
+  return getRootType(field.type);
+}
+function definitionFromAncestors(ancestors) {
+  let parents = [...ancestors];
+  parents.shift();
+  let definition = parents.shift();
+  while (Array.isArray(definition) && definition) {
+    definition = parents.shift();
+  }
+  return { parents, definition };
+}
+function unwrapType(config, type, wrappers = [], convertRuntimeScalars) {
+  if (type.kind === "NonNullType") {
+    return unwrapType(config, type.type, [TypeWrapper.NonNull, ...wrappers]);
+  }
+  if (type instanceof graphql2.GraphQLNonNull) {
+    return unwrapType(config, type.ofType, [TypeWrapper.NonNull, ...wrappers]);
+  }
+  if (wrappers[0] !== TypeWrapper.NonNull) {
+    wrappers.unshift(TypeWrapper.Nullable);
+  }
+  if (type.kind === "ListType") {
+    return unwrapType(config, type.type, [TypeWrapper.List, ...wrappers]);
+  }
+  if (type instanceof graphql2.GraphQLList) {
+    return unwrapType(config, type.ofType, [TypeWrapper.List, ...wrappers]);
+  }
+  if (convertRuntimeScalars && config.configFile.features?.runtimeScalars?.[type.name.value]) {
+    type = config.schema.getType(
+      config.configFile.features?.runtimeScalars?.[type.name.value].type
+    );
+  }
+  const namedType = config.schema.getType(type.name.value || type.name);
+  if (!namedType) {
+    throw new Error("Unknown type: " + type.name.value || type.name);
+  }
+  return { type: namedType, wrappers };
+}
+function wrapType({
+  type,
+  wrappers
+}) {
+  const head = wrappers[0];
+  const tail = wrappers.slice(1);
+  let kind = graphql2.Kind.NAMED_TYPE;
+  if (head === TypeWrapper.List) {
+    kind = graphql2.Kind.LIST_TYPE;
+  } else if (head === TypeWrapper.NonNull) {
+    kind = graphql2.Kind.NON_NULL_TYPE;
+  }
+  if (kind === "NamedType") {
+    return {
+      kind,
+      name: {
+        kind: graphql2.Kind.NAME,
+        value: type.name
+      }
+    };
+  }
+  return {
+    kind,
+    type: wrapType({ type, wrappers: tail })
+  };
+}
+var TypeWrapper = /* @__PURE__ */ ((TypeWrapper2) => {
+  TypeWrapper2["Nullable"] = "Nullable";
+  TypeWrapper2["List"] = "List";
+  TypeWrapper2["NonNull"] = "NonNull";
+  return TypeWrapper2;
+})(TypeWrapper || {});
+
+// src/lib/parse.ts
+var import_parser = __toESM(require_lib6(), 1);
+var import_recast = __toESM(require_main2(), 1);
+
+// src/lib/deepMerge.ts
+var import_deepmerge = __toESM(require_cjs(), 1);
+function deepMerge2(filepath, ...targets) {
+  try {
+    if (targets.length === 1) {
+      return targets[0];
+    } else if (targets.length === 2) {
+      return (0, import_deepmerge.default)(targets[0], targets[1], {
+        arrayMerge: (source, update) => [...new Set(source.concat(update))]
+      });
+    }
+    return deepMerge2(filepath, targets[0], deepMerge2(filepath, ...targets.slice(1)));
+  } catch (e) {
+    throw new HoudiniError({
+      filepath,
+      message: "could not merge: " + JSON.stringify(targets, null, 4),
+      description: e.message
+    });
+  }
+}
+
+// src/lib/parse.ts
+function parseJS(str, config) {
+  const defaultConfig = {
+    plugins: [
+      "typescript",
+      "importAssertions",
+      "decorators-legacy",
+      "explicitResourceManagement"
+    ],
+    sourceType: "module"
+  };
+  return (0, import_parser.parse)(str || "", config ? deepMerge2("", defaultConfig, config) : defaultConfig).program;
+}
+async function printJS(script, options) {
+  if (options?.pretty) {
+    return (0, import_recast.prettyPrint)(script, options);
+  } else {
+    return (0, import_recast.print)(script, options);
+  }
+}
 
 // src/lib/router/server.ts
-var graphql3 = __toESM(require("graphql"), 1);
+var graphql4 = __toESM(require("graphql"), 1);
 
 // src/runtime/lib/flatten.ts
 function flatten(source) {
@@ -60583,218 +60792,9 @@ var LogLevel = {
 var import_meta = {};
 var currentDir = dirname((0, import_node_url3.fileURLToPath)(import_meta.url));
 var DEFAULT_CONFIG_PATH = join(process.cwd(), "houdini.config.js");
-var emptySchema = graphql4.buildSchema("type Query { hello: String }");
+var emptySchema = graphql5.buildSchema("type Query { hello: String }");
 var defaultDirectives = emptySchema.getDirectives().map((dir) => dir.name);
 
-// src/lib/graphql.ts
-var graphql5 = __toESM(require("graphql"), 1);
-var import_node_crypto = __toESM(require("node:crypto"), 1);
-function getRootType(type) {
-  if (graphql5.isNonNullType(type)) {
-    return getRootType(type.ofType);
-  }
-  if (graphql5.isListType(type)) {
-    return getRootType(type.ofType);
-  }
-  return type;
-}
-function hashOriginal({ document }) {
-  return hashDocument(document.originalString);
-}
-function hashRaw({ document }) {
-  return hashDocument(document.artifact?.raw);
-}
-function hashDocument(str) {
-  return import_node_crypto.default.createHash("sha256").update(str || "").digest("hex");
-}
-function parentField(ancestors) {
-  return walkParentField([...ancestors].sort(() => -1));
-}
-function walkParentField(ancestors) {
-  let head = ancestors.shift();
-  if (Array.isArray(head) || head.kind === "SelectionSet") {
-    return walkParentField(ancestors);
-  }
-  return head;
-}
-function parentTypeFromAncestors(schema, filepath, ancestors) {
-  const parents = [...ancestors];
-  parents.reverse();
-  return walkAncestors(schema, filepath, parents);
-}
-function walkAncestors(schema, filepath, ancestors) {
-  let head = ancestors.shift();
-  if (Array.isArray(head)) {
-    return walkAncestors(schema, filepath, ancestors);
-  }
-  if (!head) {
-    throw new HoudiniError({ filepath, message: "Could not figure out type of field" });
-  }
-  if (head.kind === "OperationDefinition") {
-    const operationType = {
-      query: schema.getQueryType(),
-      mutation: schema.getMutationType(),
-      subscription: schema.getSubscriptionType()
-    }[head.operation];
-    if (!operationType) {
-      throw new HoudiniError({ filepath, message: "Could not find operation type" });
-    }
-    return operationType;
-  }
-  if (head.kind === "FragmentDefinition") {
-    const result = schema.getType(head.typeCondition.name.value);
-    if (!result) {
-      throw new HoudiniError({
-        filepath,
-        message: `Could not find definition for ${head.typeCondition.name.value} in the schema`
-      });
-    }
-    return result;
-  }
-  if (head.kind === "FragmentSpread") {
-    throw new Error("How the hell did this happen?");
-  }
-  const parent2 = walkAncestors(schema, filepath, ancestors);
-  if (head.kind === "InlineFragment") {
-    if (!head.typeCondition) {
-      return parent2;
-    }
-    const wrapper = schema.getType(head.typeCondition.name.value);
-    if (!wrapper) {
-      throw new HoudiniError({
-        filepath,
-        message: "Could not find type with name: " + head.typeCondition.name.value
-      });
-    }
-    return wrapper;
-  }
-  if (head.kind === "SelectionSet") {
-    return parent2;
-  }
-  const field = parent2.getFields()[head.name.value];
-  if (!field) {
-    throw new HoudiniError({
-      filepath,
-      message: `Could not find definition of ${head.name.value} in ${parent2.toString()}`
-    });
-  }
-  return getRootType(field.type);
-}
-function definitionFromAncestors(ancestors) {
-  let parents = [...ancestors];
-  parents.shift();
-  let definition = parents.shift();
-  while (Array.isArray(definition) && definition) {
-    definition = parents.shift();
-  }
-  return { parents, definition };
-}
-function unwrapType(config, type, wrappers = [], convertRuntimeScalars) {
-  if (type.kind === "NonNullType") {
-    return unwrapType(config, type.type, [TypeWrapper.NonNull, ...wrappers]);
-  }
-  if (type instanceof graphql5.GraphQLNonNull) {
-    return unwrapType(config, type.ofType, [TypeWrapper.NonNull, ...wrappers]);
-  }
-  if (wrappers[0] !== TypeWrapper.NonNull) {
-    wrappers.unshift(TypeWrapper.Nullable);
-  }
-  if (type.kind === "ListType") {
-    return unwrapType(config, type.type, [TypeWrapper.List, ...wrappers]);
-  }
-  if (type instanceof graphql5.GraphQLList) {
-    return unwrapType(config, type.ofType, [TypeWrapper.List, ...wrappers]);
-  }
-  if (convertRuntimeScalars && config.configFile.features?.runtimeScalars?.[type.name.value]) {
-    type = config.schema.getType(
-      config.configFile.features?.runtimeScalars?.[type.name.value].type
-    );
-  }
-  const namedType = config.schema.getType(type.name.value || type.name);
-  if (!namedType) {
-    throw new Error("Unknown type: " + type.name.value || type.name);
-  }
-  return { type: namedType, wrappers };
-}
-function wrapType({
-  type,
-  wrappers
-}) {
-  const head = wrappers[0];
-  const tail = wrappers.slice(1);
-  let kind = graphql5.Kind.NAMED_TYPE;
-  if (head === TypeWrapper.List) {
-    kind = graphql5.Kind.LIST_TYPE;
-  } else if (head === TypeWrapper.NonNull) {
-    kind = graphql5.Kind.NON_NULL_TYPE;
-  }
-  if (kind === "NamedType") {
-    return {
-      kind,
-      name: {
-        kind: graphql5.Kind.NAME,
-        value: type.name
-      }
-    };
-  }
-  return {
-    kind,
-    type: wrapType({ type, wrappers: tail })
-  };
-}
-var TypeWrapper = /* @__PURE__ */ ((TypeWrapper2) => {
-  TypeWrapper2["Nullable"] = "Nullable";
-  TypeWrapper2["List"] = "List";
-  TypeWrapper2["NonNull"] = "NonNull";
-  return TypeWrapper2;
-})(TypeWrapper || {});
-
-// src/lib/parse.ts
-var import_parser = __toESM(require_lib6(), 1);
-var import_recast = __toESM(require_main2(), 1);
-
-// src/lib/deepMerge.ts
-var import_deepmerge = __toESM(require_cjs(), 1);
-function deepMerge2(filepath, ...targets) {
-  try {
-    if (targets.length === 1) {
-      return targets[0];
-    } else if (targets.length === 2) {
-      return (0, import_deepmerge.default)(targets[0], targets[1], {
-        arrayMerge: (source, update) => [...new Set(source.concat(update))]
-      });
-    }
-    return deepMerge2(filepath, targets[0], deepMerge2(filepath, ...targets.slice(1)));
-  } catch (e) {
-    throw new HoudiniError({
-      filepath,
-      message: "could not merge: " + JSON.stringify(targets, null, 4),
-      description: e.message
-    });
-  }
-}
-
-// src/lib/parse.ts
-function parseJS(str, config) {
-  const defaultConfig = {
-    plugins: [
-      "typescript",
-      "importAssertions",
-      "decorators-legacy",
-      "explicitResourceManagement"
-    ],
-    sourceType: "module"
-  };
-  return (0, import_parser.parse)(str || "", config ? deepMerge2("", defaultConfig, config) : defaultConfig).program;
-}
-async function printJS(script, options) {
-  if (options?.pretty) {
-    return (0, import_recast.prettyPrint)(script, options);
-  } else {
-    return (0, import_recast.print)(script, options);
-  }
-}
-
 // src/lib/imports.ts
 var recast = __toESM(require_main2(), 1);
 var AST2 = recast.types.builders;
@@ -60923,18 +60923,18 @@ function scalarPropertyValue(config, filepath, missingScalars, target, body, fie
       return AST3.tsNeverKeyword();
     }
     const component = config.componentFields[field.parent][field.field];
-    const sourcePathRelative = path_exports.relative(
-      path_exports.join(config.projectRoot, "src"),
+    const sourcePathRelative = relative(
+      join(config.projectRoot, "src"),
       component.filepath
     );
-    let sourcePathParsed = path_exports.parse(sourcePathRelative);
-    let sourcePath = path_exports.join(sourcePathParsed.dir, sourcePathParsed.name);
+    let sourcePathParsed = parse(sourcePathRelative);
+    let sourcePath = join(sourcePathParsed.dir, sourcePathParsed.name);
     const localImport = ensureImports({
       config,
       body,
       import: "__component__" + component.fragment,
-      sourceModule: path_exports.join(
-        path_exports.relative(path_exports.dirname(filepath), config.projectRoot),
+      sourceModule: join(
+        relative(dirname(filepath), config.projectRoot),
         "src",
         sourcePath
       )
@@ -61848,12 +61848,12 @@ function stripLoc(value) {
 
 // src/codegen/transforms/collectDefinitions.ts
 var graphql8 = __toESM(require("graphql"), 1);
-var import_graphql2 = require("graphql");
+var import_graphql3 = require("graphql");
 async function includeFragmentDefinitions(config, documents) {
   const fragments = collectDefinitions(config, documents);
   for (const [index, { name, document, filename }] of documents.entries()) {
     const operation = document.definitions.find(
-      (def) => def.kind === import_graphql2.Kind.OPERATION_DEFINITION || def.kind === "FragmentDefinition"
+      (def) => def.kind === import_graphql3.Kind.OPERATION_DEFINITION || def.kind === "FragmentDefinition"
     );
     if (!operation) {
       continue;
@@ -63849,6 +63849,16 @@ async function generatePluginIndex({
 }
 
 // src/codegen/generators/runtime/pluginRuntime.ts
+function moduleStatments(config) {
+  const importStatement = config.module === "commonjs" ? importDefaultFrom : (where, as) => `import ${as} from '${where}'`;
+  const exportDefaultStatement = config.module === "commonjs" ? exportDefault : (as) => `export default ${as}`;
+  const exportStarStatement = config.module === "commonjs" ? exportStarFrom : (where) => `export * from '${where}'`;
+  return {
+    importStatement,
+    exportDefaultStatement,
+    exportStarStatement
+  };
+}
 async function generatePluginRuntimes({
   config,
   docs
@@ -63864,7 +63874,7 @@ async function generatePluginRuntimes({
         return;
       }
       try {
-        await fs_exports.stat(runtime_path);
+        await stat(runtime_path);
       } catch {
         throw new HoudiniError({
           message: "Cannot find runtime to generate for " + plugin2.name,
@@ -63876,13 +63886,13 @@ async function generatePluginRuntimes({
       if (transformMap && typeof transformMap === "function") {
         transformMap = transformMap(docs, { config });
       }
-      await fs_exports.mkdirp(pluginDir);
-      await fs_exports.recursiveCopy(
+      await mkdirp(pluginDir);
+      await recursiveCopy(
         runtime_path,
         pluginDir,
         Object.fromEntries(
           Object.entries(transformMap).map(([key, value]) => [
-            path_exports.join(runtime_path, key),
+            join(runtime_path, key),
             (content) => value({
               config,
               content,
@@ -63929,21 +63939,21 @@ async function runtimeGenerator(config, docs) {
     exportStarStatement: exportStar
   } = moduleStatments(config);
   await Promise.all([
-    fs_exports.recursiveCopy(config.runtimeSource, config.runtimeDirectory, {
-      [path_exports.join(config.runtimeSource, "lib", "constants.js")]: (content) => {
+    recursiveCopy(config.runtimeSource, config.runtimeDirectory, {
+      [join(config.runtimeSource, "lib", "constants.js")]: (content) => {
         return content.replace("SITE_URL", siteURL);
       },
-      [path_exports.join(config.runtimeSource, "imports", "pluginConfig.js")]: (content) => {
+      [join(config.runtimeSource, "imports", "pluginConfig.js")]: (content) => {
         return injectConfig({ config, importStatement, exportStatement, content });
       },
-      [path_exports.join(config.runtimeSource, "imports", "config.js")]: (content) => {
-        const configFilePath = path_exports.join(config.runtimeDirectory, "imports", "config.js");
-        const relativePath = path_exports.relative(path_exports.dirname(configFilePath), config.filepath);
+      [join(config.runtimeSource, "imports", "config.js")]: (content) => {
+        const configFilePath = join(config.runtimeDirectory, "imports", "config.js");
+        const relativePath = relative(dirname(configFilePath), config.filepath);
         return `${importStatement(relativePath, "config")}
 ${exportStatement("config")}
 `;
       },
-      [path_exports.join(config.runtimeSource, "client", "plugins", "injectedPlugins.js")]: (content) => injectPlugins({ config, content, importStatement, exportStatement })
+      [join(config.runtimeSource, "client", "plugins", "injectedPlugins.js")]: (content) => injectPlugins({ config, content, importStatement, exportStatement })
     }),
     generatePluginRuntimes({
       config,
@@ -63953,16 +63963,6 @@ ${exportStatement("config")}
   ]);
   await generateGraphqlReturnTypes(config, docs);
 }
-function moduleStatments(config) {
-  const importStatement = config.module === "commonjs" ? importDefaultFrom : (where, as) => `import ${as} from '${where}'`;
-  const exportDefaultStatement = config.module === "commonjs" ? exportDefault : (as) => `export default ${as}`;
-  const exportStarStatement = config.module === "commonjs" ? exportStarFrom : (where) => `export * from '${where}'`;
-  return {
-    importStatement,
-    exportDefaultStatement,
-    exportStarStatement
-  };
-}
 
 // src/codegen/generators/typescript/documentTypes.ts
 var recast11 = __toESM(require_main2(), 1);
@@ -65445,7 +65445,7 @@ async function writeIndexFile2(config, docs) {
 }
 
 // ../../node_modules/.pnpm/@graphql-tools+utils@10.0.6_graphql@15.5.0/node_modules/@graphql-tools/utils/esm/helpers.js
-var import_graphql3 = require("graphql");
+var import_graphql4 = require("graphql");
 function compareStrings(a, b) {
   if (String(a) < String(b)) {
     return -1;
@@ -65481,7 +65481,7 @@ function isSome(input) {
 }
 
 // ../../node_modules/.pnpm/@graphql-tools+utils@10.0.6_graphql@15.5.0/node_modules/@graphql-tools/utils/esm/inspect.js
-var import_graphql4 = require("graphql");
+var import_graphql5 = require("graphql");
 var MAX_RECURSIVE_DEPTH = 3;
 function inspect(value) {
   return formatValue(value, []);
@@ -65499,7 +65499,7 @@ function formatValue(value, seenValues) {
   }
 }
 function formatError(value) {
-  if (value instanceof import_graphql4.GraphQLError) {
+  if (value instanceof import_graphql5.GraphQLError) {
     return value.toString();
   }
   return `${value.name}: ${value.message};
@@ -65582,43 +65582,43 @@ function getDirectivesInExtensions(node, pathToDirectivesInExtensions = ["direct
 }
 
 // ../../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_graphql8 = require("graphql");
+var import_graphql9 = 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_graphql5 = require("graphql");
+var import_graphql6 = require("graphql");
 function astFromType(type) {
-  if ((0, import_graphql5.isNonNullType)(type)) {
+  if ((0, import_graphql6.isNonNullType)(type)) {
     const innerType = astFromType(type.ofType);
-    if (innerType.kind === import_graphql5.Kind.NON_NULL_TYPE) {
+    if (innerType.kind === import_graphql6.Kind.NON_NULL_TYPE) {
       throw new Error(`Invalid type node ${inspect(type)}. Inner type of non-null type cannot be a non-null type.`);
     }
     return {
-      kind: import_graphql5.Kind.NON_NULL_TYPE,
+      kind: import_graphql6.Kind.NON_NULL_TYPE,
       type: innerType
     };
-  } else if ((0, import_graphql5.isListType)(type)) {
+  } else if ((0, import_graphql6.isListType)(type)) {
     return {
-      kind: import_graphql5.Kind.LIST_TYPE,
+      kind: import_graphql6.Kind.LIST_TYPE,
       type: astFromType(type.ofType)
     };
   }
   return {
-    kind: import_graphql5.Kind.NAMED_TYPE,
+    kind: import_graphql6.Kind.NAMED_TYPE,
     name: {
-      kind: import_graphql5.Kind.NAME,
+      kind: import_graphql6.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_graphql7 = require("graphql");
+var import_graphql8 = 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_graphql6 = require("graphql");
+var import_graphql7 = require("graphql");
 function astFromValueUntyped(value) {
   if (value === null) {
-    return { kind: import_graphql6.Kind.NULL };
+    return { kind: import_graphql7.Kind.NULL };
   }
   if (value === void 0) {
     return null;
@@ -65631,7 +65631,7 @@ function astFromValueUntyped(value) {
         valuesNodes.push(itemNode);
       }
     }
-    return { kind: import_graphql6.Kind.LIST, values: valuesNodes };
+    return { kind: import_graphql7.Kind.LIST, values: valuesNodes };
   }
   if (typeof value === "object") {
     const fieldNodes = [];
@@ -65640,26 +65640,26 @@ function astFromValueUntyped(value) {
       const ast = astFromValueUntyped(fieldValue);
       if (ast) {
         fieldNodes.push({
-          kind: import_graphql6.Kind.OBJECT_FIELD,
-          name: { kind: import_graphql6.Kind.NAME, value: fieldName },
+          kind: import_graphql7.Kind.OBJECT_FIELD,
+          name: { kind: import_graphql7.Kind.NAME, value: fieldName },
           value: ast
         });
       }
     }
-    return { kind: import_graphql6.Kind.OBJECT, fields: fieldNodes };
+    return { kind: import_graphql7.Kind.OBJECT, fields: fieldNodes };
   }
   if (typeof value === "boolean") {
-    return { kind: import_graphql6.Kind.BOOLEAN, value };
+    return { kind: import_graphql7.Kind.BOOLEAN, value };
   }
   if (typeof value === "bigint") {
-    return { kind: import_graphql6.Kind.INT, value: String(value) };
+    return { kind: import_graphql7.Kind.INT, value: String(value) };
   }
   if (typeof value === "number" && isFinite(value)) {
     const stringNum = String(value);
-    return integerStringRegExp.test(stringNum) ? { kind: import_graphql6.Kind.INT, value: stringNum } : { kind: import_graphql6.Kind.FLOAT, value: stringNum };
+    return integerStringRegExp.test(stringNum) ? { kind: import_graphql7.Kind.INT, value: stringNum } : { kind: import_graphql7.Kind.FLOAT, value: stringNum };
   }
   if (typeof value === "string") {
-    return { kind: import_graphql6.Kind.STRING, value };
+    return { kind: import_graphql7.Kind.STRING, value };
   }
   throw new TypeError(`Cannot convert value to AST: ${value}.`);
 }
@@ -65667,20 +65667,20 @@ var integerStringRegExp = /^-?(?: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 astFromValue(value, type) {
-  if ((0, import_graphql7.isNonNullType)(type)) {
+  if ((0, import_graphql8.isNonNullType)(type)) {
     const astValue = astFromValue(value, type.ofType);
-    if (astValue?.kind === import_graphql7.Kind.NULL) {
+    if (astValue?.kind === import_graphql8.Kind.NULL) {
       return null;
     }
     return astValue;
   }
   if (value === null) {
-    return { kind: import_graphql7.Kind.NULL };
+    return { kind: import_graphql8.Kind.NULL };
   }
   if (value === void 0) {
     return null;
   }
-  if ((0, import_graphql7.isListType)(type)) {
+  if ((0, import_graphql8.isListType)(type)) {
     const itemType = type.ofType;
     if (isIterableObject(value)) {
       const valuesNodes = [];
@@ -65690,11 +65690,11 @@ function astFromValue(value, type) {
           valuesNodes.push(itemNode);
         }
       }
-      return { kind: import_graphql7.Kind.LIST, values: valuesNodes };
+      return { kind: import_graphql8.Kind.LIST, values: valuesNodes };
     }
     return astFromValue(value, itemType);
   }
-  if ((0, import_graphql7.isInputObjectType)(type)) {
+  if ((0, import_graphql8.isInputObjectType)(type)) {
     if (!isObjectLike(value)) {
       return null;
     }
@@ -65703,24 +65703,24 @@ function astFromValue(value, type) {
       const fieldValue = astFromValue(value[field.name], field.type);
       if (fieldValue) {
         fieldNodes.push({
-          kind: import_graphql7.Kind.OBJECT_FIELD,
-          name: { kind: import_graphql7.Kind.NAME, value: field.name },
+          kind: import_graphql8.Kind.OBJECT_FIELD,
+          name: { kind: import_graphql8.Kind.NAME, value: field.name },
           value: fieldValue
         });
       }
     }
-    return { kind: import_graphql7.Kind.OBJECT, fields: fieldNodes };
+    return { kind: import_graphql8.Kind.OBJECT, fields: fieldNodes };
   }
-  if ((0, import_graphql7.isLeafType)(type)) {
+  if ((0, import_graphql8.isLeafType)(type)) {
     const serialized = type.serialize(value);
     if (serialized == null) {
       return null;
     }
-    if ((0, import_graphql7.isEnumType)(type)) {
-      return { kind: import_graphql7.Kind.ENUM, value: serialized };
+    if ((0, import_graphql8.isEnumType)(type)) {
+      return { kind: import_graphql8.Kind.ENUM, value: serialized };
     }
     if (type.name === "ID" && typeof serialized === "string" && integerStringRegExp2.test(serialized)) {
-      return { kind: import_graphql7.Kind.INT, value: serialized };
+      return { kind: import_graphql8.Kind.INT, value: serialized };
     }
     return astFromValueUntyped(serialized);
   }
@@ -65776,36 +65776,36 @@ function getDocumentNodeFromSchema(schema, options = {}) {
   const definitions = schemaNode != null ? [schemaNode] : [];
   const directives = schema.getDirectives();
   for (const directive of directives) {
-    if ((0, import_graphql8.isSpecifiedDirective)(directive)) {
+    if ((0, import_graphql9.isSpecifiedDirective)(directive)) {
       continue;
     }
     definitions.push(astFromDirective(directive, schema, pathToDirectivesInExtensions));
   }
   for (const typeName in typesMap) {
     const type = typesMap[typeName];
-    const isPredefinedScalar = (0, import_graphql8.isSpecifiedScalarType)(type);
-    const isIntrospection = (0, import_graphql8.isIntrospectionType)(type);
+    const isPredefinedScalar = (0, import_graphql9.isSpecifiedScalarType)(type);
+    const isIntrospection = (0, import_graphql9.isIntrospectionType)(type);
     if (isPredefinedScalar || isIntrospection) {
       continue;
     }
-    if ((0, import_graphql8.isObjectType)(type)) {
+    if ((0, import_graphql9.isObjectType)(type)) {
       definitions.push(astFromObjectType(type, schema, pathToDirectivesInExtensions));
-    } else if ((0, import_graphql8.isInterfaceType)(type)) {
+    } else if ((0, import_graphql9.isInterfaceType)(type)) {
       definitions.push(astFromInterfaceType(type, schema, pathToDirectivesInExtensions));
-    } else if ((0, import_graphql8.isUnionType)(type)) {
+    } else if ((0, import_graphql9.isUnionType)(type)) {
       definitions.push(astFromUnionType(type, schema, pathToDirectivesInExtensions));
-    } else if ((0, import_graphql8.isInputObjectType)(type)) {
+    } else if ((0, import_graphql9.isInputObjectType)(type)) {
       definitions.push(astFromInputObjectType(type, schema, pathToDirectivesInExtensions));
-    } else if ((0, import_graphql8.isEnumType)(type)) {
+    } else if ((0, import_graphql9.isEnumType)(type)) {
       definitions.push(astFromEnumType(type, schema, pathToDirectivesInExtensions));
-    } else if ((0, import_graphql8.isScalarType)(type)) {
+    } else if ((0, import_graphql9.isScalarType)(type)) {
       definitions.push(astFromScalarType(type, schema, pathToDirectivesInExtensions));
     } else {
       throw new Error(`Unknown type ${type}.`);
     }
   }
   return {
-    kind: import_graphql8.Kind.DOCUMENT,
+    kind: import_graphql9.Kind.DOCUMENT,
     definitions
   };
 }
@@ -65840,7 +65840,7 @@ function astFromSchema(schema, pathToDirectivesInExtensions) {
         operationTypeDefinitionNode.type = rootTypeAST;
       } else {
         operationTypeMap.set(operationTypeNode, {
-          kind: import_graphql8.Kind.OPERATION_TYPE_DEFINITION,
+          kind: import_graphql9.Kind.OPERATION_TYPE_DEFINITION,
           operation: operationTypeNode,
           type: rootTypeAST
         });
@@ -65853,12 +65853,12 @@ function astFromSchema(schema, pathToDirectivesInExtensions) {
     return null;
   }
   const schemaNode = {
-    kind: operationTypes != null ? import_graphql8.Kind.SCHEMA_DEFINITION : import_graphql8.Kind.SCHEMA_EXTENSION,
+    kind: operationTypes != null ? import_graphql9.Kind.SCHEMA_DEFINITION : import_graphql9.Kind.SCHEMA_EXTENSION,
     operationTypes,
     directives
   };
   schemaNode.description = schema.astNode?.description ?? schema.description != null ? {
-    kind: import_graphql8.Kind.STRING,
+    kind: import_graphql9.Kind.STRING,
     value: schema.description,
     block: true
   } : void 0;
@@ -65866,19 +65866,19 @@ function astFromSchema(schema, pathToDirectivesInExtensions) {
 }
 function astFromDirective(directive, schema, pathToDirectivesInExtensions) {
   return {
-    kind: import_graphql8.Kind.DIRECTIVE_DEFINITION,
+    kind: import_graphql9.Kind.DIRECTIVE_DEFINITION,
     description: directive.astNode?.description ?? (directive.description ? {
-      kind: import_graphql8.Kind.STRING,
+      kind: import_graphql9.Kind.STRING,
       value: directive.description
     } : void 0),
     name: {
-      kind: import_graphql8.Kind.NAME,
+      kind: import_graphql9.Kind.NAME,
       value: directive.name
     },
     arguments: directive.args?.map((arg) => astFromArg(arg, schema, pathToDirectivesInExtensions)),
     repeatable: directive.isRepeatable,
     locations: directive.locations?.map((location) => ({
-      kind: import_graphql8.Kind.NAME,
+      kind: import_graphql9.Kind.NAME,
       value: location
     })) || []
   };
@@ -65928,14 +65928,14 @@ function getDeprecatableDirectiveNodes(entity, schema, pathToDirectivesInExtensi
 }
 function astFromArg(arg, schema, pathToDirectivesInExtensions) {
   return {
-    kind: import_graphql8.Kind.INPUT_VALUE_DEFINITION,
+    kind: import_graphql9.Kind.INPUT_VALUE_DEFINITION,
     description: arg.astNode?.description ?? (arg.description ? {
-      kind: import_graphql8.Kind.STRING,
+      kind: import_graphql9.Kind.STRING,
       value: arg.description,
       block: true
     } : void 0),
     name: {
-      kind: import_graphql8.Kind.NAME,
+      kind: import_graphql9.Kind.NAME,
       value: arg.name
     },
     type: astFromType(arg.type),
@@ -65945,14 +65945,14 @@ function astFromArg(arg, schema, pathToDirectivesInExtensions) {
 }
 function astFromObjectType(type, schema, pathToDirectivesInExtensions) {
   return {
-    kind: import_graphql8.Kind.OBJECT_TYPE_DEFINITION,
+    kind: import_graphql9.Kind.OBJECT_TYPE_DEFINITION,
     description: type.astNode?.description ?? (type.description ? {
-      kind: import_graphql8.Kind.STRING,
+      kind: import_graphql9.Kind.STRING,
       value: type.description,
       block: true
     } : void 0),
     name: {
-      kind: import_graphql8.Kind.NAME,
+      kind: import_graphql9.Kind.NAME,
       value: type.name
     },
     fields: Object.values(type.getFields()).map((field) => astFromField(field, schema, pathToDirectivesInExtensions)),
@@ -65962,14 +65962,14 @@ function astFromObjectType(type, schema, pathToDirectivesInExtensions) {
 }
 function astFromInterfaceType(type, schema, pathToDirectivesInExtensions) {
   const node = {
-    kind: import_graphql8.Kind.INTERFACE_TYPE_DEFINITION,
+    kind: import_graphql9.Kind.INTERFACE_TYPE_DEFINITION,
     description: type.astNode?.description ?? (type.description ? {
-      kind: import_graphql8.Kind.STRING,
+      kind: import_graphql9.Kind.STRING,
       value: type.description,
       block: true
     } : void 0),
     name: {
-      kind: import_graphql8.Kind.NAME,
+      kind: import_graphql9.Kind.NAME,
       value: type.name
     },
     fields: Object.values(type.getFields()).map((field) => astFromField(field, schema, pathToDirectivesInExtensions)),
@@ -65982,14 +65982,14 @@ function astFromInterfaceType(type, schema, pathToDirectivesInExtensions) {
 }
 function astFromUnionType(type, schema, pathToDirectivesInExtensions) {
   return {
-    kind: import_graphql8.Kind.UNION_TYPE_DEFINITION,
+    kind: import_graphql9.Kind.UNION_TYPE_DEFINITION,
     description: type.astNode?.description ?? (type.description ? {
-      kind: import_graphql8.Kind.STRING,
+      kind: import_graphql9.Kind.STRING,
       value: type.description,
       block: true
     } : void 0),
     name: {
-      kind: import_graphql8.Kind.NAME,
+      kind: import_graphql9.Kind.NAME,
       value: type.name
     },
     directives: getDirectiveNodes(type, schema, pathToDirectivesInExtensions),
@@ -65998,14 +65998,14 @@ function astFromUnionType(type, schema, pathToDirectivesInExtensions) {
 }
 function astFromInputObjectType(type, schema, pathToDirectivesInExtensions) {
   return {
-    kind: import_graphql8.Kind.INPUT_OBJECT_TYPE_DEFINITION,
+    kind: import_graphql9.Kind.INPUT_OBJECT_TYPE_DEFINITION,
     description: type.astNode?.description ?? (type.description ? {
-      kind: import_graphql8.Kind.STRING,
+      kind: import_graphql9.Kind.STRING,
       value: type.description,
       block: true
     } : void 0),
     name: {
-      kind: import_graphql8.Kind.NAME,
+      kind: import_graphql9.Kind.NAME,
       value: type.name
     },
     fields: Object.values(type.getFields()).map((field) => astFromInputField(field, schema, pathToDirectivesInExtensions)),
@@ -66014,14 +66014,14 @@ function astFromInputObjectType(type, schema, pathToDirectivesInExtensions) {
 }
 function astFromEnumType(type, schema, pathToDirectivesInExtensions) {
   return {
-    kind: import_graphql8.Kind.ENUM_TYPE_DEFINITION,
+    kind: import_graphql9.Kind.ENUM_TYPE_DEFINITION,
     description: type.astNode?.description ?? (type.description ? {
-      kind: import_graphql8.Kind.STRING,
+      kind: import_graphql9.Kind.STRING,
       value: type.description,
       block: true
     } : void 0),
     name: {
-      kind: import_graphql8.Kind.NAME,
+      kind: import_graphql9.Kind.NAME,
       value: type.name
     },
     values: Object.values(type.getValues()).map((value) => astFromEnumValue(value, schema, pathToDirectivesInExtensions)),
@@ -66039,14 +66039,14 @@ function astFromScalarType(type, schema, pathToDirectivesInExtensions) {
     directives.push(makeDirectiveNode("specifiedBy", specifiedByArgs));
   }
   return {
-    kind: import_graphql8.Kind.SCALAR_TYPE_DEFINITION,
+    kind: import_graphql9.Kind.SCALAR_TYPE_DEFINITION,
     description: type.astNode?.description ?? (type.description ? {
-      kind: import_graphql8.Kind.STRING,
+      kind: import_graphql9.Kind.STRING,
       value: type.description,
       block: true
     } : void 0),
     name: {
-      kind: import_graphql8.Kind.NAME,
+      kind: import_graphql9.Kind.NAME,
       value: type.name
     },
     directives
@@ -66054,14 +66054,14 @@ function astFromScalarType(type, schema, pathToDirectivesInExtensions) {
 }
 function astFromField(field, schema, pathToDirectivesInExtensions) {
   return {
-    kind: import_graphql8.Kind.FIELD_DEFINITION,
+    kind: import_graphql9.Kind.FIELD_DEFINITION,
     description: field.astNode?.description ?? (field.description ? {
-      kind: import_graphql8.Kind.STRING,
+      kind: import_graphql9.Kind.STRING,
       value: field.description,
       block: true
     } : void 0),
     name: {
-      kind: import_graphql8.Kind.NAME,
+      kind: import_graphql9.Kind.NAME,
       value: field.name
     },
     arguments: field.args.map((arg) => astFromArg(arg, schema, pathToDirectivesInExtensions)),
@@ -66071,14 +66071,14 @@ function astFromField(field, schema, pathToDirectivesInExtensions) {
 }
 function astFromInputField(field, schema, pathToDirectivesInExtensions) {
   return {
-    kind: import_graphql8.Kind.INPUT_VALUE_DEFINITION,
+    kind: import_graphql9.Kind.INPUT_VALUE_DEFINITION,
     description: field.astNode?.description ?? (field.description ? {
-      kind: import_graphql8.Kind.STRING,
+      kind: import_graphql9.Kind.STRING,
       value: field.description,
       block: true
     } : void 0),
     name: {
-      kind: import_graphql8.Kind.NAME,
+      kind: import_graphql9.Kind.NAME,
       value: field.name
     },
     type: astFromType(field.type),
@@ -66088,21 +66088,21 @@ function astFromInputField(field, schema, pathToDirectivesInExtensions) {
 }
 function astFromEnumValue(value, schema, pathToDirectivesInExtensions) {
   return {
-    kind: import_graphql8.Kind.ENUM_VALUE_DEFINITION,
+    kind: import_graphql9.Kind.ENUM_VALUE_DEFINITION,
     description: value.astNode?.description ?? (value.description ? {
-      kind: import_graphql8.Kind.STRING,
+      kind: import_graphql9.Kind.STRING,
       value: value.description,
       block: true
     } : void 0),
     name: {
-      kind: import_graphql8.Kind.NAME,
+      kind: import_graphql9.Kind.NAME,
       value: value.name
     },
     directives: getDeprecatableDirectiveNodes(value, schema, pathToDirectivesInExtensions)
   };
 }
 function makeDeprecatedDirective(deprecationReason) {
-  return makeDirectiveNode("deprecated", { reason: deprecationReason }, import_graphql8.GraphQLDeprecatedDirective);
+  return makeDirectiveNode("deprecated", { reason: deprecationReason }, import_graphql9.GraphQLDeprecatedDirective);
 }
 function makeDirectiveNode(name, args, directive) {
   const directiveArguments = [];
@@ -66114,9 +66114,9 @@ function makeDirectiveNode(name, args, directive) {
         const value = astFromValue(argValue, arg.type);
         if (value) {
           directiveArguments.push({
-            kind: import_graphql8.Kind.ARGUMENT,
+            kind: import_graphql9.Kind.ARGUMENT,
             name: {
-              kind: import_graphql8.Kind.NAME,
+              kind: import_graphql9.Kind.NAME,
               value: argName
             },
             value
@@ -66130,9 +66130,9 @@ function makeDirectiveNode(name, args, directive) {
       const value = astFromValueUntyped(argValue);
       if (value) {
         directiveArguments.push({
-          kind: import_graphql8.Kind.ARGUMENT,
+          kind: import_graphql9.Kind.ARGUMENT,
           name: {
-            kind: import_graphql8.Kind.NAME,
+            kind: import_graphql9.Kind.NAME,
             value: argName
           },
           value
@@ -66141,9 +66141,9 @@ function makeDirectiveNode(name, args, directive) {
     }
   }
   return {
-    kind: import_graphql8.Kind.DIRECTIVE,
+    kind: import_graphql9.Kind.DIRECTIVE,
     name: {
-      kind: import_graphql8.Kind.NAME,
+      kind: import_graphql9.Kind.NAME,
       value: name
     },
     arguments: directiveArguments
@@ -66166,7 +66166,7 @@ function makeDirectiveNodes(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_graphql9 = require("graphql");
+var import_graphql10 = require("graphql");
 var MAX_LINE_LENGTH = 80;
 var commentsRegistry = {};
 function resetComments() {
@@ -66411,7 +66411,7 @@ var printDocASTReducerWithComments = Object.keys(printDocASTReducer).reduce((pre
   }
 }), {});
 function printWithComments(ast) {
-  return (0, import_graphql9.visit)(ast, printDocASTReducerWithComments);
+  return (0, import_graphql10.visit)(ast, printDocASTReducerWithComments);
 }
 function isFieldDefinitionNode(node) {
   return node.kind === "FieldDefinition";
@@ -66430,7 +66430,7 @@ function getLeadingCommentBlock(node) {
   }
   const comments = [];
   let token = loc.startToken.prev;
-  while (token != null && token.kind === import_graphql9.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_graphql10.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;
@@ -66482,9 +66482,9 @@ function isBlank(str) {
 }
 
 // ../../node_modules/.pnpm/@graphql-tools+utils@10.0.6_graphql@15.5.0/node_modules/@graphql-tools/utils/esm/isDocumentNode.js
-var import_graphql10 = require("graphql");
+var import_graphql11 = require("graphql");
 function isDocumentNode(object) {
-  return object && typeof object === "object" && "kind" in object && object.kind === import_graphql10.Kind.DOCUMENT;
+  return object && typeof object === "object" && "kind" in object && object.kind === import_graphql11.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
@@ -66508,7 +66508,7 @@ function deduplicateArguments(args, config) {
 }
 
 // ../../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_graphql11 = require("graphql");
+var import_graphql12 = require("graphql");
 function directiveAlreadyExists(directivesArr, otherDirective) {
   return !!directivesArr.find((directive) => directive.name.value === otherDirective.name.value);
 }
@@ -66568,11 +66568,11 @@ function mergeDirectives(d1 = [], d2 = [], config, directives) {
   return result;
 }
 function validateInputs(node, existingNode) {
-  const printedNode = (0, import_graphql11.print)({
+  const printedNode = (0, import_graphql12.print)({
     ...node,
     description: void 0
   });
-  const printedExistingNode = (0, import_graphql11.print)({
+  const printedExistingNode = (0, import_graphql12.print)({
     ...existingNode,
     description: void 0
   });
@@ -66639,7 +66639,7 @@ function mergeEnumValues(first, second, config, 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_graphql12 = require("graphql");
+var import_graphql13 = require("graphql");
 function mergeEnum(e1, e2, config, directives) {
   if (e2) {
     return {
@@ -66653,33 +66653,33 @@ function mergeEnum(e1, e2, config, directives) {
   }
   return config?.convertExtensions ? {
     ...e1,
-    kind: import_graphql12.Kind.ENUM_TYPE_DEFINITION
+    kind: import_graphql13.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_graphql13 = require("graphql");
+var import_graphql14 = require("graphql");
 function isStringTypes(types15) {
   return typeof types15 === "string";
 }
 function isSourceTypes(types15) {
-  return types15 instanceof import_graphql13.Source;
+  return types15 instanceof import_graphql14.Source;
 }
 function extractType(type) {
   let visitedType = type;
-  while (visitedType.kind === import_graphql13.Kind.LIST_TYPE || visitedType.kind === "NonNullType") {
+  while (visitedType.kind === import_graphql14.Kind.LIST_TYPE || visitedType.kind === "NonNullType") {
     visitedType = visitedType.type;
   }
   return visitedType;
 }
 function isWrappingTypeNode(type) {
-  return type.kind !== import_graphql13.Kind.NAMED_TYPE;
+  return type.kind !== import_graphql14.Kind.NAMED_TYPE;
 }
 function isListTypeNode(type) {
-  return type.kind === import_graphql13.Kind.LIST_TYPE;
+  return type.kind === import_graphql14.Kind.LIST_TYPE;
 }
 function isNonNullTypeNode(type) {
-  return type.kind === import_graphql13.Kind.NON_NULL_TYPE;
+  return type.kind === import_graphql14.Kind.NON_NULL_TYPE;
 }
 function printTypeNode(type) {
   if (isListTypeNode(type)) {
@@ -66782,7 +66782,7 @@ function safeChangeForFieldType(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_graphql14 = require("graphql");
+var import_graphql15 = require("graphql");
 function mergeInputType(node, existingNode, config, directives) {
   if (existingNode) {
     try {
@@ -66800,12 +66800,12 @@ function mergeInputType(node, existingNode, config, directives) {
   }
   return config?.convertExtensions ? {
     ...node,
-    kind: import_graphql14.Kind.INPUT_OBJECT_TYPE_DEFINITION
+    kind: import_graphql15.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_graphql15 = require("graphql");
+var import_graphql16 = 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 alreadyExists(arr, other) {
@@ -66838,15 +66838,15 @@ function mergeInterface(node, existingNode, config, directives) {
   }
   return config?.convertExtensions ? {
     ...node,
-    kind: import_graphql15.Kind.INTERFACE_TYPE_DEFINITION
+    kind: import_graphql16.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_graphql20 = require("graphql");
+var import_graphql21 = 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_graphql16 = require("graphql");
+var import_graphql17 = require("graphql");
 function mergeType(node, existingNode, config, directives) {
   if (existingNode) {
     try {
@@ -66865,12 +66865,12 @@ function mergeType(node, existingNode, config, directives) {
   }
   return config?.convertExtensions ? {
     ...node,
-    kind: import_graphql16.Kind.OBJECT_TYPE_DEFINITION
+    kind: import_graphql17.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_graphql17 = require("graphql");
+var import_graphql18 = require("graphql");
 function mergeScalar(node, existingNode, config, directives) {
   if (existingNode) {
     return {
@@ -66883,31 +66883,31 @@ function mergeScalar(node, existingNode, config, directives) {
   }
   return config?.convertExtensions ? {
     ...node,
-    kind: import_graphql17.Kind.SCALAR_TYPE_DEFINITION
+    kind: import_graphql18.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_graphql18 = require("graphql");
+var import_graphql19 = require("graphql");
 function mergeUnion(first, second, config, directives) {
   if (second) {
     return {
       name: first.name,
       description: first["description"] || second["description"],
       directives: mergeDirectives(first.directives, second.directives, config, directives),
-      kind: config?.convertExtensions || first.kind === "UnionTypeDefinition" || second.kind === "UnionTypeDefinition" ? import_graphql18.Kind.UNION_TYPE_DEFINITION : import_graphql18.Kind.UNION_TYPE_EXTENSION,
+      kind: config?.convertExtensions || first.kind === "UnionTypeDefinition" || second.kind === "UnionTypeDefinition" ? import_graphql19.Kind.UNION_TYPE_DEFINITION : import_graphql19.Kind.UNION_TYPE_EXTENSION,
       loc: first.loc,
       types: mergeNamedTypeArray(first.types, second.types, config)
     };
   }
   return config?.convertExtensions ? {
     ...first,
-    kind: import_graphql18.Kind.UNION_TYPE_DEFINITION
+    kind: import_graphql19.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_graphql19 = require("graphql");
+var import_graphql20 = require("graphql");
 var DEFAULT_OPERATION_TYPE_NAME_MAP = {
   query: "Query",
   mutation: "Mutation",
@@ -66926,7 +66926,7 @@ function mergeOperationTypes(opNodeList = [], existingOpNodeList = []) {
 function mergeSchemaDefs(node, existingNode, config, directives) {
   if (existingNode) {
     return {
-      kind: node.kind === import_graphql19.Kind.SCHEMA_DEFINITION || existingNode.kind === import_graphql19.Kind.SCHEMA_DEFINITION ? import_graphql19.Kind.SCHEMA_DEFINITION : import_graphql19.Kind.SCHEMA_EXTENSION,
+      kind: node.kind === import_graphql20.Kind.SCHEMA_DEFINITION || existingNode.kind === import_graphql20.Kind.SCHEMA_DEFINITION ? import_graphql20.Kind.SCHEMA_DEFINITION : import_graphql20.Kind.SCHEMA_EXTENSION,
       description: node["description"] || existingNode["description"],
       directives: mergeDirectives(node.directives, existingNode.directives, config, directives),
       operationTypes: mergeOperationTypes(node.operationTypes, existingNode.operationTypes)
@@ -66934,7 +66934,7 @@ function mergeSchemaDefs(node, existingNode, config, directives) {
   }
   return config?.convertExtensions ? {
     ...node,
-    kind: import_graphql19.Kind.SCHEMA_DEFINITION
+    kind: import_graphql20.Kind.SCHEMA_DEFINITION
   } : node;
 }
 
@@ -66958,36 +66958,36 @@ function mergeGraphQLNodes(nodes, config, directives = {}) {
         delete mergedResultMap[name];
       } else {
         switch (nodeDefinition.kind) {
-          case import_graphql20.Kind.OBJECT_TYPE_DEFINITION:
-          case import_graphql20.Kind.OBJECT_TYPE_EXTENSION:
+          case import_graphql21.Kind.OBJECT_TYPE_DEFINITION:
+          case import_graphql21.Kind.OBJECT_TYPE_EXTENSION:
             mergedResultMap[name] = mergeType(nodeDefinition, mergedResultMap[name], config, directives);
             break;
-          case import_graphql20.Kind.ENUM_TYPE_DEFINITION:
-          case import_graphql20.Kind.ENUM_TYPE_EXTENSION:
+          case import_graphql21.Kind.ENUM_TYPE_DEFINITION:
+          case import_graphql21.Kind.ENUM_TYPE_EXTENSION:
             mergedResultMap[name] = mergeEnum(nodeDefinition, mergedResultMap[name], config, directives);
             break;
-          case import_graphql20.Kind.UNION_TYPE_DEFINITION:
-          case import_graphql20.Kind.UNION_TYPE_EXTENSION:
+          case import_graphql21.Kind.UNION_TYPE_DEFINITION:
+          case import_graphql21.Kind.UNION_TYPE_EXTENSION:
             mergedResultMap[name] = mergeUnion(nodeDefinition, mergedResultMap[name], config, directives);
             break;
-          case import_graphql20.Kind.SCALAR_TYPE_DEFINITION:
-          case import_graphql20.Kind.SCALAR_TYPE_EXTENSION:
+          case import_graphql21.Kind.SCALAR_TYPE_DEFINITION:
+          case import_graphql21.Kind.SCALAR_TYPE_EXTENSION:
             mergedResultMap[name] = mergeScalar(nodeDefinition, mergedResultMap[name], config, directives);
             break;
-          case import_graphql20.Kind.INPUT_OBJECT_TYPE_DEFINITION:
-          case import_graphql20.Kind.INPUT_OBJECT_TYPE_EXTENSION:
+          case import_graphql21.Kind.INPUT_OBJECT_TYPE_DEFINITION:
+          case import_graphql21.Kind.INPUT_OBJECT_TYPE_EXTENSION:
             mergedResultMap[name] = mergeInputType(nodeDefinition, mergedResultMap[name], config, directives);
             break;
-          case import_graphql20.Kind.INTERFACE_TYPE_DEFINITION:
-          case import_graphql20.Kind.INTERFACE_TYPE_EXTENSION:
+          case import_graphql21.Kind.INTERFACE_TYPE_DEFINITION:
+          case import_graphql21.Kind.INTERFACE_TYPE_EXTENSION:
             mergedResultMap[name] = mergeInterface(nodeDefinition, mergedResultMap[name], config, directives);
             break;
-          case import_graphql20.Kind.DIRECTIVE_DEFINITION:
+          case import_graphql21.Kind.DIRECTIVE_DEFINITION:
             mergedResultMap[name] = mergeDirective(nodeDefinition, mergedResultMap[name]);
             break;
         }
       }
-    } else if (nodeDefinition.kind === import_graphql20.Kind.SCHEMA_DEFINITION || nodeDefinition.kind === import_graphql20.Kind.SCHEMA_EXTENSION) {
+    } else if (nodeDefinition.kind === import_graphql21.Kind.SCHEMA_DEFINITION || nodeDefinition.kind === import_graphql21.Kind.SCHEMA_EXTENSION) {
       mergedResultMap[schemaDefSymbol] = mergeSchemaDefs(nodeDefinition, mergedResultMap[schemaDefSymbol], config);
     }
   }
@@ -66995,11 +66995,11 @@ function mergeGraphQLNodes(nodes, config, 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_graphql21 = require("graphql");
+var import_graphql22 = require("graphql");
 function mergeTypeDefs(typeSource, config) {
   resetComments();
   const doc = {
-    kind: import_graphql21.Kind.DOCUMENT,
+    kind: import_graphql22.Kind.DOCUMENT,
     definitions: mergeGraphQLTypes(typeSource, {
       useSchemaDefinition: true,
       forceSchemaDefinition: false,
@@ -67026,14 +67026,14 @@ function visitTypeSources(typeSource, options, allDirectives = [], allNodes = []
       for (const type of typeSource) {
         visitTypeSources(type, options, allDirectives, allNodes, visitedTypeSources);
       }
-    } else if ((0, import_graphql21.isSchema)(typeSource)) {
+    } else if ((0, import_graphql22.isSchema)(typeSource)) {
       const documentNode = getDocumentNodeFromSchema(typeSource, options);
       visitTypeSources(documentNode.definitions, options, allDirectives, allNodes, visitedTypeSources);
     } else if (isStringTypes(typeSource) || isSourceTypes(typeSource)) {
-      const documentNode = (0, import_graphql21.parse)(typeSource, options);
+      const documentNode = (0, import_graphql22.parse)(typeSource, options);
       visitTypeSources(documentNode.definitions, options, allDirectives, allNodes, visitedTypeSources);
-    } else if (typeof typeSource === "object" && (0, import_graphql21.isDefinitionNode)(typeSource)) {
-      if (typeSource.kind === import_graphql21.Kind.DIRECTIVE_DEFINITION) {
+    } else if (typeof typeSource === "object" && (0, import_graphql22.isDefinitionNode)(typeSource)) {
+      if (typeSource.kind === import_graphql22.Kind.DIRECTIVE_DEFINITION) {
         allDirectives.push(typeSource);
       } else {
         allNodes.push(typeSource);
@@ -67053,7 +67053,7 @@ function mergeGraphQLTypes(typeSource, config) {
   const mergedNodes = mergeGraphQLNodes(allNodes, config, mergedDirectives);
   if (config?.useSchemaDefinition) {
     const schemaDef = mergedNodes[schemaDefSymbol] || {
-      kind: import_graphql21.Kind.SCHEMA_DEFINITION,
+      kind: import_graphql22.Kind.SCHEMA_DEFINITION,
       operationTypes: []
     };
     const operationTypes = schemaDef.operationTypes;
@@ -67064,9 +67064,9 @@ function mergeGraphQLTypes(typeSource, config) {
         const existingPossibleRootType = mergedNodes[possibleRootTypeName];
         if (existingPossibleRootType != null && existingPossibleRootType.name != null) {
           operationTypes.push({
-            kind: import_graphql21.Kind.OPERATION_TYPE_DEFINITION,
+            kind: import_graphql22.Kind.OPERATION_TYPE_DEFINITION,
             type: {
-              kind: import_graphql21.Kind.NAMED_TYPE,
+              kind: import_graphql22.Kind.NAMED_TYPE,
               name: existingPossibleRootType.name
             },
             operation: opTypeDefNodeType
@@ -67080,15 +67080,15 @@ function mergeGraphQLTypes(typeSource, config) {
   }
   if (config?.forceSchemaDefinition && !mergedNodes[schemaDefSymbol]?.operationTypes?.length) {
     mergedNodes[schemaDefSymbol] = {
-      kind: import_graphql21.Kind.SCHEMA_DEFINITION,
+      kind: import_graphql22.Kind.SCHEMA_DEFINITION,
       operationTypes: [
         {
-          kind: import_graphql21.Kind.OPERATION_TYPE_DEFINITION,
+          kind: import_graphql22.Kind.OPERATION_TYPE_DEFINITION,
           operation: "query",
           type: {
-            kind: import_graphql21.Kind.NAMED_TYPE,
+            kind: import_graphql22.Kind.NAMED_TYPE,
             name: {
-              kind: import_graphql21.Kind.NAME,
+              kind: import_graphql22.Kind.NAME,
               value: "Query"
             }
           }