@settlemint/sdk-mcp 2.6.2-prdbaefab2 → 2.6.2-prfaedf028

package/dist/mcp.js

@@ -74120,8 +74120,8 @@ function collectSchemaParts(sources) {
   };
 }
 
-// ../../node_modules/.bun/@graphql-tools+url-loader@8.0.33+ded46c799560c44e/node_modules/@graphql-tools/url-loader/esm/index.js
-var import_graphql55 = __toESM(require_graphql2(), 1);
+// ../../node_modules/.bun/@graphql-tools+url-loader@9.0.0+ded46c799560c44e/node_modules/@graphql-tools/url-loader/esm/index.js
+var import_graphql54 = __toESM(require_graphql2(), 1);
 var import_isomorphic_ws3 = __toESM(require_ws(), 1);
 // ../../node_modules/.bun/@envelop+core@5.3.0/node_modules/@envelop/core/esm/document-string-map.js
 var documentStringMap = new WeakMap;
@@ -74133,7 +74133,7 @@ function getDocumentString(document, print5) {
   }
   return documentSource;
 }
-// ../../node_modules/.bun/@graphql-tools+executor-common@0.0.6+ded46c799560c44e/node_modules/@graphql-tools/executor-common/dist/index.js
+// ../../node_modules/.bun/@graphql-tools+executor-common@1.0.0+ded46c799560c44e/node_modules/@graphql-tools/executor-common/dist/index.js
 var import_graphql45 = __toESM(require_graphql2(), 1);
 var defaultPrintFn = memoize1(function defaultPrintFn2(document) {
   return import_graphql45.stripIgnoredCharacters(getDocumentString(document, import_graphql45.print));
@@ -74722,7 +74722,7 @@ function isFatalInternalCloseCode(code) {
 function isWebSocket(val) {
   return typeof val === "function" && "constructor" in val && "CLOSED" in val && "CLOSING" in val && "CONNECTING" in val && "OPEN" in val;
 }
-// ../../node_modules/.bun/@graphql-tools+executor-graphql-ws@2.0.7+ded46c799560c44e/node_modules/@graphql-tools/executor-graphql-ws/dist/index.js
+// ../../node_modules/.bun/@graphql-tools+executor-graphql-ws@3.0.0+ded46c799560c44e/node_modules/@graphql-tools/executor-graphql-ws/dist/index.js
 var import_isomorphic_ws = __toESM(require_ws(), 1);
 function isClient(client) {
   return "subscribe" in client;
@@ -74787,7 +74787,7 @@ function buildGraphQLWSExecutor(clientOptionsOrClient) {
   return executor2;
 }
 
-// ../../node_modules/.bun/@graphql-hive+signal@1.0.0/node_modules/@graphql-hive/signal/dist/index.js
+// ../../node_modules/.bun/@graphql-hive+signal@2.0.0/node_modules/@graphql-hive/signal/dist/index.js
 var isNode = !globalThis.Bun && globalThis.process?.release?.name === "node";
 var anySignalRegistry = isNode ? new FinalizationRegistry((cb) => cb()) : null;
 var controllerInSignalSy = Symbol("CONTROLLER_IN_SIGNAL");
@@ -74839,24 +74839,6 @@ function abortSignalAny(signals) {
   return ctrl.signal;
 }
 
-// ../../node_modules/.bun/@graphql-tools+executor-common@0.0.4+ded46c799560c44e/node_modules/@graphql-tools/executor-common/dist/index.js
-var import_graphql46 = __toESM(require_graphql2(), 1);
-var defaultPrintFn3 = memoize1(function defaultPrintFn22(document) {
-  return import_graphql46.stripIgnoredCharacters(getDocumentString(document, import_graphql46.print));
-});
-function serializeExecutionRequest2({
-  executionRequest,
-  excludeQuery,
-  printFn = defaultPrintFn3
-}) {
-  return {
-    query: excludeQuery ? undefined : printFn(executionRequest.document),
-    variables: (executionRequest.variables && Object.keys(executionRequest.variables).length) > 0 ? executionRequest.variables : undefined,
-    operationName: executionRequest.operationName ? executionRequest.operationName : undefined,
-    extensions: executionRequest.extensions && Object.keys(executionRequest.extensions).length > 0 ? executionRequest.extensions : undefined
-  };
-}
-
 // ../../node_modules/.bun/@whatwg-node+fetch@0.10.10/node_modules/@whatwg-node/fetch/dist/node-ponyfill.js
 var createNodePonyfill = require_create_node_ponyfill();
 var shouldSkipPonyfill = require_shouldSkipPonyfill();
@@ -75944,8 +75926,8 @@ function latest(contenders) {
   });
 }
 
-// ../../node_modules/.bun/@graphql-tools+executor-http@1.3.3+ded46c799560c44e/node_modules/@graphql-tools/executor-http/dist/index.js
-var import_graphql47 = __toESM(require_graphql2(), 1);
+// ../../node_modules/.bun/@graphql-tools+executor-http@3.0.0+ded46c799560c44e/node_modules/@graphql-tools/executor-http/dist/index.js
+var import_graphql46 = __toESM(require_graphql2(), 1);
 
 // ../../node_modules/.bun/meros@1.3.1/node_modules/meros/browser/index.mjs
 async function e(e2, t) {
@@ -76040,7 +76022,7 @@ async function e2(e3, t) {
   }(e3, `--${i}`, t);
 }
 
-// ../../node_modules/.bun/@graphql-tools+executor-http@1.3.3+ded46c799560c44e/node_modules/@graphql-tools/executor-http/dist/index.js
+// ../../node_modules/.bun/@graphql-tools+executor-http@3.0.0+ded46c799560c44e/node_modules/@graphql-tools/executor-http/dist/index.js
 function isPlainObject2(value) {
   if (typeof value !== "object" || value === null) {
     return false;
@@ -76186,7 +76168,7 @@ function isBlob(obj) {
   return typeof obj.arrayBuffer === "function";
 }
 function createGraphQLErrorForAbort(reason, extensions) {
-  if (reason instanceof import_graphql47.GraphQLError) {
+  if (reason instanceof import_graphql46.GraphQLError) {
     return reason;
   }
   if (reason?.name === "TimeoutError") {
@@ -76237,7 +76219,8 @@ function handleEventStreamResponse(response, subscriptionCtrl, signal) {
   return new Repeater((push2, stop2) => {
     const decoder = new $TextDecoder;
     const reader = body.getReader();
-    reader.closed.then(stop2).catch(stop2);
+    let closed = false;
+    reader.closed.then(() => closed = true).catch((reason) => closed = reason);
     stop2.then(() => {
       subscriptionCtrl?.abort();
       if (body.locked) {
@@ -76255,7 +76238,24 @@ function handleEventStreamResponse(response, subscriptionCtrl, signal) {
       if (!body?.locked) {
         return stop2();
       }
-      const { done, value: chunk } = await reader.read();
+      let done, chunk;
+      try {
+        const result = await reader.read();
+        done = result.done;
+        chunk = result.value;
+      } catch (err) {
+        if (signal?.aborted) {
+          await push2(createResultForAbort(signal.reason));
+          return stop2();
+        }
+        const errErr = err instanceof Error ? err : new Error(String(err));
+        await push2({
+          errors: [
+            createGraphQLError(errErr.message, { originalError: errErr })
+          ]
+        });
+        return stop2();
+      }
       if (done) {
         return stop2();
       }
@@ -76272,11 +76272,15 @@ function handleEventStreamResponse(response, subscriptionCtrl, signal) {
           const data = JSON.parse(dataStr);
           await push2(data.payload || data);
         }
-        const event = msg.split("event:")[1]?.trim();
+        const event = msg.split("event:")[1]?.trim().split(`
+`)[0]?.trim();
         if (event === "complete") {
           return stop2();
         }
       }
+      if (closed) {
+        return stop2();
+      }
       return pump();
     }
     return pump();
@@ -76344,10 +76348,10 @@ function prepareGETUrl({
   const finalUrl = urlObj.toString().replace(dummyHostname, "");
   return finalUrl;
 }
+var inflightRequests = /* @__PURE__ */ new Map;
 function buildHTTPExecutor(options) {
-  const printFn = options?.print ?? defaultPrintFn3;
+  const printFn = options?.print ?? defaultPrintFn;
   let disposeCtrl;
-  const serviceName = options?.serviceName;
   const baseExecutor = (request, excludeQuery) => {
     disposeCtrl ||= new AbortController;
     if (disposeCtrl.signal.aborted) {
@@ -76369,12 +76373,34 @@ function buildHTTPExecutor(options) {
     } else {
       method ||= "POST";
     }
-    const endpoint = request.extensions?.endpoint || options?.endpoint || "/graphql";
+    let endpoint;
+    if (request.extensions?.endpoint) {
+      if (typeof request.extensions.endpoint === "string") {
+        endpoint = request.extensions.endpoint;
+      }
+      if (typeof request.extensions.endpoint === "function") {
+        endpoint = request.extensions.endpoint(request);
+      }
+    }
+    if (!endpoint) {
+      if (typeof options?.endpoint === "string") {
+        endpoint = options.endpoint;
+      }
+      if (typeof options?.endpoint === "function") {
+        endpoint = options.endpoint(request);
+      }
+    }
+    if (!endpoint) {
+      endpoint = "/graphql";
+    }
+    let isCustomHeader = false;
     const headers = { accept };
     if (options?.headers) {
+      isCustomHeader = true;
       Object.assign(headers, typeof options?.headers === "function" ? options.headers(request) : options?.headers);
     }
     if (request.extensions?.headers) {
+      isCustomHeader = true;
       const { headers: headersFromExtensions, ...restExtensions } = request.extensions;
       Object.assign(headers, headersFromExtensions);
       request.extensions = restExtensions;
@@ -76395,15 +76421,13 @@ function buildHTTPExecutor(options) {
     }
     const signal = abortSignalAny(signals);
     const upstreamErrorExtensions = {
-      code: "DOWNSTREAM_SERVICE_ERROR",
-      serviceName,
       request: {
         method
       }
     };
     const query = printFn(request.document);
     let serializeFn = function serialize() {
-      return serializeExecutionRequest2({
+      return serializeExecutionRequest({
         executionRequest: request,
         excludeQuery,
         printFn
@@ -76417,7 +76441,7 @@ function buildHTTPExecutor(options) {
             version: 1,
             sha256Hash
           };
-          return serializeExecutionRequest2({
+          return serializeExecutionRequest({
             executionRequest: {
               ...request,
               extensions
@@ -76448,23 +76472,129 @@ function buildHTTPExecutor(options) {
         ]
       };
     }
-    return handleMaybePromise(() => serializeFn(), (body) => handleMaybePromise(() => {
+    function handleInflightRequest(inflightRequestOptions, context, info) {
+      if (options?.deduplicateInflightRequests === false) {
+        return runInflightRequest();
+      }
+      function runInflightRequest() {
+        return handleMaybePromise(() => fetchFn(inflightRequestOptions.url, {
+          method: inflightRequestOptions.method,
+          headers: inflightRequestOptions.headers,
+          body: inflightRequestOptions.body,
+          credentials: inflightRequestOptions.credentials,
+          signal: inflightRequestOptions.signal
+        }, context, info), (fetchResult) => handleMaybePromise(() => {
+          upstreamErrorExtensions.response ||= {};
+          upstreamErrorExtensions.response.status = fetchResult.status;
+          upstreamErrorExtensions.response.statusText = fetchResult.statusText;
+          Object.defineProperty(upstreamErrorExtensions.response, "headers", {
+            get() {
+              return Object.fromEntries(fetchResult.headers.entries());
+            }
+          });
+          if (options?.retry != null && !fetchResult.status.toString().startsWith("2")) {
+            throw new Error(fetchResult.statusText || `Upstream HTTP Error: ${fetchResult.status}`);
+          }
+          const contentType = fetchResult.headers.get("content-type");
+          if (contentType?.includes("text/event-stream")) {
+            return handleEventStreamResponse(fetchResult, subscriptionCtrl, signal);
+          } else if (contentType?.includes("multipart/mixed")) {
+            return handleMultipartMixedResponse(fetchResult);
+          }
+          return fetchResult.text();
+        }, (result) => {
+          if (typeof result === "string") {
+            upstreamErrorExtensions.response ||= {};
+            upstreamErrorExtensions.response.body = result;
+            if (result) {
+              try {
+                const parsedResult = JSON.parse(result);
+                upstreamErrorExtensions.response.body = parsedResult;
+                if (parsedResult.data == null && (parsedResult.errors == null || parsedResult.errors.length === 0)) {
+                  const message = `Unexpected empty "data" and "errors" fields in result: ${result}`;
+                  return {
+                    errors: [
+                      createGraphQLError(message, {
+                        originalError: new Error(message),
+                        extensions: upstreamErrorExtensions
+                      })
+                    ]
+                  };
+                }
+                if (Array.isArray(parsedResult.errors)) {
+                  return {
+                    ...parsedResult,
+                    errors: parsedResult.errors.map(({
+                      message,
+                      ...options2
+                    }) => createGraphQLError(message, options2))
+                  };
+                }
+                return parsedResult;
+              } catch (e3) {
+                return {
+                  errors: [
+                    createGraphQLError(`Unexpected response: ${JSON.stringify(result)}`, {
+                      extensions: upstreamErrorExtensions,
+                      originalError: e3
+                    })
+                  ]
+                };
+              }
+            } else {
+              const message = "No response returned";
+              return {
+                errors: [
+                  createGraphQLError(message, {
+                    extensions: upstreamErrorExtensions,
+                    originalError: new Error(message)
+                  })
+                ]
+              };
+            }
+          } else {
+            return result;
+          }
+        }, handleError), handleError);
+      }
+      if (typeof inflightRequestOptions.body === "object") {
+        return runInflightRequest();
+      }
+      let inflightRequestId = `${inflightRequestOptions.url}|${inflightRequestOptions.method}`;
+      if (inflightRequestOptions.body) {
+        inflightRequestId += `|${inflightRequestOptions.body}`;
+      }
+      if (isCustomHeader) {
+        inflightRequestId += `|${JSON.stringify(inflightRequestOptions.headers)}`;
+      }
+      let inflightRequest = inflightRequests.get(inflightRequestId);
+      if (!inflightRequest) {
+        inflightRequest = runInflightRequest();
+        if (isPromise(inflightRequest)) {
+          inflightRequests.set(inflightRequestId, inflightRequest);
+          inflightRequest.finally(() => {
+            inflightRequests.delete(inflightRequestId);
+          });
+        }
+      }
+      return inflightRequest;
+    }
+    return handleMaybePromise(() => serializeFn(), (body) => {
       switch (method) {
         case "GET": {
           const finalUrl = prepareGETUrl({
             baseUrl: endpoint,
             body
           });
-          const fetchOptions = {
+          const inflightRequestOptions = {
+            url: finalUrl,
             method: "GET",
             headers,
-            signal
+            signal,
+            credentials: options?.credentials
           };
-          if (options?.credentials != null) {
-            fetchOptions.credentials = options.credentials;
-          }
           upstreamErrorExtensions.request.url = finalUrl;
-          return fetchFn(finalUrl, fetchOptions, request.context, request.info);
+          return handleInflightRequest(inflightRequestOptions, request.context, request.info);
         }
         case "POST": {
           upstreamErrorExtensions.request.body = body;
@@ -76476,95 +76606,19 @@ function buildHTTPExecutor(options) {
               upstreamErrorExtensions.request.body = body2;
               headers["content-type"] = "application/json";
             }
-            const fetchOptions = {
+            const inflightRequestOptions = {
+              url: endpoint,
               method: "POST",
               body: body2,
               headers,
+              credentials: options?.credentials,
               signal
             };
-            if (options?.credentials != null) {
-              fetchOptions.credentials = options.credentials;
-            }
-            return fetchFn(endpoint, fetchOptions, request.context, request.info);
+            return handleInflightRequest(inflightRequestOptions, request.context, request.info);
           }, handleError);
         }
       }
-    }, (fetchResult) => handleMaybePromise(() => {
-      upstreamErrorExtensions.response ||= {};
-      upstreamErrorExtensions.response.status = fetchResult.status;
-      upstreamErrorExtensions.response.statusText = fetchResult.statusText;
-      Object.defineProperty(upstreamErrorExtensions.response, "headers", {
-        get() {
-          return Object.fromEntries(fetchResult.headers.entries());
-        }
-      });
-      if (options?.retry != null && !fetchResult.status.toString().startsWith("2")) {
-        throw new Error(fetchResult.statusText || `Upstream HTTP Error: ${fetchResult.status}`);
-      }
-      const contentType = fetchResult.headers.get("content-type");
-      if (contentType?.includes("text/event-stream")) {
-        return handleEventStreamResponse(fetchResult, subscriptionCtrl, signal);
-      } else if (contentType?.includes("multipart/mixed")) {
-        return handleMultipartMixedResponse(fetchResult);
-      }
-      return fetchResult.text();
-    }, (result) => {
-      if (typeof result === "string") {
-        upstreamErrorExtensions.response ||= {};
-        upstreamErrorExtensions.response.body = result;
-        if (result) {
-          try {
-            const parsedResult = JSON.parse(result);
-            upstreamErrorExtensions.response.body = parsedResult;
-            if (parsedResult.data == null && (parsedResult.errors == null || parsedResult.errors.length === 0)) {
-              return {
-                errors: [
-                  createGraphQLError('Unexpected empty "data" and "errors" fields in result: ' + result, {
-                    extensions: upstreamErrorExtensions
-                  })
-                ]
-              };
-            }
-            if (Array.isArray(parsedResult.errors)) {
-              return {
-                ...parsedResult,
-                errors: parsedResult.errors.map(({
-                  message,
-                  ...options2
-                }) => createGraphQLError(message, {
-                  ...options2,
-                  extensions: {
-                    code: "DOWNSTREAM_SERVICE_ERROR",
-                    serviceName,
-                    ...options2.extensions || {}
-                  }
-                }))
-              };
-            }
-            return parsedResult;
-          } catch (e3) {
-            return {
-              errors: [
-                createGraphQLError(`Unexpected response: ${JSON.stringify(result)}`, {
-                  extensions: upstreamErrorExtensions,
-                  originalError: e3
-                })
-              ]
-            };
-          }
-        } else {
-          return {
-            errors: [
-              createGraphQLError("No response returned", {
-                extensions: upstreamErrorExtensions
-              })
-            ]
-          };
-        }
-      } else {
-        return result;
-      }
-    }, handleError), handleError), handleError);
+    }, handleError);
   };
   let executor2 = baseExecutor;
   if (options?.apq != null) {
@@ -76658,7 +76712,7 @@ function coerceFetchError(e3, {
 }
 
 // ../../node_modules/.bun/@graphql-tools+executor-legacy-ws@1.1.19+ded46c799560c44e/node_modules/@graphql-tools/executor-legacy-ws/esm/index.js
-var import_graphql48 = __toESM(require_graphql2(), 1);
+var import_graphql47 = __toESM(require_graphql2(), 1);
 var import_isomorphic_ws2 = __toESM(require_ws(), 1);
 var LEGACY_WS;
 (function(LEGACY_WS2) {
@@ -76746,7 +76800,7 @@ function buildWSLegacyExecutor(subscriptionsEndpoint, WebSocketImpl, options) {
                 type: LEGACY_WS.START,
                 id,
                 payload: {
-                  query: import_graphql48.print(request.document),
+                  query: import_graphql47.print(request.document),
                   variables: request.variables,
                   operationName: request.operationName
                 }
@@ -76802,11 +76856,11 @@ function buildWSLegacyExecutor(subscriptionsEndpoint, WebSocketImpl, options) {
   return executor2;
 }
 
-// ../../node_modules/.bun/@graphql-tools+delegate@10.2.23+ded46c799560c44e/node_modules/@graphql-tools/delegate/dist/index.js
-var import_graphql53 = __toESM(require_graphql2(), 1);
+// ../../node_modules/.bun/@graphql-tools+delegate@11.0.0+ded46c799560c44e/node_modules/@graphql-tools/delegate/dist/index.js
+var import_graphql52 = __toESM(require_graphql2(), 1);
 
 // ../../node_modules/.bun/@graphql-tools+executor@1.4.9+ded46c799560c44e/node_modules/@graphql-tools/executor/esm/execution/execute.js
-var import_graphql50 = __toESM(require_graphql2(), 1);
+var import_graphql49 = __toESM(require_graphql2(), 1);
 
 // ../../node_modules/.bun/@graphql-tools+executor@1.4.9+ded46c799560c44e/node_modules/@graphql-tools/executor/esm/execution/coerceError.js
 function coerceError(error43) {
@@ -76932,7 +76986,7 @@ function promiseForObject(object3, signal, signalPromise) {
 }
 
 // ../../node_modules/.bun/@graphql-tools+executor@1.4.9+ded46c799560c44e/node_modules/@graphql-tools/executor/esm/execution/values.js
-var import_graphql49 = __toESM(require_graphql2(), 1);
+var import_graphql48 = __toESM(require_graphql2(), 1);
 function getVariableValues(schema, varDefNodes, inputs, options) {
   const errors5 = [];
   const maxErrors = options?.maxErrors;
@@ -76955,16 +77009,16 @@ function coerceVariableValues(schema, varDefNodes, inputs, onError) {
   const coercedValues = {};
   for (const varDefNode of varDefNodes) {
     const varName = varDefNode.variable.name.value;
-    const varType = import_graphql49.typeFromAST(schema, varDefNode.type);
-    if (!import_graphql49.isInputType(varType)) {
-      const varTypeStr = import_graphql49.print(varDefNode.type);
+    const varType = import_graphql48.typeFromAST(schema, varDefNode.type);
+    if (!import_graphql48.isInputType(varType)) {
+      const varTypeStr = import_graphql48.print(varDefNode.type);
       onError(createGraphQLError(`Variable "$${varName}" expected value of type "${varTypeStr}" which cannot be used as an input type.`, { nodes: varDefNode.type }));
       continue;
     }
     if (!hasOwnProperty(inputs, varName)) {
       if (varDefNode.defaultValue) {
-        coercedValues[varName] = import_graphql49.valueFromAST(varDefNode.defaultValue, varType);
-      } else if (import_graphql49.isNonNullType(varType)) {
+        coercedValues[varName] = import_graphql48.valueFromAST(varDefNode.defaultValue, varType);
+      } else if (import_graphql48.isNonNullType(varType)) {
         const varTypeStr = inspect(varType);
         onError(createGraphQLError(`Variable "$${varName}" of required type "${varTypeStr}" was not provided.`, {
           nodes: varDefNode
@@ -76973,14 +77027,14 @@ function coerceVariableValues(schema, varDefNodes, inputs, onError) {
       continue;
     }
     const value = inputs[varName];
-    if (value === null && import_graphql49.isNonNullType(varType)) {
+    if (value === null && import_graphql48.isNonNullType(varType)) {
       const varTypeStr = inspect(varType);
       onError(createGraphQLError(`Variable "$${varName}" of non-null type "${varTypeStr}" must not be null.`, {
         nodes: varDefNode
       }));
       continue;
     }
-    coercedValues[varName] = import_graphql49.coerceInputValue(value, varType, (path2, invalidValue, error43) => {
+    coercedValues[varName] = import_graphql48.coerceInputValue(value, varType, (path2, invalidValue, error43) => {
       let prefix = `Variable "$${varName}" got invalid value ` + inspect(invalidValue);
       if (path2.length > 0) {
         prefix += ` at "${varName}${printPathArray(path2)}"`;
@@ -77046,7 +77100,7 @@ function buildResponse(data, errors5) {
 var getFragmentsFromDocument = memoize1(function getFragmentsFromDocument2(document) {
   const fragments = Object.create(null);
   for (const definition of document.definitions) {
-    if (definition.kind === import_graphql50.Kind.FRAGMENT_DEFINITION) {
+    if (definition.kind === import_graphql49.Kind.FRAGMENT_DEFINITION) {
       fragments[definition.name.value] = definition;
     }
   }
@@ -77055,12 +77109,12 @@ var getFragmentsFromDocument = memoize1(function getFragmentsFromDocument2(docum
 function buildExecutionContext(args) {
   const { schema, document, rootValue, contextValue, variableValues: rawVariableValues, operationName, fieldResolver, typeResolver, subscribeFieldResolver, signal } = args;
   signal?.throwIfAborted();
-  import_graphql50.assertValidSchema(schema);
+  import_graphql49.assertValidSchema(schema);
   const fragments = getFragmentsFromDocument(document);
   let operation;
   for (const definition of document.definitions) {
     switch (definition.kind) {
-      case import_graphql50.Kind.OPERATION_DEFINITION:
+      case import_graphql49.Kind.OPERATION_DEFINITION:
         if (operationName == null) {
           if (operation !== undefined) {
             return [
@@ -77242,14 +77296,14 @@ function executeField(exeContext, parentType, source, fieldNodes, path2, asyncPa
           let result2;
           for (let rawErrorItem of rawError.errors) {
             rawErrorItem = coerceError(rawErrorItem);
-            const error44 = import_graphql50.locatedError(rawErrorItem, fieldNodes, pathToArray(path2));
+            const error44 = import_graphql49.locatedError(rawErrorItem, fieldNodes, pathToArray(path2));
             result2 = handleFieldError(error44, returnType, errors5);
             filterSubsequentPayloads(exeContext, path2, asyncPayloadRecord);
           }
           return result2;
         }
         rawError = coerceError(rawError);
-        const error43 = import_graphql50.locatedError(rawError, fieldNodes, pathToArray(path2));
+        const error43 = import_graphql49.locatedError(rawError, fieldNodes, pathToArray(path2));
         const handledError = handleFieldError(error43, returnType, errors5);
         filterSubsequentPayloads(exeContext, path2, asyncPayloadRecord);
         return handledError;
@@ -77261,14 +77315,14 @@ function executeField(exeContext, parentType, source, fieldNodes, path2, asyncPa
       let result;
       for (let rawErrorItem of rawError.errors) {
         rawErrorItem = coerceError(rawErrorItem);
-        const error44 = import_graphql50.locatedError(rawErrorItem, fieldNodes, pathToArray(path2));
+        const error44 = import_graphql49.locatedError(rawErrorItem, fieldNodes, pathToArray(path2));
         result = handleFieldError(error44, returnType, errors5);
         filterSubsequentPayloads(exeContext, path2, asyncPayloadRecord);
       }
       return result;
     }
     const coercedError = coerceError(rawError);
-    const error43 = import_graphql50.locatedError(coercedError, fieldNodes, pathToArray(path2));
+    const error43 = import_graphql49.locatedError(coercedError, fieldNodes, pathToArray(path2));
     const handledError = handleFieldError(error43, returnType, errors5);
     filterSubsequentPayloads(exeContext, path2, asyncPayloadRecord);
     return handledError;
@@ -77291,7 +77345,7 @@ function buildResolveInfo(exeContext, fieldDef, fieldNodes, parentType, path2) {
 }
 var CRITICAL_ERROR = "CRITICAL_ERROR";
 function handleFieldError(error43, returnType, errors5) {
-  if (import_graphql50.isNonNullType(returnType)) {
+  if (import_graphql49.isNonNullType(returnType)) {
     throw error43;
   }
   if (error43.extensions?.[CRITICAL_ERROR]) {
@@ -77304,7 +77358,7 @@ function completeValue(exeContext, returnType, fieldNodes, info, path2, result,
   if (result instanceof Error) {
     throw result;
   }
-  if (import_graphql50.isNonNullType(returnType)) {
+  if (import_graphql49.isNonNullType(returnType)) {
     const completed = completeValue(exeContext, returnType.ofType, fieldNodes, info, path2, result, asyncPayloadRecord);
     if (completed === null) {
       throw new Error(`Cannot return null for non-nullable field ${info.parentType.name}.${info.fieldName}.`);
@@ -77314,16 +77368,16 @@ function completeValue(exeContext, returnType, fieldNodes, info, path2, result,
   if (result == null) {
     return null;
   }
-  if (import_graphql50.isListType(returnType)) {
+  if (import_graphql49.isListType(returnType)) {
     return completeListValue(exeContext, returnType, fieldNodes, info, path2, result, asyncPayloadRecord);
   }
-  if (import_graphql50.isLeafType(returnType)) {
+  if (import_graphql49.isLeafType(returnType)) {
     return completeLeafValue(returnType, result);
   }
-  if (import_graphql50.isAbstractType(returnType)) {
+  if (import_graphql49.isAbstractType(returnType)) {
     return completeAbstractValue(exeContext, returnType, fieldNodes, info, path2, result, asyncPayloadRecord);
   }
-  if (import_graphql50.isObjectType(returnType)) {
+  if (import_graphql49.isObjectType(returnType)) {
     return completeObjectValue(exeContext, returnType, fieldNodes, info, path2, result, asyncPayloadRecord);
   }
   console.assert(false, "Cannot complete value of unexpected output type: " + inspect(returnType));
@@ -77332,7 +77386,7 @@ function getStreamValues(exeContext, fieldNodes, path2) {
   if (typeof path2.key === "number") {
     return;
   }
-  const stream2 = import_graphql50.getDirectiveValues(GraphQLStreamDirective, fieldNodes[0], exeContext.variableValues);
+  const stream2 = import_graphql49.getDirectiveValues(GraphQLStreamDirective, fieldNodes[0], exeContext.variableValues);
   if (!stream2) {
     return;
   }
@@ -77372,7 +77426,7 @@ async function completeAsyncIteratorValue(exeContext, itemType, fieldNodes, info
       }
     } catch (rawError) {
       const coercedError = coerceError(rawError);
-      const error43 = import_graphql50.locatedError(coercedError, fieldNodes, pathToArray(itemPath));
+      const error43 = import_graphql49.locatedError(coercedError, fieldNodes, pathToArray(itemPath));
       completedResults.push(handleFieldError(error43, itemType, errors5));
       break;
     }
@@ -77423,7 +77477,7 @@ function completeListItemValue(item, completedResults, errors5, exeContext, item
     if (isPromise(completedItem)) {
       completedResults.push(completedItem.then(undefined, (rawError) => {
         rawError = coerceError(rawError);
-        const error43 = import_graphql50.locatedError(rawError, fieldNodes, pathToArray(itemPath));
+        const error43 = import_graphql49.locatedError(rawError, fieldNodes, pathToArray(itemPath));
         const handledError = handleFieldError(error43, itemType, errors5);
         filterSubsequentPayloads(exeContext, itemPath, asyncPayloadRecord);
         return handledError;
@@ -77433,7 +77487,7 @@ function completeListItemValue(item, completedResults, errors5, exeContext, item
     completedResults.push(completedItem);
   } catch (rawError) {
     const coercedError = coerceError(rawError);
-    const error43 = import_graphql50.locatedError(coercedError, fieldNodes, pathToArray(itemPath));
+    const error43 = import_graphql49.locatedError(coercedError, fieldNodes, pathToArray(itemPath));
     const handledError = handleFieldError(error43, itemType, errors5);
     filterSubsequentPayloads(exeContext, itemPath, asyncPayloadRecord);
     completedResults.push(handledError);
@@ -77445,7 +77499,7 @@ function completeLeafValue(returnType, result) {
   try {
     serializedResult = returnType.serialize(result);
   } catch (err) {
-    if (err instanceof import_graphql50.GraphQLError) {
+    if (err instanceof import_graphql49.GraphQLError) {
       throw new Error(err.message);
     }
     throw err;
@@ -77468,8 +77522,8 @@ function ensureValidRuntimeType(runtimeTypeName, exeContext, returnType, fieldNo
   if (runtimeTypeName == null) {
     throw createGraphQLError(`Abstract type "${returnType.name}" must resolve to an Object type at runtime for field "${info.parentType.name}.${info.fieldName}". Either the "${returnType.name}" type should provide a "resolveType" function or each possible type should provide an "isTypeOf" function.`, { nodes: fieldNodes });
   }
-  if (import_graphql50.isObjectType(runtimeTypeName)) {
-    if (import_graphql50.versionInfo.major >= 16) {
+  if (import_graphql49.isObjectType(runtimeTypeName)) {
+    if (import_graphql49.versionInfo.major >= 16) {
       throw createGraphQLError("Support for returning GraphQLObjectType from resolveType was removed in graphql-js@16.0.0 please return type name instead.");
     }
     runtimeTypeName = runtimeTypeName.name;
@@ -77481,7 +77535,7 @@ function ensureValidRuntimeType(runtimeTypeName, exeContext, returnType, fieldNo
   if (runtimeType == null) {
     throw createGraphQLError(`Abstract type "${returnType.name}" was resolved to a type "${runtimeTypeName}" that does not exist inside the schema.`, { nodes: fieldNodes });
   }
-  if (!import_graphql50.isObjectType(runtimeType)) {
+  if (!import_graphql49.isObjectType(runtimeType)) {
     throw createGraphQLError(`Abstract type "${returnType.name}" was resolved to a non-object type "${runtimeTypeName}".`, { nodes: fieldNodes });
   }
   if (!exeContext.schema.isSubType(returnType, runtimeType)) {
@@ -77674,12 +77728,12 @@ function executeSubscription(exeContext) {
     const result = resolveFn(rootValue, args, contextValue, info);
     if (isPromise(result)) {
       return result.then((result2) => assertEventStream(result2, exeContext.signal, exeContext.onSignalAbort)).then(undefined, (error43) => {
-        throw import_graphql50.locatedError(error43, fieldNodes, pathToArray(path2));
+        throw import_graphql49.locatedError(error43, fieldNodes, pathToArray(path2));
       });
     }
     return assertEventStream(result, exeContext.signal, exeContext.onSignalAbort);
   } catch (error43) {
-    throw import_graphql50.locatedError(error43, fieldNodes, pathToArray(path2));
+    throw import_graphql49.locatedError(error43, fieldNodes, pathToArray(path2));
   }
 }
 function assertEventStream(result, signal, onSignalAbort) {
@@ -77745,7 +77799,7 @@ function executeStreamField(path2, itemPath, item, exeContext, fieldNodes, info,
       if (isPromise(completedItem)) {
         completedItem = completedItem.then(undefined, (rawError) => {
           rawError = coerceError(rawError);
-          const error43 = import_graphql50.locatedError(rawError, fieldNodes, pathToArray(itemPath));
+          const error43 = import_graphql49.locatedError(rawError, fieldNodes, pathToArray(itemPath));
           const handledError = handleFieldError(error43, itemType, asyncPayloadRecord.errors);
           filterSubsequentPayloads(exeContext, itemPath, asyncPayloadRecord);
           return handledError;
@@ -77753,7 +77807,7 @@ function executeStreamField(path2, itemPath, item, exeContext, fieldNodes, info,
       }
     } catch (rawError) {
       const coercedError = coerceError(rawError);
-      const error43 = import_graphql50.locatedError(coercedError, fieldNodes, pathToArray(itemPath));
+      const error43 = import_graphql49.locatedError(coercedError, fieldNodes, pathToArray(itemPath));
       completedItem = handleFieldError(error43, itemType, asyncPayloadRecord.errors);
       filterSubsequentPayloads(exeContext, itemPath, asyncPayloadRecord);
     }
@@ -77787,7 +77841,7 @@ async function executeStreamIteratorItem(iterator, exeContext, fieldNodes, info,
     item = value;
   } catch (rawError) {
     const coercedError = coerceError(rawError);
-    const error43 = import_graphql50.locatedError(coercedError, fieldNodes, pathToArray(itemPath));
+    const error43 = import_graphql49.locatedError(coercedError, fieldNodes, pathToArray(itemPath));
     const value = handleFieldError(error43, itemType, asyncPayloadRecord.errors);
     return { done: true, value };
   }
@@ -77796,7 +77850,7 @@ async function executeStreamIteratorItem(iterator, exeContext, fieldNodes, info,
     completedItem = completeValue(exeContext, itemType, fieldNodes, info, itemPath, item, asyncPayloadRecord);
     if (isPromise(completedItem)) {
       completedItem = completedItem.then(undefined, (rawError) => {
-        const error43 = import_graphql50.locatedError(rawError, fieldNodes, pathToArray(itemPath));
+        const error43 = import_graphql49.locatedError(rawError, fieldNodes, pathToArray(itemPath));
         const handledError = handleFieldError(error43, itemType, asyncPayloadRecord.errors);
         filterSubsequentPayloads(exeContext, itemPath, asyncPayloadRecord);
         return handledError;
@@ -77804,7 +77858,7 @@ async function executeStreamIteratorItem(iterator, exeContext, fieldNodes, info,
     }
     return { done: false, value: completedItem };
   } catch (rawError) {
-    const error43 = import_graphql50.locatedError(rawError, fieldNodes, pathToArray(itemPath));
+    const error43 = import_graphql49.locatedError(rawError, fieldNodes, pathToArray(itemPath));
     const value = handleFieldError(error43, itemType, asyncPayloadRecord.errors);
     filterSubsequentPayloads(exeContext, itemPath, asyncPayloadRecord);
     return { done: false, value };
@@ -78049,20 +78103,20 @@ function isStreamPayload(asyncPayload) {
 }
 function getFieldDef(schema, parentType, fieldNode) {
   const fieldName = fieldNode.name.value;
-  if (fieldName === import_graphql50.SchemaMetaFieldDef.name && schema.getQueryType() === parentType) {
-    return import_graphql50.SchemaMetaFieldDef;
-  } else if (fieldName === import_graphql50.TypeMetaFieldDef.name && schema.getQueryType() === parentType) {
-    return import_graphql50.TypeMetaFieldDef;
-  } else if (fieldName === import_graphql50.TypeNameMetaFieldDef.name) {
-    return import_graphql50.TypeNameMetaFieldDef;
+  if (fieldName === import_graphql49.SchemaMetaFieldDef.name && schema.getQueryType() === parentType) {
+    return import_graphql49.SchemaMetaFieldDef;
+  } else if (fieldName === import_graphql49.TypeMetaFieldDef.name && schema.getQueryType() === parentType) {
+    return import_graphql49.TypeMetaFieldDef;
+  } else if (fieldName === import_graphql49.TypeNameMetaFieldDef.name) {
+    return import_graphql49.TypeNameMetaFieldDef;
   }
   return parentType.getFields()[fieldName];
 }
 
 // ../../node_modules/.bun/@graphql-tools+executor@1.4.9+ded46c799560c44e/node_modules/@graphql-tools/executor/esm/execution/normalizedExecutor.js
-var import_graphql51 = __toESM(require_graphql2(), 1);
+var import_graphql50 = __toESM(require_graphql2(), 1);
 function normalizedExecutor(args) {
-  const operationAST = import_graphql51.getOperationAST(args.document, args.operationName);
+  const operationAST = import_graphql50.getOperationAST(args.document, args.operationName);
   if (operationAST == null) {
     throw new Error("Must provide an operation.");
   }
@@ -78090,9 +78144,9 @@ var executorFromSchema = memoize1(function executorFromSchema2(schema) {
   };
 });
 
-// ../../node_modules/.bun/@graphql-tools+batch-execute@9.0.19+ded46c799560c44e/node_modules/@graphql-tools/batch-execute/dist/index.js
+// ../../node_modules/.bun/@graphql-tools+batch-execute@10.0.0+ded46c799560c44e/node_modules/@graphql-tools/batch-execute/dist/index.js
 var import_dataloader = __toESM(require_dataloader(), 1);
-var import_graphql52 = __toESM(require_graphql2(), 1);
+var import_graphql51 = __toESM(require_graphql2(), 1);
 function createPrefix(index) {
   return `_v${index}_`;
 }
@@ -78128,6 +78182,10 @@ function parseKeyFromPath(path2) {
   };
 }
 function mergeRequests(requests, extensionsReducer) {
+  if (requests.length === 1) {
+    return requests[0];
+  }
+  const subgraphName = requests[0].subgraphName;
   const mergedVariables = /* @__PURE__ */ Object.create(null);
   const mergedVariableDefinitions = [];
   const mergedSelections = [];
@@ -78158,24 +78216,25 @@ function mergeRequests(requests, extensionsReducer) {
   }
   const operationType = firstRequest.operationType ?? getOperationASTFromRequest(firstRequest).operation;
   const mergedOperationDefinition = {
-    kind: import_graphql52.Kind.OPERATION_DEFINITION,
+    kind: import_graphql51.Kind.OPERATION_DEFINITION,
     operation: operationType,
     variableDefinitions: mergedVariableDefinitions,
     selectionSet: {
-      kind: import_graphql52.Kind.SELECTION_SET,
+      kind: import_graphql51.Kind.SELECTION_SET,
       selections: mergedSelections
     }
   };
   const operationName = firstRequest.operationName ?? firstRequest.info?.operation?.name?.value;
   if (operationName) {
     mergedOperationDefinition.name = {
-      kind: import_graphql52.Kind.NAME,
+      kind: import_graphql51.Kind.NAME,
       value: operationName
     };
   }
   return {
+    subgraphName,
     document: {
-      kind: import_graphql52.Kind.DOCUMENT,
+      kind: import_graphql51.Kind.DOCUMENT,
       definitions: [mergedOperationDefinition, ...mergedFragmentDefinitions]
     },
     variables: mergedVariables,
@@ -78201,13 +78260,13 @@ function prefixRequest(prefix, request) {
   const fragmentSpreadImpl = {};
   let hasFragments = false;
   if (hasFragmentDefinitionsOrVariables) {
-    prefixedDocument = import_graphql52.visit(prefixedDocument, {
-      [import_graphql52.Kind.VARIABLE]: prefixNode,
-      [import_graphql52.Kind.FRAGMENT_DEFINITION](node) {
+    prefixedDocument = import_graphql51.visit(prefixedDocument, {
+      [import_graphql51.Kind.VARIABLE]: prefixNode,
+      [import_graphql51.Kind.FRAGMENT_DEFINITION](node) {
         hasFragments = true;
         return prefixNode(node);
       },
-      [import_graphql52.Kind.FRAGMENT_SPREAD]: (node) => {
+      [import_graphql51.Kind.FRAGMENT_SPREAD]: (node) => {
         node = prefixNodeName(node, prefix);
         fragmentSpreadImpl[node.name.value] = true;
         return node;
@@ -78235,7 +78294,7 @@ function prefixRequest(prefix, request) {
 }
 function aliasTopLevelFields(prefix, document) {
   const transformer = {
-    [import_graphql52.Kind.OPERATION_DEFINITION]: (def) => {
+    [import_graphql51.Kind.OPERATION_DEFINITION]: (def) => {
       const { selections } = def.selectionSet;
       return {
         ...def,
@@ -78246,20 +78305,20 @@ function aliasTopLevelFields(prefix, document) {
       };
     }
   };
-  return import_graphql52.visit(document, transformer, {
-    [import_graphql52.Kind.DOCUMENT]: [`definitions`]
+  return import_graphql51.visit(document, transformer, {
+    [import_graphql51.Kind.DOCUMENT]: [`definitions`]
   });
 }
 function aliasFieldsInSelection(prefix, selections, document) {
   return selections.map((selection) => {
     switch (selection.kind) {
-      case import_graphql52.Kind.INLINE_FRAGMENT:
+      case import_graphql51.Kind.INLINE_FRAGMENT:
         return aliasFieldsInInlineFragment(prefix, selection, document);
-      case import_graphql52.Kind.FRAGMENT_SPREAD: {
+      case import_graphql51.Kind.FRAGMENT_SPREAD: {
         const inlineFragment = inlineFragmentSpread(selection, document);
         return aliasFieldsInInlineFragment(prefix, inlineFragment, document);
       }
-      case import_graphql52.Kind.FIELD:
+      case import_graphql51.Kind.FIELD:
       default:
         return aliasField(selection, prefix);
     }
@@ -78282,7 +78341,7 @@ function inlineFragmentSpread(spread, document) {
   }
   const { typeCondition, selectionSet } = fragment;
   return {
-    kind: import_graphql52.Kind.INLINE_FRAGMENT,
+    kind: import_graphql51.Kind.INLINE_FRAGMENT,
     typeCondition,
     selectionSet,
     directives: spread.directives
@@ -78308,10 +78367,10 @@ function aliasField(field, aliasPrefix) {
   };
 }
 function isOperationDefinition(def) {
-  return def.kind === import_graphql52.Kind.OPERATION_DEFINITION;
+  return def.kind === import_graphql51.Kind.OPERATION_DEFINITION;
 }
 function isFragmentDefinition(def) {
-  return def.kind === import_graphql52.Kind.FRAGMENT_DEFINITION;
+  return def.kind === import_graphql51.Kind.FRAGMENT_DEFINITION;
 }
 function splitResult({ data, errors: errors5 }, numResults) {
   const splitResults = new Array(numResults);
@@ -78407,7 +78466,7 @@ var getBatchingExecutor = memoize2of4(function getBatchingExecutor2(_context, ex
   return createBatchingExecutor(executor2, dataLoaderOptions, extensionsReducer);
 });
 
-// ../../node_modules/.bun/@graphql-tools+delegate@10.2.23+ded46c799560c44e/node_modules/@graphql-tools/delegate/dist/index.js
+// ../../node_modules/.bun/@graphql-tools+delegate@11.0.0+ded46c799560c44e/node_modules/@graphql-tools/delegate/dist/index.js
 var applySchemaTransforms = memoize2(function applySchemaTransforms2(originalWrappingSchema, subschemaConfig) {
   const schemaTransforms = subschemaConfig.transforms;
   if (schemaTransforms == null) {
@@ -78505,14 +78564,14 @@ function handleResolverResult(resolverResult, subschema, selectionSet, object3,
     const nullResult = {};
     for (const [responseKey, fieldNodes] of fields2) {
       const combinedPath = [...path2, responseKey];
-      if (resolverResult instanceof import_graphql53.GraphQLError) {
+      if (resolverResult instanceof import_graphql52.GraphQLError) {
         if (resolverResult.message.includes("Cannot return null for non-nullable field")) {
           nullResult[responseKey] = null;
         } else {
           nullResult[responseKey] = relocatedError(resolverResult, combinedPath);
         }
       } else if (resolverResult instanceof Error) {
-        nullResult[responseKey] = import_graphql53.locatedError(resolverResult, fieldNodes, combinedPath);
+        nullResult[responseKey] = import_graphql52.locatedError(resolverResult, fieldNodes, combinedPath);
       } else {
         nullResult[responseKey] = null;
       }
@@ -78531,7 +78590,7 @@ function handleResolverResult(resolverResult, subschema, selectionSet, object3,
     }
     const existingPropValue = object3[responseKey];
     const sourcePropValue = resolverResult[responseKey];
-    if (responseKey === "__typename" && existingPropValue !== sourcePropValue && import_graphql53.isAbstractType(subschema.transformedSchema.getType(sourcePropValue))) {
+    if (responseKey === "__typename" && existingPropValue !== sourcePropValue && import_graphql52.isAbstractType(subschema.transformedSchema.getType(sourcePropValue))) {
       continue;
     }
     if (sourcePropValue != null || existingPropValue == null) {
@@ -78578,22 +78637,22 @@ function executeDelegationStage(mergedTypeInfo, delegationMap, object3, context,
   }
 }
 function resolveExternalValue(result, unpathedErrors, subschema, context, info, returnType = getReturnType$1(info), skipTypeMerging) {
-  const type = import_graphql53.getNullableType(returnType);
+  const type = import_graphql52.getNullableType(returnType);
   if (result instanceof Error) {
     return result;
   }
   if (result == null) {
     return reportUnpathedErrorsViaNull(unpathedErrors);
   }
-  if (import_graphql53.isLeafType(type)) {
+  if (import_graphql52.isLeafType(type)) {
     try {
       return type.parseValue(result);
     } catch {
       return null;
     }
-  } else if (import_graphql53.isCompositeType(type)) {
+  } else if (import_graphql52.isCompositeType(type)) {
     return handleMaybePromise(() => resolveExternalObject(type, result, unpathedErrors, subschema, context, info, skipTypeMerging), (result2) => {
-      if (info && import_graphql53.isAbstractType(type)) {
+      if (info && import_graphql52.isAbstractType(type)) {
         if (result2.__typename != null) {
           const resolvedType = info.schema.getType(result2.__typename);
           if (!resolvedType) {
@@ -78604,7 +78663,7 @@ function resolveExternalValue(result, unpathedErrors, subschema, context, info,
       }
       return result2;
     });
-  } else if (import_graphql53.isListType(type)) {
+  } else if (import_graphql52.isListType(type)) {
     if (Array.isArray(result)) {
       return resolveExternalList(type, result, unpathedErrors, subschema, context, info, skipTypeMerging);
     }
@@ -78651,9 +78710,9 @@ function reportUnpathedErrorsViaNull(unpathedErrors) {
     if (unreportedErrors.length) {
       const unreportedError = unreportedErrors[0];
       if (unreportedErrors.length === 1 && unreportedError) {
-        return import_graphql53.locatedError(unreportedError, undefined, unreportedError.path);
+        return import_graphql52.locatedError(unreportedError, undefined, unreportedError.path);
       }
-      return new AggregateError(unreportedErrors.map((e3) => import_graphql53.locatedError(e3, undefined, unreportedError?.path)), unreportedErrors.map((error43) => error43.message).join(`, 
+      return new AggregateError(unreportedErrors.map((e3) => import_graphql52.locatedError(e3, undefined, unreportedError?.path)), unreportedErrors.map((error43) => error43.message).join(`, 
 `));
     }
   }
@@ -78678,7 +78737,7 @@ function checkResultAndHandleErrors(result = {
     skipTypeMerging,
     onLocatedError
   } = delegationContext;
-  const { data, unpathedErrors } = mergeDataAndErrors(result.data == null ? undefined : result.data[responseKey], result.errors == null ? [] : result.errors, info != null && info.path ? import_graphql53.responsePathAsArray(info.path) : undefined, onLocatedError);
+  const { data, unpathedErrors } = mergeDataAndErrors(result.data == null ? undefined : result.data[responseKey], result.errors == null ? [] : result.errors, info != null && info.path ? import_graphql52.responsePathAsArray(info.path) : undefined, onLocatedError);
   return resolveExternalValue(data, unpathedErrors, subschema, context, info, returnType, skipTypeMerging);
 }
 function mergeDataAndErrors(data, errors5, path2, onLocatedError, index = 1) {
@@ -78747,10 +78806,10 @@ function getDocumentMetadata(document) {
   const fragmentNames = /* @__PURE__ */ new Set;
   for (let i = 0;i < document.definitions.length; i++) {
     const def = document.definitions[i];
-    if (def?.kind === import_graphql53.Kind.FRAGMENT_DEFINITION) {
+    if (def?.kind === import_graphql52.Kind.FRAGMENT_DEFINITION) {
       fragments.push(def);
       fragmentNames.add(def.name.value);
-    } else if (def?.kind === import_graphql53.Kind.OPERATION_DEFINITION) {
+    } else if (def?.kind === import_graphql52.Kind.OPERATION_DEFINITION) {
       operations.push(def);
     }
   }
@@ -78761,32 +78820,32 @@ function getDocumentMetadata(document) {
   };
 }
 var getTypeInfo = memoize1(function getTypeInfo2(schema) {
-  return new import_graphql53.TypeInfo(schema);
+  return new import_graphql52.TypeInfo(schema);
 });
 var getTypeInfoWithType = memoize2(function getTypeInfoWithType2(schema, type) {
-  return import_graphql53.versionInfo.major < 16 ? new import_graphql53.TypeInfo(schema, undefined, type) : new import_graphql53.TypeInfo(schema, type);
+  return import_graphql52.versionInfo.major < 16 ? new import_graphql52.TypeInfo(schema, undefined, type) : new import_graphql52.TypeInfo(schema, type);
 });
 function updateArgument2(argumentNodes, variableDefinitionsMap, variableValues, argName, varName, type, value) {
   argumentNodes[argName] = {
-    kind: import_graphql53.Kind.ARGUMENT,
+    kind: import_graphql52.Kind.ARGUMENT,
     name: {
-      kind: import_graphql53.Kind.NAME,
+      kind: import_graphql52.Kind.NAME,
       value: argName
     },
     value: {
-      kind: import_graphql53.Kind.VARIABLE,
+      kind: import_graphql52.Kind.VARIABLE,
       name: {
-        kind: import_graphql53.Kind.NAME,
+        kind: import_graphql52.Kind.NAME,
         value: varName
       }
     }
   };
   variableDefinitionsMap[varName] = {
-    kind: import_graphql53.Kind.VARIABLE_DEFINITION,
+    kind: import_graphql52.Kind.VARIABLE_DEFINITION,
     variable: {
-      kind: import_graphql53.Kind.VARIABLE,
+      kind: import_graphql52.Kind.VARIABLE,
       name: {
-        kind: import_graphql53.Kind.NAME,
+        kind: import_graphql52.Kind.NAME,
         value: varName
       }
     },
@@ -78846,13 +78905,13 @@ function finalizeGatewayDocument(targetSchema, fragments, operations, onOverlapp
     fragmentSet = collectedFragmentSet;
     const variableDefinitions = (operation.variableDefinitions ?? []).filter((variable) => operationOrFragmentVariables.indexOf(variable.variable.name.value) !== -1);
     if (operation.operation === "subscription") {
-      selectionSet.selections = selectionSet.selections.filter((selection) => selection.kind !== import_graphql53.Kind.FIELD || selection.name.value !== "__typename");
+      selectionSet.selections = selectionSet.selections.filter((selection) => selection.kind !== import_graphql52.Kind.FIELD || selection.name.value !== "__typename");
     }
-    if (selectionSet.selections.length === 1 && selectionSet.selections[0] && selectionSet.selections[0].kind === import_graphql53.Kind.FIELD && selectionSet.selections[0].name.value === "__typename") {
+    if (selectionSet.selections.length === 1 && selectionSet.selections[0] && selectionSet.selections[0].kind === import_graphql52.Kind.FIELD && selectionSet.selections[0].name.value === "__typename") {
       continue;
     }
     newOperations.push({
-      kind: import_graphql53.Kind.OPERATION_DEFINITION,
+      kind: import_graphql52.Kind.OPERATION_DEFINITION,
       operation: operation.operation,
       name: operation.name,
       directives: operation.directives,
@@ -78868,14 +78927,14 @@ function finalizeGatewayDocument(targetSchema, fragments, operations, onOverlapp
     });
   }
   let newDocument = {
-    kind: import_graphql53.Kind.DOCUMENT,
+    kind: import_graphql52.Kind.DOCUMENT,
     definitions: [...newOperations, ...newFragments]
   };
   const stitchingInfo = delegationContext.info?.schema?.extensions?.["stitchingInfo"];
   if (stitchingInfo != null) {
     const typeInfo = getTypeInfo(targetSchema);
-    newDocument = import_graphql53.visit(newDocument, import_graphql53.visitWithTypeInfo(typeInfo, {
-      [import_graphql53.Kind.FIELD](fieldNode) {
+    newDocument = import_graphql52.visit(newDocument, import_graphql52.visitWithTypeInfo(typeInfo, {
+      [import_graphql52.Kind.FIELD](fieldNode) {
         const parentType = typeInfo.getParentType();
         if (parentType) {
           const parentTypeName = parentType.name;
@@ -78888,7 +78947,7 @@ function finalizeGatewayDocument(targetSchema, fragments, operations, onOverlapp
                 return {
                   ...fieldNode,
                   selectionSet: {
-                    kind: import_graphql53.Kind.SELECTION_SET,
+                    kind: import_graphql52.Kind.SELECTION_SET,
                     selections: [
                       ...providedSelection.selections,
                       ...fieldNode.selectionSet?.selections ?? []
@@ -78934,7 +78993,7 @@ function finalizeGatewayRequest(originalRequest, delegationContext, onOverlappin
   };
 }
 function isTypeNameField(selection) {
-  return selection.kind === import_graphql53.Kind.FIELD && !selection.alias && selection.name.value === "__typename";
+  return selection.kind === import_graphql52.Kind.FIELD && !selection.alias && selection.name.value === "__typename";
 }
 function filterTypenameFields(selections) {
   let hasTypeNameField = false;
@@ -78960,7 +79019,7 @@ function addVariablesToRootFields(targetSchema, operations, args) {
     const type = getDefinedRootType(targetSchema, operation.operation);
     const newSelections = [];
     for (const selection of operation.selectionSet.selections) {
-      if (selection.kind === import_graphql53.Kind.FIELD) {
+      if (selection.kind === import_graphql52.Kind.FIELD) {
         const argumentNodes = selection.arguments ?? [];
         const argumentNodeMap = argumentNodes.reduce((prev, argument) => ({
           ...prev,
@@ -78979,7 +79038,7 @@ function addVariablesToRootFields(targetSchema, operations, args) {
       }
     }
     const newSelectionSet = {
-      kind: import_graphql53.Kind.SELECTION_SET,
+      kind: import_graphql52.Kind.SELECTION_SET,
       selections: newSelections
     };
     return {
@@ -79027,9 +79086,9 @@ function collectFragmentVariables(targetSchema, fragmentSet, validFragments, val
       if (name && !(name in fragmentSet)) {
         fragmentSet[name] = true;
         newFragments.push({
-          kind: import_graphql53.Kind.FRAGMENT_DEFINITION,
+          kind: import_graphql52.Kind.FRAGMENT_DEFINITION,
           name: {
-            kind: import_graphql53.Kind.NAME,
+            kind: import_graphql52.Kind.NAME,
             value: name
           },
           typeCondition: fragment.typeCondition,
@@ -79069,8 +79128,8 @@ function finalizeSelectionSet(schema, type, validFragments, selectionSet, onOver
   const seenNonNullableMap = /* @__PURE__ */ new WeakMap;
   const seenNullableMap = /* @__PURE__ */ new WeakMap;
   const filteredSelectionSet = filterSelectionSet(schema, typeInfo, validFragments, selectionSet, onOverlappingAliases, usedFragments, seenNonNullableMap, seenNullableMap);
-  import_graphql53.visit(filteredSelectionSet, {
-    [import_graphql53.Kind.VARIABLE]: (variableNode) => {
+  import_graphql52.visit(filteredSelectionSet, {
+    [import_graphql52.Kind.VARIABLE]: (variableNode) => {
       usedVariables.push(variableNode.name.value);
     }
   }, variablesVisitorKeys);
@@ -79081,11 +79140,11 @@ function finalizeSelectionSet(schema, type, validFragments, selectionSet, onOver
   };
 }
 function filterSelectionSet(schema, typeInfo, validFragments, selectionSet, onOverlappingAliases, usedFragments, seenNonNullableMap, seenNullableMap) {
-  return import_graphql53.visit(selectionSet, import_graphql53.visitWithTypeInfo(typeInfo, {
-    [import_graphql53.Kind.FIELD]: {
+  return import_graphql52.visit(selectionSet, import_graphql52.visitWithTypeInfo(typeInfo, {
+    [import_graphql52.Kind.FIELD]: {
       enter: (node) => {
         const parentType = typeInfo.getParentType();
-        if (import_graphql53.isObjectType(parentType) || import_graphql53.isInterfaceType(parentType)) {
+        if (import_graphql52.isObjectType(parentType) || import_graphql52.isInterfaceType(parentType)) {
           const field = typeInfo.getFieldDef();
           if (!field) {
             return null;
@@ -79110,18 +79169,18 @@ function filterSelectionSet(schema, typeInfo, validFragments, selectionSet, onOv
             }
           }
         }
-        if (import_graphql53.isUnionType(parentType) && typeInfo.getType() == null) {
+        if (import_graphql52.isUnionType(parentType) && typeInfo.getType() == null) {
           const possibleTypeNames = [];
           const fieldName = node.name.value;
           for (const memberType of parentType.getTypes()) {
             const memberFields = memberType.getFields();
             const possibleField = memberFields[fieldName];
             if (possibleField != null) {
-              const namedType = import_graphql53.getNamedType(possibleField.type);
-              if (node.selectionSet?.selections?.length && import_graphql53.isLeafType(namedType)) {
+              const namedType = import_graphql52.getNamedType(possibleField.type);
+              if (node.selectionSet?.selections?.length && import_graphql52.isLeafType(namedType)) {
                 continue;
               }
-              if (!node.selectionSet?.selections?.length && import_graphql53.isCompositeType(namedType)) {
+              if (!node.selectionSet?.selections?.length && import_graphql52.isCompositeType(namedType)) {
                 continue;
               }
               possibleTypeNames.push(memberType.name);
@@ -79131,16 +79190,16 @@ function filterSelectionSet(schema, typeInfo, validFragments, selectionSet, onOv
             const spreads = possibleTypeNames.map((possibleTypeName) => {
               if (!node.selectionSet?.selections) {
                 return {
-                  kind: import_graphql53.Kind.INLINE_FRAGMENT,
+                  kind: import_graphql52.Kind.INLINE_FRAGMENT,
                   typeCondition: {
-                    kind: import_graphql53.Kind.NAMED_TYPE,
+                    kind: import_graphql52.Kind.NAMED_TYPE,
                     name: {
-                      kind: import_graphql53.Kind.NAME,
+                      kind: import_graphql52.Kind.NAME,
                       value: possibleTypeName
                     }
                   },
                   selectionSet: {
-                    kind: import_graphql53.Kind.SELECTION_SET,
+                    kind: import_graphql52.Kind.SELECTION_SET,
                     selections: [node]
                   }
                 };
@@ -79155,16 +79214,16 @@ function filterSelectionSet(schema, typeInfo, validFragments, selectionSet, onOv
                 return;
               }
               return {
-                kind: import_graphql53.Kind.INLINE_FRAGMENT,
+                kind: import_graphql52.Kind.INLINE_FRAGMENT,
                 typeCondition: {
-                  kind: import_graphql53.Kind.NAMED_TYPE,
+                  kind: import_graphql52.Kind.NAMED_TYPE,
                   name: {
-                    kind: import_graphql53.Kind.NAME,
+                    kind: import_graphql52.Kind.NAME,
                     value: possibleTypeName
                   }
                 },
                 selectionSet: {
-                  kind: import_graphql53.Kind.SELECTION_SET,
+                  kind: import_graphql52.Kind.SELECTION_SET,
                   selections: [
                     {
                       ...node,
@@ -79188,11 +79247,11 @@ function filterSelectionSet(schema, typeInfo, validFragments, selectionSet, onOv
         if (type == null) {
           return null;
         }
-        const namedType = import_graphql53.getNamedType(type);
+        const namedType = import_graphql52.getNamedType(type);
         if (schema.getType(namedType.name) == null) {
           return null;
         }
-        if (import_graphql53.isObjectType(namedType) || import_graphql53.isInterfaceType(namedType)) {
+        if (import_graphql52.isObjectType(namedType) || import_graphql52.isInterfaceType(namedType)) {
           const selections = node.selectionSet != null ? node.selectionSet.selections : null;
           if (selections == null || selections.length === 0) {
             return null;
@@ -79201,7 +79260,7 @@ function filterSelectionSet(schema, typeInfo, validFragments, selectionSet, onOv
         return;
       }
     },
-    [import_graphql53.Kind.FRAGMENT_SPREAD]: {
+    [import_graphql52.Kind.FRAGMENT_SPREAD]: {
       enter: (node) => {
         if (!(node.name.value in validFragments)) {
           return null;
@@ -79215,15 +79274,15 @@ function filterSelectionSet(schema, typeInfo, validFragments, selectionSet, onOv
         return;
       }
     },
-    [import_graphql53.Kind.SELECTION_SET]: {
+    [import_graphql52.Kind.SELECTION_SET]: {
       enter: (node, _key, _parent, _path) => {
         const parentType = typeInfo.getParentType();
         const { hasTypeNameField, selections } = filterTypenameFields(node.selections);
-        if (hasTypeNameField || parentType != null && import_graphql53.isAbstractType(parentType)) {
+        if (hasTypeNameField || parentType != null && import_graphql52.isAbstractType(parentType)) {
           selections.unshift({
-            kind: import_graphql53.Kind.FIELD,
+            kind: import_graphql52.Kind.FIELD,
             name: {
-              kind: import_graphql53.Kind.NAME,
+              kind: import_graphql52.Kind.NAME,
               value: "__typename"
             }
           });
@@ -79234,12 +79293,12 @@ function filterSelectionSet(schema, typeInfo, validFragments, selectionSet, onOv
         };
       }
     },
-    [import_graphql53.Kind.INLINE_FRAGMENT]: {
+    [import_graphql52.Kind.INLINE_FRAGMENT]: {
       enter: (node) => {
         if (node.typeCondition != null) {
           const parentType = typeInfo.getParentType();
           const innerType = schema.getType(node.typeCondition.name.value);
-          if (import_graphql53.isUnionType(parentType) && parentType.getTypes().some((t) => t.name === innerType?.name)) {
+          if (import_graphql52.isUnionType(parentType) && parentType.getTypes().some((t) => t.name === innerType?.name)) {
             return node;
           }
           if (!implementsAbstractType(schema, parentType, innerType)) {
@@ -79273,13 +79332,13 @@ function filterSelectionSet(schema, typeInfo, validFragments, selectionSet, onOv
                 selectionSet: {
                   ...selection.selectionSet,
                   selections: selection.selectionSet.selections.map((subSelection) => {
-                    if (subSelection.kind === import_graphql53.Kind.FIELD) {
+                    if (subSelection.kind === import_graphql52.Kind.FIELD) {
                       const fieldName = subSelection.name.value;
                       if (!subSelection.alias) {
                         const field = selectionTypeFields[fieldName];
                         if (field) {
                           let currentNullable;
-                          if (import_graphql53.isNullableType(field.type)) {
+                          if (import_graphql52.isNullableType(field.type)) {
                             seenNullable.add(fieldName);
                             currentNullable = true;
                           } else {
@@ -79291,7 +79350,7 @@ function filterSelectionSet(schema, typeInfo, validFragments, selectionSet, onOv
                             return {
                               ...subSelection,
                               alias: {
-                                kind: import_graphql53.Kind.NAME,
+                                kind: import_graphql52.Kind.NAME,
                                 value: currentNullable ? `_nullable_${fieldName}` : `_nonNullable_${fieldName}`
                               }
                             };
@@ -79353,7 +79412,7 @@ function prepareGatewayDocument(originalDocument, transformedSchema, returnType,
   const { expandedFragments, fragmentReplacements } = getExpandedFragments(fragments, fragmentNames, possibleTypesMap);
   const typeInfo = getTypeInfo(transformedSchema);
   const expandedDocument = {
-    kind: import_graphql53.Kind.DOCUMENT,
+    kind: import_graphql52.Kind.DOCUMENT,
     definitions: [...operations, ...fragments, ...expandedFragments]
   };
   const visitorKeyMap = {
@@ -79364,8 +79423,8 @@ function prepareGatewayDocument(originalDocument, transformedSchema, returnType,
     InlineFragment: ["selectionSet"],
     FragmentDefinition: ["selectionSet"]
   };
-  return import_graphql53.visit(expandedDocument, import_graphql53.visitWithTypeInfo(typeInfo, {
-    [import_graphql53.Kind.SELECTION_SET]: (node) => visitSelectionSet(node, fragmentReplacements, transformedSchema, typeInfo, possibleTypesMap, reversePossibleTypesMap2, interfaceExtensionsMap, fieldNodesByType, fieldNodesByField, dynamicSelectionSetsByField, infoSchema, visitedSelections)
+  return import_graphql52.visit(expandedDocument, import_graphql52.visitWithTypeInfo(typeInfo, {
+    [import_graphql52.Kind.SELECTION_SET]: (node) => visitSelectionSet(node, fragmentReplacements, transformedSchema, typeInfo, possibleTypesMap, reversePossibleTypesMap2, interfaceExtensionsMap, fieldNodesByType, fieldNodesByField, dynamicSelectionSetsByField, infoSchema, visitedSelections)
   }), visitorKeyMap);
 }
 var getExtraPossibleTypesFn = memoize2(function getExtraPossibleTypes(transformedSchema, infoSchema) {
@@ -79376,7 +79435,7 @@ var getExtraPossibleTypesFn = memoize2(function getExtraPossibleTypes(transforme
       extraTypesForSubschema = /* @__PURE__ */ new Set;
       const gatewayType = infoSchema.getType(typeName);
       const subschemaType = transformedSchema.getType(typeName);
-      if (import_graphql53.isAbstractType(gatewayType) && import_graphql53.isAbstractType(subschemaType)) {
+      if (import_graphql52.isAbstractType(gatewayType) && import_graphql52.isAbstractType(subschemaType)) {
         const possibleTypes = infoSchema.getPossibleTypes(gatewayType);
         const possibleTypesInSubschema = transformedSchema.getPossibleTypes(subschemaType);
         for (const possibleType of possibleTypes) {
@@ -79399,7 +79458,7 @@ function visitSelectionSet(node, fragmentReplacements, transformedSchema, typeIn
   const newSelections = /* @__PURE__ */ new Set;
   const maybeType = typeInfo.getParentType();
   if (maybeType != null) {
-    const parentType = import_graphql53.getNamedType(maybeType);
+    const parentType = import_graphql52.getNamedType(maybeType);
     const parentTypeName = parentType.name;
     const fieldNodes = fieldNodesByType[parentTypeName];
     if (fieldNodes) {
@@ -79410,7 +79469,7 @@ function visitSelectionSet(node, fragmentReplacements, transformedSchema, typeIn
     const interfaceExtensions = interfaceExtensionsMap[parentType.name];
     const interfaceExtensionFields = [];
     for (const selection of node.selections) {
-      if (selection.kind === import_graphql53.Kind.INLINE_FRAGMENT) {
+      if (selection.kind === import_graphql52.Kind.INLINE_FRAGMENT) {
         if (selection.typeCondition != null) {
           if (!visitedSelections.has(selection)) {
             visitedSelections.add(selection);
@@ -79421,19 +79480,19 @@ function visitSelectionSet(node, fragmentReplacements, transformedSchema, typeIn
               newSelections.add({
                 ...selection,
                 typeCondition: {
-                  kind: import_graphql53.Kind.NAMED_TYPE,
+                  kind: import_graphql52.Kind.NAMED_TYPE,
                   name: {
-                    kind: import_graphql53.Kind.NAME,
+                    kind: import_graphql52.Kind.NAME,
                     value: extraPossibleTypeName
                   }
                 }
               });
             }
             const typeInSubschema = transformedSchema.getType(typeName);
-            if (import_graphql53.isObjectType(typeInSubschema) || import_graphql53.isInterfaceType(typeInSubschema)) {
+            if (import_graphql52.isObjectType(typeInSubschema) || import_graphql52.isInterfaceType(typeInSubschema)) {
               const fieldMap = typeInSubschema.getFields();
               for (const subSelection of selection.selectionSet.selections) {
-                if (subSelection.kind === import_graphql53.Kind.FIELD) {
+                if (subSelection.kind === import_graphql52.Kind.FIELD) {
                   const fieldName = subSelection.name.value;
                   const field = fieldMap[fieldName];
                   if (!field) {
@@ -79470,7 +79529,7 @@ function visitSelectionSet(node, fragmentReplacements, transformedSchema, typeIn
         } else {
           newSelections.add(selection);
         }
-      } else if (selection.kind === import_graphql53.Kind.FRAGMENT_SPREAD) {
+      } else if (selection.kind === import_graphql52.Kind.FRAGMENT_SPREAD) {
         const fragmentName = selection.name.value;
         if (!fragmentReplacements[fragmentName]) {
           newSelections.add(selection);
@@ -79481,9 +79540,9 @@ function visitSelectionSet(node, fragmentReplacements, transformedSchema, typeIn
           const maybeReplacementType = transformedSchema.getType(typeName);
           if (maybeReplacementType != null && implementsAbstractType(transformedSchema, parentType, maybeType)) {
             newSelections.add({
-              kind: import_graphql53.Kind.FRAGMENT_SPREAD,
+              kind: import_graphql52.Kind.FRAGMENT_SPREAD,
               name: {
-                kind: import_graphql53.Kind.NAME,
+                kind: import_graphql52.Kind.NAME,
                 value: replacement.fragmentName
               }
             });
@@ -79491,7 +79550,7 @@ function visitSelectionSet(node, fragmentReplacements, transformedSchema, typeIn
         }
       } else {
         const fieldName = selection.name.value;
-        if (import_graphql53.isAbstractType(parentType)) {
+        if (import_graphql52.isAbstractType(parentType)) {
           const fieldNodesForTypeName = fieldNodesByField[parentTypeName]?.["__typename"];
           if (fieldNodesForTypeName) {
             for (const fieldNode of fieldNodesForTypeName) {
@@ -79523,9 +79582,9 @@ function visitSelectionSet(node, fragmentReplacements, transformedSchema, typeIn
     }
     if (reversePossibleTypesMap2[parentType.name]) {
       newSelections.add({
-        kind: import_graphql53.Kind.FIELD,
+        kind: import_graphql52.Kind.FIELD,
         name: {
-          kind: import_graphql53.Kind.NAME,
+          kind: import_graphql52.Kind.NAME,
           value: "__typename"
         }
       });
@@ -79535,7 +79594,7 @@ function visitSelectionSet(node, fragmentReplacements, transformedSchema, typeIn
       if (possibleTypes != null) {
         for (const possibleType of possibleTypes) {
           newSelections.add(generateInlineFragment(possibleType, {
-            kind: import_graphql53.Kind.SELECTION_SET,
+            kind: import_graphql52.Kind.SELECTION_SET,
             selections: interfaceExtensionFields
           }));
         }
@@ -79563,11 +79622,11 @@ function addDependenciesNestedly(fieldNode, seenFieldNames, fieldNodesByField, n
 }
 function generateInlineFragment(typeName, selectionSet) {
   return {
-    kind: import_graphql53.Kind.INLINE_FRAGMENT,
+    kind: import_graphql52.Kind.INLINE_FRAGMENT,
     typeCondition: {
-      kind: import_graphql53.Kind.NAMED_TYPE,
+      kind: import_graphql52.Kind.NAMED_TYPE,
       name: {
-        kind: import_graphql53.Kind.NAME,
+        kind: import_graphql52.Kind.NAME,
         value: typeName
       }
     },
@@ -79581,9 +79640,9 @@ var getSchemaMetaData = memoize2((sourceSchema, targetSchema) => {
   const interfaceExtensionsMap = /* @__PURE__ */ Object.create(null);
   for (const typeName in typeMap) {
     const type = typeMap[typeName];
-    if (import_graphql53.isAbstractType(type)) {
+    if (import_graphql52.isAbstractType(type)) {
       const targetType = targetTypeMap[typeName];
-      if (import_graphql53.isInterfaceType(type) && import_graphql53.isInterfaceType(targetType)) {
+      if (import_graphql52.isInterfaceType(type) && import_graphql52.isInterfaceType(targetType)) {
         const targetTypeFields = targetType.getFields();
         const sourceTypeFields = type.getFields();
         const extensionFields = /* @__PURE__ */ Object.create(null);
@@ -79598,7 +79657,7 @@ var getSchemaMetaData = memoize2((sourceSchema, targetSchema) => {
           interfaceExtensionsMap[typeName] = extensionFields;
         }
       }
-      if (interfaceExtensionsMap[typeName] || !import_graphql53.isAbstractType(targetType)) {
+      if (interfaceExtensionsMap[typeName] || !import_graphql52.isAbstractType(targetType)) {
         const implementations = sourceSchema.getPossibleTypes(type);
         possibleTypesMap[typeName] = [];
         for (const impl of implementations) {
@@ -79655,15 +79714,15 @@ function getExpandedFragments(fragments, fragmentNames, possibleTypesMap) {
         const name = generateFragmentName(possibleTypeName);
         fragmentNames.add(name);
         expandedFragments.push({
-          kind: import_graphql53.Kind.FRAGMENT_DEFINITION,
+          kind: import_graphql52.Kind.FRAGMENT_DEFINITION,
           name: {
-            kind: import_graphql53.Kind.NAME,
+            kind: import_graphql52.Kind.NAME,
             value: name
           },
           typeCondition: {
-            kind: import_graphql53.Kind.NAMED_TYPE,
+            kind: import_graphql52.Kind.NAMED_TYPE,
             name: {
-              kind: import_graphql53.Kind.NAME,
+              kind: import_graphql52.Kind.NAME,
               value: possibleTypeName
             }
           },
@@ -79682,11 +79741,11 @@ function getExpandedFragments(fragments, fragmentNames, possibleTypesMap) {
   };
 }
 function wrapConcreteTypes(returnType, targetSchema, document) {
-  const namedType = import_graphql53.getNamedType(returnType);
-  if (import_graphql53.isLeafType(namedType)) {
+  const namedType = import_graphql52.getNamedType(returnType);
+  if (import_graphql52.isLeafType(namedType)) {
     return document;
   }
-  let possibleTypes = import_graphql53.isAbstractType(namedType) ? targetSchema.getPossibleTypes(namedType) : [namedType];
+  let possibleTypes = import_graphql52.isAbstractType(namedType) ? targetSchema.getPossibleTypes(namedType) : [namedType];
   if (possibleTypes.length === 0) {
     possibleTypes = [namedType];
   }
@@ -79699,29 +79758,29 @@ function wrapConcreteTypes(returnType, targetSchema, document) {
     InlineFragment: ["selectionSet"],
     FragmentDefinition: ["selectionSet"]
   };
-  return import_graphql53.visit(document, import_graphql53.visitWithTypeInfo(typeInfo, {
-    [import_graphql53.Kind.FRAGMENT_DEFINITION]: (node) => {
+  return import_graphql52.visit(document, import_graphql52.visitWithTypeInfo(typeInfo, {
+    [import_graphql52.Kind.FRAGMENT_DEFINITION]: (node) => {
       const typeName = node.typeCondition.name.value;
       if (!rootTypeNames.has(typeName)) {
         return false;
       }
       return;
     },
-    [import_graphql53.Kind.FIELD]: (node) => {
+    [import_graphql52.Kind.FIELD]: (node) => {
       const fieldType = typeInfo.getType();
       if (fieldType) {
-        const fieldNamedType = import_graphql53.getNamedType(fieldType);
-        if (import_graphql53.isAbstractType(fieldNamedType) && fieldNamedType.name !== namedType.name && possibleTypes.length > 0) {
+        const fieldNamedType = import_graphql52.getNamedType(fieldType);
+        if (import_graphql52.isAbstractType(fieldNamedType) && fieldNamedType.name !== namedType.name && possibleTypes.length > 0) {
           return {
             ...node,
             selectionSet: {
-              kind: import_graphql53.Kind.SELECTION_SET,
+              kind: import_graphql52.Kind.SELECTION_SET,
               selections: possibleTypes.map((possibleType) => ({
-                kind: import_graphql53.Kind.INLINE_FRAGMENT,
+                kind: import_graphql52.Kind.INLINE_FRAGMENT,
                 typeCondition: {
-                  kind: import_graphql53.Kind.NAMED_TYPE,
+                  kind: import_graphql52.Kind.NAMED_TYPE,
                   name: {
-                    kind: import_graphql53.Kind.NAME,
+                    kind: import_graphql52.Kind.NAME,
                     value: possibleType.name
                   }
                 },
@@ -79807,6 +79866,7 @@ function getDelegatingOperation(parentType, schema) {
   return "query";
 }
 function createRequest({
+  subgraphName,
   sourceSchema,
   sourceParentType,
   sourceFieldName,
@@ -79836,7 +79896,7 @@ function createRequest({
       }
     }
     newSelectionSet = selections.length ? {
-      kind: import_graphql53.Kind.SELECTION_SET,
+      kind: import_graphql52.Kind.SELECTION_SET,
       selections
     } : undefined;
     const args = fieldNodes?.[0]?.arguments;
@@ -79852,7 +79912,7 @@ function createRequest({
     for (const def of variableDefinitions) {
       const varName = def.variable.name.value;
       variableDefinitionMap[varName] = def;
-      const varType = import_graphql53.typeFromAST(sourceSchema, def.type);
+      const varType = import_graphql52.typeFromAST(sourceSchema, def.type);
       const serializedValue = serializeInputValue(varType, variableValues?.[varName]);
       if (serializedValue !== undefined) {
         newVariables[varName] = serializedValue;
@@ -79868,26 +79928,26 @@ function createRequest({
     throw new Error(`Either "targetFieldName" or a non empty "fieldNodes" array must be provided.`);
   }
   const rootfieldNode = {
-    kind: import_graphql53.Kind.FIELD,
+    kind: import_graphql52.Kind.FIELD,
     arguments: Object.values(argumentNodeMap),
     name: {
-      kind: import_graphql53.Kind.NAME,
+      kind: import_graphql52.Kind.NAME,
       value: rootFieldName
     },
     selectionSet: newSelectionSet,
     directives: fieldNode?.directives
   };
   const operationName = targetOperationName ? {
-    kind: import_graphql53.Kind.NAME,
+    kind: import_graphql52.Kind.NAME,
     value: targetOperationName
   } : undefined;
   const operationDefinition = {
-    kind: import_graphql53.Kind.OPERATION_DEFINITION,
+    kind: import_graphql52.Kind.OPERATION_DEFINITION,
     name: operationName,
     operation: targetOperation,
     variableDefinitions: Object.values(variableDefinitionMap),
     selectionSet: {
-      kind: import_graphql53.Kind.SELECTION_SET,
+      kind: import_graphql52.Kind.SELECTION_SET,
       selections: [rootfieldNode]
     }
   };
@@ -79901,10 +79961,11 @@ function createRequest({
     }
   }
   const document = {
-    kind: import_graphql53.Kind.DOCUMENT,
+    kind: import_graphql52.Kind.DOCUMENT,
     definitions
   };
   return {
+    subgraphName,
     document,
     variables: newVariables,
     rootValue: targetRootValue,
@@ -79937,7 +79998,7 @@ function defaultMergedResolver(parent, args, context, info) {
   }
   const responseKey = getResponseKeyFromInfo(info);
   if (!isExternalObject(parent)) {
-    return import_graphql53.defaultFieldResolver(parent, args, context, info);
+    return import_graphql52.defaultFieldResolver(parent, args, context, info);
   }
   if (!Object.prototype.hasOwnProperty.call(parent, responseKey)) {
     const leftOver = getPlanLeftOverFromParent(parent);
@@ -80007,7 +80068,7 @@ function handleLeftOver(parent, context, info, leftOver) {
       }
       if (selectionSets2.size) {
         const selectionSet = {
-          kind: import_graphql53.Kind.SELECTION_SET,
+          kind: import_graphql52.Kind.SELECTION_SET,
           selections: Array.from(selectionSets2).flatMap((selectionSet2) => selectionSet2.selections)
         };
         handleMaybePromise(() => flattenPromise(parent), (flattenedParent) => {
@@ -80025,7 +80086,7 @@ function handleFlattenedParent(flattenedParent, leftOverParent, possibleSubschem
       if (resolver) {
         Object.assign(leftOverParent, flattenedParent);
         const selectionSet2 = {
-          kind: import_graphql53.Kind.SELECTION_SET,
+          kind: import_graphql52.Kind.SELECTION_SET,
           selections: missingFieldNodes
         };
         handleMaybePromise(() => resolver(leftOverParent, context, info, possibleSubschema, selectionSet2, info.parentType, info.parentType), (resolverResult) => {
@@ -80035,7 +80096,7 @@ function handleFlattenedParent(flattenedParent, leftOverParent, possibleSubschem
     }
   } else {
     for (const selectionNode of selectionSet.selections) {
-      if (selectionNode.kind === import_graphql53.Kind.FIELD && selectionNode.selectionSet?.selections?.length) {
+      if (selectionNode.kind === import_graphql52.Kind.FIELD && selectionNode.selectionSet?.selections?.length) {
         const responseKey = selectionNode.alias?.value ?? selectionNode.name.value;
         const nestedParent = flattenedParent[responseKey];
         const nestedSelectionSet = selectionNode.selectionSet;
@@ -80053,7 +80114,7 @@ function handleFlattenedParent(flattenedParent, leftOverParent, possibleSubschem
                       if (resolver) {
                         const res = await resolver(nestedParentItem, context, info, subschema, selectionSet2, info.parentType, info.parentType);
                         if (res) {
-                          handleResolverResult(res, subschema, selectionSet2, nestedParentItem, nestedParentItem[FIELD_SUBSCHEMA_MAP_SYMBOL] ||= /* @__PURE__ */ new Map, info, import_graphql53.responsePathAsArray(info.path), nestedParentItem[UNPATHED_ERRORS_SYMBOL] ||= []);
+                          handleResolverResult(res, subschema, selectionSet2, nestedParentItem, nestedParentItem[FIELD_SUBSCHEMA_MAP_SYMBOL] ||= /* @__PURE__ */ new Map, info, import_graphql52.responsePathAsArray(info.path), nestedParentItem[UNPATHED_ERRORS_SYMBOL] ||= []);
                         }
                       }
                     }
@@ -80076,7 +80137,7 @@ function handleFlattenedParent(flattenedParent, leftOverParent, possibleSubschem
   }
 }
 function handleDeferredResolverResult(resolverResult, possibleSubschema, selectionSet, leftOverParent, leftOver, context, info) {
-  handleResolverResult(resolverResult, possibleSubschema, selectionSet, leftOverParent, leftOverParent[FIELD_SUBSCHEMA_MAP_SYMBOL], info, import_graphql53.responsePathAsArray(info.path), leftOverParent[UNPATHED_ERRORS_SYMBOL]);
+  handleResolverResult(resolverResult, possibleSubschema, selectionSet, leftOverParent, leftOverParent[FIELD_SUBSCHEMA_MAP_SYMBOL], info, import_graphql52.responsePathAsArray(info.path), leftOverParent[UNPATHED_ERRORS_SYMBOL]);
   const deferredFields = leftOver.missingFieldsParentDeferredMap.get(leftOverParent);
   if (deferredFields) {
     for (const [responseKey, deferred] of deferredFields) {
@@ -80118,7 +80179,7 @@ function parentSatisfiedSelectionSet(parent, selectionSet) {
   }
   const subschemas = /* @__PURE__ */ new Set;
   for (const selection of selectionSet.selections) {
-    if (selection.kind === import_graphql53.Kind.FIELD) {
+    if (selection.kind === import_graphql52.Kind.FIELD) {
       const responseKey = selection.alias?.value ?? selection.name.value;
       if (parent[responseKey] === undefined) {
         return;
@@ -80141,7 +80202,7 @@ function parentSatisfiedSelectionSet(parent, selectionSet) {
           subschemas.add(subschema);
         }
       }
-    } else if (selection.kind === import_graphql53.Kind.INLINE_FRAGMENT) {
+    } else if (selection.kind === import_graphql52.Kind.INLINE_FRAGMENT) {
       const inlineSatisfied = parentSatisfiedSelectionSet(parent, selection.selectionSet);
       if (inlineSatisfied === undefined) {
         return;
@@ -80205,6 +80266,7 @@ function delegateToSchema(options) {
     context
   } = options;
   const request = createRequest({
+    subgraphName: schema.name,
     sourceSchema: info.schema,
     sourceParentType: info.parentType,
     sourceFieldName: info.fieldName,
@@ -80242,7 +80304,7 @@ function delegateRequest(options) {
   }
   return handleMaybePromise(() => getExecutor(delegationContext)(processedRequest), function handleExecutorResult(executorResult) {
     if (isAsyncIterable(executorResult)) {
-      if (delegationContext.operation === "query" && import_graphql53.isListType(delegationContext.returnType)) {
+      if (delegationContext.operation === "query" && import_graphql52.isListType(delegationContext.returnType)) {
         return new Repeater(async (push2, stop2) => {
           const pushed = /* @__PURE__ */ new WeakSet;
           let stopped = false;
@@ -80353,7 +80415,7 @@ function getDelegationContext({
   };
 }
 function validateRequest(delegationContext, document) {
-  const errors5 = import_graphql53.validate(delegationContext.targetSchema, document);
+  const errors5 = import_graphql52.validate(delegationContext.targetSchema, document);
   if (errors5.length > 0) {
     if (errors5.length > 1) {
       const combinedError = new AggregateError(errors5, errors5.map((error210) => error210.message).join(`, 
@@ -80377,8 +80439,8 @@ function getExecutor(delegationContext) {
   return executor2;
 }
 
-// ../../node_modules/.bun/@graphql-tools+wrap@10.1.4+ded46c799560c44e/node_modules/@graphql-tools/wrap/dist/index.js
-var import_graphql54 = __toESM(require_graphql2(), 1);
+// ../../node_modules/.bun/@graphql-tools+wrap@11.0.0+ded46c799560c44e/node_modules/@graphql-tools/wrap/dist/index.js
+var import_graphql53 = __toESM(require_graphql2(), 1);
 function generateProxyingResolvers(subschemaConfig) {
   const targetSchema = subschemaConfig.schema;
   const createProxyingResolver = subschemaConfig.createProxyingResolver ?? defaultCreateProxyingResolver;
@@ -80464,21 +80526,21 @@ function createWrappingSchema(schema, proxyingResolvers) {
     },
     [MapperKind.OBJECT_TYPE]: (type) => {
       const config3 = type.toConfig();
-      return new import_graphql54.GraphQLObjectType({
+      return new import_graphql53.GraphQLObjectType({
         ...config3,
         isTypeOf: undefined
       });
     },
     [MapperKind.INTERFACE_TYPE]: (type) => {
       const config3 = type.toConfig();
-      return new import_graphql54.GraphQLInterfaceType({
+      return new import_graphql53.GraphQLInterfaceType({
         ...config3,
         resolveType: undefined
       });
     },
     [MapperKind.UNION_TYPE]: (type) => {
       const config3 = type.toConfig();
-      return new import_graphql54.GraphQLUnionType({
+      return new import_graphql53.GraphQLUnionType({
         ...config3,
         resolveType: undefined
       });
@@ -80492,14 +80554,14 @@ function createWrappingSchema(schema, proxyingResolvers) {
   });
 }
 var getTypeInfo3 = memoize1(function getTypeInfo22(schema) {
-  return new import_graphql54.TypeInfo(schema);
+  return new import_graphql53.TypeInfo(schema);
 });
 memoize2(function getTypeInfoWithType22(schema, type) {
-  return import_graphql54.versionInfo.major < 16 ? new import_graphql54.TypeInfo(schema, undefined, type) : new import_graphql54.TypeInfo(schema, type);
+  return import_graphql53.versionInfo.major < 16 ? new import_graphql53.TypeInfo(schema, undefined, type) : new import_graphql53.TypeInfo(schema, type);
 });
 function getSchemaFromIntrospection(introspectionResult, options) {
   if (introspectionResult?.data?.__schema) {
-    return import_graphql54.buildClientSchema(introspectionResult.data, options);
+    return import_graphql53.buildClientSchema(introspectionResult.data, options);
   }
   if (introspectionResult?.errors) {
     const graphqlErrors = introspectionResult.errors.map((error43) => createGraphQLError(error43.message, error43));
@@ -80513,7 +80575,7 @@ function getSchemaFromIntrospection(introspectionResult, options) {
  ${inspect(introspectionResult)}`);
 }
 function schemaFromExecutor(executor2, context, options) {
-  const parsedIntrospectionQuery = import_graphql54.parse(import_graphql54.getIntrospectionQuery(options), options);
+  const parsedIntrospectionQuery = import_graphql53.parse(import_graphql53.getIntrospectionQuery(options), options);
   return handleMaybePromise(() => handleMaybePromise(() => executor2({
     document: parsedIntrospectionQuery,
     context
@@ -80526,10 +80588,10 @@ function schemaFromExecutor(executor2, context, options) {
   }), (introspection) => getSchemaFromIntrospection(introspection, options));
 }
 
-// ../../node_modules/.bun/@graphql-tools+url-loader@8.0.33+ded46c799560c44e/node_modules/@graphql-tools/url-loader/esm/defaultAsyncFetch.js
+// ../../node_modules/.bun/@graphql-tools+url-loader@9.0.0+ded46c799560c44e/node_modules/@graphql-tools/url-loader/esm/defaultAsyncFetch.js
 var defaultAsyncFetch = $fetch;
 
-// ../../node_modules/.bun/@graphql-tools+url-loader@8.0.33+ded46c799560c44e/node_modules/@graphql-tools/url-loader/esm/defaultSyncFetch.js
+// ../../node_modules/.bun/@graphql-tools+url-loader@9.0.0+ded46c799560c44e/node_modules/@graphql-tools/url-loader/esm/defaultSyncFetch.js
 var import_sync_fetch = __toESM(require_sync_fetch(), 1);
 var defaultSyncFetch = (input, init) => {
   if (typeof input === "string") {
@@ -80540,7 +80602,7 @@ var defaultSyncFetch = (input, init) => {
   return import_sync_fetch.default(input, init);
 };
 
-// ../../node_modules/.bun/@graphql-tools+url-loader@8.0.33+ded46c799560c44e/node_modules/@graphql-tools/url-loader/esm/index.js
+// ../../node_modules/.bun/@graphql-tools+url-loader@9.0.0+ded46c799560c44e/node_modules/@graphql-tools/url-loader/esm/index.js
 var asyncImport = (moduleName) => import(`${moduleName}`);
 var syncImport = (moduleName) => __require(`${moduleName}`);
 var SubscriptionProtocol;
@@ -80692,7 +80754,7 @@ class UrlLoader {
       if (!source.schema && !source.document && !source.rawSDL) {
         throw new Error(`Invalid SDL response`);
       }
-      source.schema = source.schema || (source.document ? import_graphql55.buildASTSchema(source.document, options) : source.rawSDL ? import_graphql55.buildSchema(source.rawSDL, options) : undefined);
+      source.schema = source.schema || (source.document ? import_graphql54.buildASTSchema(source.document, options) : source.rawSDL ? import_graphql54.buildSchema(source.rawSDL, options) : undefined);
     } else {
       executor2 = this.getExecutorAsync(pointer, options);
       source.schema = await schemaFromExecutor(executor2, {}, options);
@@ -80726,7 +80788,7 @@ class UrlLoader {
       if (!source.schema && !source.document && !source.rawSDL) {
         throw new Error(`Invalid SDL response`);
       }
-      source.schema = source.schema || (source.document ? import_graphql55.buildASTSchema(source.document, options) : source.rawSDL ? import_graphql55.buildSchema(source.rawSDL, options) : undefined);
+      source.schema = source.schema || (source.document ? import_graphql54.buildASTSchema(source.document, options) : source.rawSDL ? import_graphql54.buildSchema(source.rawSDL, options) : undefined);
     } else {
       executor2 = this.getExecutorSync(pointer, options);
       source.schema = schemaFromExecutor(executor2, {}, options);
@@ -82135,7 +82197,7 @@ var portalQueries = (server, env3) => {
 var package_default = {
   name: "@settlemint/sdk-mcp",
   description: "MCP interface for SettleMint SDK, providing development tools and project management capabilities",
-  version: "2.6.2-prdbaefab2",
+  version: "2.6.2-prfaedf028",
   type: "module",
   private: false,
   license: "FSL-1.1-MIT",
@@ -82176,10 +82238,10 @@ var package_default = {
   dependencies: {
     "@commander-js/extra-typings": "14.0.0",
     "@graphql-tools/load": "8.1.2",
-    "@graphql-tools/url-loader": "8.0.33",
+    "@graphql-tools/url-loader": "9.0.0",
     "@modelcontextprotocol/sdk": "1.17.5",
-    "@settlemint/sdk-js": "2.6.2-prdbaefab2",
-    "@settlemint/sdk-utils": "2.6.2-prdbaefab2",
+    "@settlemint/sdk-js": "2.6.2-prfaedf028",
+    "@settlemint/sdk-utils": "2.6.2-prfaedf028",
     commander: "14.0.0",
     graphql: "16.11.0",
     zod: "^4",
@@ -82999,7 +83061,7 @@ var registerBlockchainConcepts = (server) => {
 };
 
 // src/utils/sdl.ts
-var import_graphql56 = __toESM(require_graphql2(), 1);
+var import_graphql55 = __toESM(require_graphql2(), 1);
 var processFieldTypes = (fields2, schema, collectedTypes) => {
   for (const field of Object.values(fields2)) {
     collectCustomTypes(field.type, schema, collectedTypes);
@@ -83020,7 +83082,7 @@ var collectCustomTypes = (type, schema, collectedTypes = new Set) => {
     return collectedTypes;
   }
   collectedTypes.add(typeName);
-  if (import_graphql56.isInputObjectType(schemaType) || import_graphql56.isObjectType(schemaType)) {
+  if (import_graphql55.isInputObjectType(schemaType) || import_graphql55.isObjectType(schemaType)) {
     const fields2 = schemaType.getFields();
     processFieldTypes(fields2, schema, collectedTypes);
   }
@@ -83030,7 +83092,7 @@ var generateTypeSDL = (typeName, schema) => {
   const type = schema[typeName];
   if (!type)
     return "";
-  if (import_graphql56.isInputObjectType(type)) {
+  if (import_graphql55.isInputObjectType(type)) {
     const fields2 = type.getFields();
     const fieldSDLs = Object.values(fields2).map((field) => `  ${field.name}: ${field.type}`).join(`
 `);
@@ -83038,7 +83100,7 @@ var generateTypeSDL = (typeName, schema) => {
 ${fieldSDLs}
 }`;
   }
-  if (import_graphql56.isObjectType(type)) {
+  if (import_graphql55.isObjectType(type)) {
     const fields2 = type.getFields();
     const fieldSDLs = Object.values(fields2).map((field) => {
       const args = field.args.length > 0 ? `(${field.args.map((arg) => `${arg.name}: ${arg.type}`).join(", ")})` : "";
@@ -83539,7 +83601,7 @@ var parseRawRequestArgs = (queryOrOptions, variables, requestHeaders) => {
 };
 
 // ../../node_modules/.bun/graphql-request@7.2.0+ded46c799560c44e/node_modules/graphql-request/build/legacy/lib/graphql.js
-var import_graphql57 = __toESM(require_graphql2(), 1);
+var import_graphql56 = __toESM(require_graphql2(), 1);
 
 // ../../node_modules/.bun/graphql-request@7.2.0+ded46c799560c44e/node_modules/graphql-request/build/lib/http.js
 var ACCEPT_HEADER = `Accept`;
@@ -83607,12 +83669,12 @@ var parseExecutionResult = (result) => {
 var isRequestResultHaveErrors = (result) => result._tag === `Batch` ? result.executionResults.some(isExecutionResultHaveErrors) : isExecutionResultHaveErrors(result.executionResult);
 var isExecutionResultHaveErrors = (result) => Array.isArray(result.errors) ? result.errors.length > 0 : Boolean(result.errors);
 var isOperationDefinitionNode = (definition) => {
-  return typeof definition === `object` && definition !== null && `kind` in definition && definition.kind === import_graphql57.Kind.OPERATION_DEFINITION;
+  return typeof definition === `object` && definition !== null && `kind` in definition && definition.kind === import_graphql56.Kind.OPERATION_DEFINITION;
 };
 
 // ../../node_modules/.bun/graphql-request@7.2.0+ded46c799560c44e/node_modules/graphql-request/build/legacy/helpers/analyzeDocument.js
+var import_graphql58 = __toESM(require_graphql2(), 1);
 var import_graphql59 = __toESM(require_graphql2(), 1);
-var import_graphql60 = __toESM(require_graphql2(), 1);
 var extractOperationName = (document) => {
   let operationName = undefined;
   const defs = document.definitions.filter(isOperationDefinitionNode);
@@ -83630,13 +83692,13 @@ var extractIsMutation = (document) => {
   return isMutation;
 };
 var analyzeDocument = (document, excludeOperationName) => {
-  const expression = typeof document === `string` ? document : import_graphql60.print(document);
+  const expression = typeof document === `string` ? document : import_graphql59.print(document);
   let isMutation = false;
   let operationName = undefined;
   if (excludeOperationName) {
     return { expression, isMutation, operationName };
   }
-  const docNode = tryCatch(() => typeof document === `string` ? import_graphql59.parse(document) : document);
+  const docNode = tryCatch(() => typeof document === `string` ? import_graphql58.parse(document) : document);
   if (docNode instanceof Error) {
     return { expression, isMutation, operationName };
   }
@@ -84910,6 +84972,7 @@ var createBlockchainNetwork = graphql(`
     $quorumGenesis: QuorumGenesisInput
     $externalNodes: [BlockchainNetworkExternalNodeInput!]
     $privateKeyId: ID
+    $includePredeployedContracts: Boolean
   ) {
     createBlockchainNetwork(
       applicationId: $applicationId
@@ -84938,6 +85001,7 @@ var createBlockchainNetwork = graphql(`
       quorumGenesis: $quorumGenesis
       externalNodes: $externalNodes
       keyMaterial: $privateKeyId
+      includePredeployedContracts: $includePredeployedContracts
     ) {
       ...BlockchainNetwork
     }
@@ -88246,4 +88310,4 @@ await main().catch((error44) => {
   process.exit(1);
 });
 
-//# debugId=7D28193A22B46C8264756E2164756E21
+//# debugId=8714F33C418BE3B264756E2164756E21