import { isOriginalGraphQLError, getInstrumented as getInstrumented$1 } from '@envelop/core';
export { withState } from '@envelop/core';
import { useDisableIntrospection } from '@envelop/disable-introspection';
import { useGenericAuth } from '@envelop/generic-auth';
import { createCDNArtifactFetcher, joinUrl } from '@graphql-hive/core';
import { Logger, LegacyLogger } from '@graphql-hive/logger';
export * from '@graphql-hive/logger';
import { millisecondsToStr, getOnSubgraphExecute, UnifiedGraphManager, restoreExtraDirectives, getTransportEntryMapUsingFusionAndFederationDirectives, getStitchingDirectivesTransformerForSubschema, handleFederationSubschema, handleResolveToDirectives } from '@graphql-mesh/fusion-runtime';
export { getExecutorForUnifiedGraph, getSdkRequesterForUnifiedGraph } from '@graphql-mesh/fusion-runtime';
import { useHmacUpstreamSignature } from '@graphql-mesh/hmac-upstream-signature';
export * from '@graphql-mesh/hmac-upstream-signature';
import useMeshResponseCache from '@graphql-mesh/plugin-response-cache';
import { isUrl, readFileOrUrl, defaultImportFn, getHeadersObj, isDisposable, dispose, getInContextSDK, pathExists } from '@graphql-mesh/utils';
import { batchDelegateToSchema } from '@graphql-tools/batch-delegate';
import { getTypeInfo, EMPTY_OBJECT, delegateToSchema, defaultMergedResolver } from '@graphql-tools/delegate';
import { defaultPrintFn as defaultPrintFn$1 } from '@graphql-tools/executor-common';
import { getDirectiveExtensions, memoize1, mergeDeep, isValidPath, pathToArray, memoize3, getDirective, createGraphQLError, isAsyncIterable, mapAsyncIterator, createDeferred, isPromise, isDocumentNode, asArray, printSchemaWithDirectives, parseSelectionSet } from '@graphql-tools/utils';
import { schemaFromExecutor, wrapSchema } from '@graphql-tools/wrap';
import { useCSRFPrevention } from '@graphql-yoga/plugin-csrf-prevention';
import { useDeferStream } from '@graphql-yoga/plugin-defer-stream';
import { usePersistedOperations } from '@graphql-yoga/plugin-persisted-operations';
import { AsyncDisposableStack } from '@whatwg-node/disposablestack';
export * from '@whatwg-node/disposablestack';
import { handleMaybePromise, iterateAsync } from '@whatwg-node/promise-helpers';
import { useCookies } from '@whatwg-node/server-plugin-cookies';
import { print, visit, visitWithTypeInfo, getArgumentValues, getNamedType, isIntrospectionType, isListType, isCompositeType, getOperationAST, isSchema, parse, buildSchema, buildASTSchema } from 'graphql';
import { isAsyncIterable as isAsyncIterable$1, useReadinessCheck, useExecutionCancellation, createYoga, chain, mergeSchemas } from 'graphql-yoga';
import { DEFAULT_UPLINKS, fetchSupergraphSdlFromManagedFederation } from '@graphql-tools/federation';
import { useApolloUsageReport } from '@graphql-yoga/plugin-apollo-usage-report';
import { useHive } from '@graphql-hive/yoga';
import { useContentEncoding as useContentEncoding$1 } from '@whatwg-node/server';
import { defaultPrintFn } from '@graphql-mesh/transport-common';
import { abortSignalAny } from '@graphql-hive/signal';
import { getInstrumented } from '@envelop/instrumentation';
import { path, fs } from '@graphql-mesh/cross-helpers';

function createLoggerFromLogging(logging) {
  if (logging == null || typeof logging === "boolean") {
    return new Logger({ level: logging === false ? false : "info" });
  }
  if (typeof logging === "string") {
    return new Logger({ level: logging });
  }
  return logging;
}

function getEnvStr(key, opts = {}) {
  const globalThat = opts.globalThis ?? globalThis;
  let variable = globalThat.process?.env?.[key] || // @ts-expect-error can exist in wrangler and maybe other runtimes
  globalThat.env?.[key] || // @ts-expect-error can exist in deno
  globalThat.Deno?.env?.get(key) || // @ts-expect-error could be
  globalThat[key];
  if (variable != null) {
    variable += "";
  } else {
    variable = void 0;
  }
  return variable?.trim();
}
function getNodeEnv(opts = {}) {
  return getEnvStr("NODE_ENV", opts);
}

function checkIfDataSatisfiesSelectionSet(selectionSet, data) {
  if (Array.isArray(data)) {
    return data.every(
      (item) => checkIfDataSatisfiesSelectionSet(selectionSet, item)
    );
  }
  for (const selection of selectionSet.selections) {
    if (selection.kind === "Field") {
      const field = selection;
      const responseKey = field.alias?.value || field.name.value;
      if (data[responseKey] != null) {
        if (field.selectionSet) {
          if (!checkIfDataSatisfiesSelectionSet(
            field.selectionSet,
            data[field.name.value]
          )) {
            return false;
          }
        }
      } else {
        return false;
      }
    } else if (selection.kind === "InlineFragment") {
      const inlineFragment = selection;
      if (!checkIfDataSatisfiesSelectionSet(inlineFragment.selectionSet, data)) {
        return false;
      }
    }
  }
  return true;
}
const defaultQueryText = (
  /* GraphQL */
  `
  # Welcome to GraphiQL
  # GraphiQL is an in-browser tool for writing, validating,
  # and testing GraphQL queries.
  #
  # Type queries into this side of the screen, and you will
  # see intelligent typeaheads aware of the current GraphQL
  # type schema and live syntax and validation errors
  # highlighted within the text.
  #
  # GraphQL queries typically start with a "{" character.
  # Lines that start with a # are ignored.
  #
  # An example GraphQL query might look like:
  #
  #     {
  #       field(arg: "value") {
  #         subField
  #       }
  #     }
  #
`
);
function delayInMs(ms, signal) {
  return new Promise((resolve, reject) => {
    globalThis.setTimeout(resolve, ms);
  });
}
const getExecuteFnFromExecutor = memoize1(
  function getExecuteFnFromExecutor2(executor) {
    return function executeFn(args) {
      return executor({
        document: args.document,
        variables: args.variableValues,
        operationName: args.operationName ?? void 0,
        rootValue: args.rootValue,
        context: args.contextValue,
        signal: args.signal,
        schemaCoordinateInErrors: args.schemaCoordinateInErrors
      });
    };
  }
);
function wrapCacheWithHooks({
  cache,
  onCacheGet,
  onCacheSet,
  onCacheDelete
}) {
  return new Proxy(cache, {
    get(target, prop, receiver) {
      switch (prop) {
        case "get": {
          if (onCacheGet.length === 0) {
            break;
          }
          return function cacheGet(key) {
            const onCacheGetResults = [];
            return handleMaybePromise(
              () => iterateAsync(
                onCacheGet,
                (onCacheGet2) => onCacheGet2({
                  key,
                  cache
                }),
                onCacheGetResults
              ),
              () => handleMaybePromise(
                () => target.get(key),
                (value) => value == null ? handleMaybePromise(
                  () => iterateAsync(
                    onCacheGetResults,
                    (onCacheGetResult) => onCacheGetResult?.onCacheMiss?.()
                  ),
                  () => value
                ) : handleMaybePromise(
                  () => iterateAsync(
                    onCacheGetResults,
                    (onCacheGetResult) => onCacheGetResult?.onCacheHit?.({ value })
                  ),
                  () => value
                ),
                (error) => handleMaybePromise(
                  () => iterateAsync(
                    onCacheGetResults,
                    (onCacheGetResult) => onCacheGetResult?.onCacheGetError?.({ error })
                  ),
                  () => {
                    throw error;
                  }
                )
              )
            );
          };
        }
        case "set": {
          if (onCacheSet.length === 0) {
            break;
          }
          return function cacheSet(key, value, opts) {
            const onCacheSetResults = [];
            return handleMaybePromise(
              () => iterateAsync(
                onCacheSet,
                (onCacheSet2) => onCacheSet2({
                  key,
                  value,
                  ttl: opts?.ttl,
                  cache
                }),
                onCacheSetResults
              ),
              () => handleMaybePromise(
                () => target.set(key, value, opts),
                (result) => handleMaybePromise(
                  () => iterateAsync(
                    onCacheSetResults,
                    (onCacheSetResult) => onCacheSetResult?.onCacheSetDone?.()
                  ),
                  () => result
                ),
                (err) => handleMaybePromise(
                  () => iterateAsync(
                    onCacheSetResults,
                    (onCacheSetResult) => onCacheSetResult?.onCacheSetError?.({ error: err })
                  ),
                  () => {
                    throw err;
                  }
                )
              )
            );
          };
        }
        case "delete": {
          if (onCacheDelete.length === 0) {
            break;
          }
          return function cacheDelete(key) {
            const onCacheDeleteResults = [];
            return handleMaybePromise(
              () => iterateAsync(
                onCacheDelete,
                (onCacheDelete2) => onCacheDelete2({
                  key,
                  cache
                })
              ),
              () => handleMaybePromise(
                () => target.delete(key),
                (result) => handleMaybePromise(
                  () => iterateAsync(
                    onCacheDeleteResults,
                    (onCacheDeleteResult) => onCacheDeleteResult?.onCacheDeleteDone?.()
                  ),
                  () => result
                )
              ),
              (err) => handleMaybePromise(
                () => iterateAsync(
                  onCacheDeleteResults,
                  (onCacheDeleteResult) => onCacheDeleteResult?.onCacheDeleteError?.({ error: err })
                ),
                () => {
                  throw err;
                }
              )
            );
          };
        }
      }
      return Reflect.get(target, prop, receiver);
    }
  });
}
function urlMatches(url, specUrl) {
  {
    return url === specUrl;
  }
}
function normalizeDirectiveName(directiveName) {
  if (directiveName.startsWith("@")) {
    return directiveName.slice(1);
  }
  return directiveName;
}
function getDirectiveNameForFederationDirective({
  schema,
  directiveName,
  specUrl
}) {
  const directivesOnSchemaDef = getDirectiveExtensions(schema, schema);
  const normalizedDirectiveName = normalizeDirectiveName(directiveName);
  if (directivesOnSchemaDef?.["link"]) {
    const linkDirectives = directivesOnSchemaDef["link"];
    for (const linkDirective of linkDirectives) {
      if (urlMatches(linkDirective.url, specUrl)) {
        const imports = linkDirective.import;
        if (imports) {
          for (const importDirective of imports) {
            if (typeof importDirective === "string") {
              const normalizedImportDirective = normalizeDirectiveName(importDirective);
              if (normalizedImportDirective === normalizedDirectiveName) {
                return normalizedImportDirective;
              }
            } else {
              const normalizedImportDirective = normalizeDirectiveName(
                importDirective.name
              );
              if (normalizedImportDirective === normalizedDirectiveName) {
                const normalizedAlias = normalizeDirectiveName(
                  importDirective.as
                );
                return normalizedAlias;
              }
            }
          }
        }
      }
    }
  }
  return normalizedDirectiveName;
}
const specs = [
  function extractPersistedOperationIdByApolloSpec(params) {
    const persistedQuery = params.extensions?.["persistedQuery"];
    if (persistedQuery != null && typeof persistedQuery === "object" && persistedQuery["version"] === 1 && typeof persistedQuery["sha256Hash"] === "string") {
      return persistedQuery["sha256Hash"];
    }
    return null;
  },
  function extractPersistedOperationIdByHiveSpec(params, request, _context) {
    if ("documentId" in params && typeof params.documentId === "string") {
      return params.documentId;
    }
    const documentId = new URL(request.url).searchParams.get("documentId");
    if (documentId) {
      return documentId;
    }
    return null;
  }
];
const defaultExtractPersistedOperationId = function defaultExtractPersistedOperationId2(params, request, context) {
  for (const spec of specs) {
    const id = spec(params, request, context);
    if (id) {
      return id;
    }
  }
  return null;
};

const defaultLoadedPlacePrefix = "GraphOS Managed Federation";
function decideMaxRetries({
  graphosOpts,
  pollingInterval,
  minDelaySeconds,
  uplinks,
  initialSchemaExists
}) {
  let maxRetries = graphosOpts.maxRetries || Math.max(3, uplinks.length);
  if (initialSchemaExists && pollingInterval && pollingInterval <= minDelaySeconds * 1e3) {
    maxRetries = 1;
  }
  return maxRetries;
}
function createGraphOSFetcher({
  graphosOpts,
  configContext,
  pollingInterval
}) {
  let lastSeenId;
  let lastSupergraphSdl;
  let nextFetchTime;
  const uplinksParam = graphosOpts.upLink || getEnvStr("APOLLO_SCHEMA_CONFIG_DELIVERY_ENDPOINT");
  const uplinks = uplinksParam?.split(",").map((uplink) => uplink.trim()) || DEFAULT_UPLINKS;
  const log = configContext.log.child("[apolloGraphOSSupergraphFetcher] ");
  log.info({ uplinks }, "Using uplinks");
  let supergraphLoadedPlace = defaultLoadedPlacePrefix;
  if (graphosOpts.graphRef) {
    supergraphLoadedPlace += ` <br>${graphosOpts.graphRef}`;
  }
  let minDelaySeconds = 10;
  const uplinksToUse = [];
  return {
    supergraphLoadedPlace,
    unifiedGraphFetcher(transportContext) {
      const maxRetries = decideMaxRetries({
        graphosOpts,
        pollingInterval,
        minDelaySeconds,
        uplinks,
        initialSchemaExists: !!lastSupergraphSdl
      });
      let retries = maxRetries;
      function fetchSupergraphWithDelay() {
        if (nextFetchTime) {
          const currentTime = Date.now();
          if (nextFetchTime >= currentTime) {
            const delay = nextFetchTime - currentTime;
            log.info(
              `Fetching supergraph with delay ${millisecondsToStr(delay)}`
            );
            nextFetchTime = 0;
            return delayInMs(delay).then(fetchSupergraph);
          }
        }
        return fetchSupergraph();
      }
      function fetchSupergraph() {
        if (uplinksToUse.length === 0) {
          uplinksToUse.push(...uplinks);
        }
        retries--;
        const uplinkToUse = uplinksToUse.pop();
        const attemptMetadata = {
          uplink: uplinkToUse || "none"
        };
        if (maxRetries > 1) {
          attemptMetadata["attempt"] = `${maxRetries - retries}/${maxRetries}`;
        }
        const attemptLogger = log.child(attemptMetadata);
        attemptLogger.debug("Fetching supergraph");
        return handleMaybePromise(
          () => fetchSupergraphSdlFromManagedFederation({
            graphRef: graphosOpts.graphRef,
            apiKey: graphosOpts.apiKey,
            upLink: uplinkToUse,
            lastSeenId,
            fetch: transportContext.fetch || configContext.fetch,
            loggerByMessageLevel: {
              ERROR(message) {
                attemptLogger.error(message);
              },
              INFO(message) {
                attemptLogger.info(message);
              },
              WARN(message) {
                attemptLogger.warn(message);
              }
            }
          }),
          (result) => {
            if (result.minDelaySeconds) {
              minDelaySeconds = result.minDelaySeconds;
              attemptLogger.debug(`Setting min delay to ${minDelaySeconds}s`);
            }
            nextFetchTime = Date.now() + minDelaySeconds * 1e3;
            if ("error" in result && result.error) {
              attemptLogger.error(result.error.code, result.error.message);
            }
            if ("id" in result) {
              if (lastSeenId === result.id) {
                attemptLogger.debug("Supergraph is unchanged");
                return lastSupergraphSdl;
              }
              lastSeenId = result.id;
            }
            if ("supergraphSdl" in result && result.supergraphSdl) {
              attemptLogger.debug(
                `Fetched the new supergraph ${lastSeenId ? `with id ${lastSeenId}` : ""}`
              );
              lastSupergraphSdl = result.supergraphSdl;
            }
            if (!lastSupergraphSdl) {
              if (retries > 0) {
                return fetchSupergraphWithDelay();
              }
              throw new Error(
                `Failed to fetch supergraph SDL from '${uplinkToUse}': [${JSON.stringify(result)}]`
              );
            }
            return lastSupergraphSdl;
          },
          (err) => {
            nextFetchTime = Date.now() + minDelaySeconds * 1e3;
            if (retries > 0) {
              attemptLogger.error(err);
              return fetchSupergraphWithDelay();
            }
            if (lastSupergraphSdl) {
              attemptLogger.error(err);
              return lastSupergraphSdl;
            }
            if (err?.name === "TimeoutError") {
              throw new Error(`HTTP request to '${uplinkToUse}' timed out`);
            }
            throw err;
          }
        );
      }
      return fetchSupergraphWithDelay();
    }
  };
}

function getProxyExecutor({
  config,
  configContext,
  getSchema,
  onSubgraphExecuteHooks,
  transportExecutorStack,
  instrumentation
}) {
  const fakeTransportEntryMap = {};
  let subgraphName = "upstream";
  const onSubgraphExecute = getOnSubgraphExecute({
    onSubgraphExecuteHooks,
    transportEntryMap: new Proxy(fakeTransportEntryMap, {
      get(fakeTransportEntryMap2, subgraphNameProp) {
        if (!fakeTransportEntryMap2[subgraphNameProp]) {
          subgraphName = subgraphNameProp;
          fakeTransportEntryMap2[subgraphNameProp] = {
            kind: "http",
            subgraph: subgraphName.toString(),
            location: config.proxy?.endpoint,
            headers: config.proxy?.headers,
            options: config.proxy
          };
          if (config.transportEntries) {
            fakeTransportEntryMap2[subgraphNameProp] = mergeDeep([
              fakeTransportEntryMap2[subgraphNameProp],
              ...Object.values(config.transportEntries)
            ]);
          }
        }
        return fakeTransportEntryMap2[subgraphNameProp];
      }
    }),
    transportContext: {
      ...configContext,
      logger: LegacyLogger.from(configContext.log)
    },
    getSubgraphSchema: getSchema,
    transportExecutorStack,
    transports: config.transports,
    instrumentation
  });
  return function proxyExecutor(executionRequest) {
    return onSubgraphExecute(subgraphName, executionRequest);
  };
}

const defaultClientNameHeaders = [
  "graphql-client-name",
  "x-graphql-client-name"
];
const defaultClientVersionHeaders = [
  "graphql-client-version",
  "x-graphql-client-version"
];
function lookupHeader(headers, possibleNames) {
  if (headers == null) {
    return null;
  }
  for (const name of possibleNames) {
    const value = headers[name];
    if (value) {
      return value;
    }
  }
  return null;
}
function defaultClientInfoFactory(context) {
  const name = lookupHeader(context.headers, defaultClientNameHeaders);
  const version = lookupHeader(context.headers, defaultClientVersionHeaders);
  if (name) {
    return {
      name,
      version: version ?? "unknown"
    };
  }
  return null;
}
function useHiveConsole({
  enabled,
  token,
  ...options
}) {
  const agent = {
    name: "hive-gateway",
    version: globalThis.__VERSION__,
    fetch,
    ...options.agent
  };
  let usage = void 0;
  if (options.usage && typeof options.usage === "object") {
    usage = {
      ...options.usage,
      clientInfo: options.usage.clientInfo == null ? defaultClientInfoFactory : typeof options.usage.clientInfo === "object" ? () => (
        // @ts-expect-error clientInfo will be an object
        options.usage.clientInfo
      ) : options.usage.clientInfo
    };
  } else {
    usage = options.usage;
  }
  if (enabled && !token) {
    throw new Error("Hive plugin is enabled but the token is not provided");
  }
  return useHive({
    logger: options.log,
    printTokenInfo: false,
    ...options,
    enabled: !!enabled,
    token,
    agent,
    usage
  });
}

function getReportingPlugin(config, configContext, allowArbitraryDocuments = false) {
  if (config.reporting?.type === "hive") {
    const { target, ...reporting } = config.reporting;
    let usage = reporting.usage;
    if (usage === false) ; else {
      usage = {
        target,
        ...typeof usage === "object" ? { ...usage } : {}
      };
    }
    return useHiveConsole({
      log: configContext.log.child("[useHiveConsole] "),
      fetch: configContext.fetch,
      enabled: true,
      ...reporting,
      ...usage ? { usage } : {},
      ...config.persistedDocuments && "type" in config.persistedDocuments && config.persistedDocuments?.type === "hive" ? {
        experimental__persistedDocuments: {
          cdn: {
            endpoint: config.persistedDocuments.endpoint,
            accessToken: config.persistedDocuments.token
          },
          circuitBreaker: config.persistedDocuments.circuitBreaker,
          // Trick to satisfy the Hive Console plugin types
          allowArbitraryDocuments
        }
      } : {}
    });
  } else if (config.reporting?.type === "graphos" || !config.reporting && "supergraph" in config && typeof config.supergraph === "object" && "type" in config.supergraph && config.supergraph.type === "graphos") {
    if ("supergraph" in config && typeof config.supergraph === "object" && "type" in config.supergraph && config.supergraph.type === "graphos") {
      if (!config.reporting) {
        config.reporting = {
          type: "graphos",
          apiKey: config.supergraph.apiKey,
          graphRef: config.supergraph.graphRef
        };
      } else {
        config.reporting.apiKey ||= config.supergraph.apiKey;
        config.reporting.graphRef ||= config.supergraph.graphRef;
      }
    }
    const plugin = useApolloUsageReport({
      agentVersion: `hive-gateway@${globalThis.__VERSION__}`,
      ...config.reporting
    });
    return plugin;
  }
  return {};
}

function handleUnifiedGraphConfig(config, configContext) {
  return handleMaybePromise(
    () => typeof config === "function" ? config(configContext) : config,
    (schema) => handleUnifiedGraphSchema(schema, configContext)
  );
}
function handleUnifiedGraphSchema(unifiedGraphSchema, configContext) {
  if (typeof unifiedGraphSchema === "string" && (isValidPath(unifiedGraphSchema) || isUrl(unifiedGraphSchema))) {
    return readFileOrUrl(unifiedGraphSchema, {
      fetch: configContext.fetch,
      cwd: configContext.cwd,
      logger: LegacyLogger.from(configContext.log),
      allowUnknownExtensions: true,
      importFn: defaultImportFn
    });
  }
  return unifiedGraphSchema;
}

const iconBase64 = "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";
const logoSvg = '<svg viewBox="0 1 52 51" fill="currentColor"  xmlns="http://www.w3.org/2000/svg"  xmlnsXlink="http://www.w3.org/1999/xlink">  <defs>    <path id="hive-gateway-path" d="m25 .524872-7.7758.000001V13.6981c0 2.2382-1.8128 4.051-4.0509 4.051H0l7.2e-7 7.7758H8.48411c1.06096 0 2.07849-.4215 2.82859-1.1718l12.5159-12.5176C24.5786 11.0854 25 10.068 25 9.00727V.524872Zm2 0 7.7758.000001V13.6981c0 2.2382 1.8128 4.051 4.0509 4.051H52v7.7758h-8.4841c-1.061 0-2.0785-.4215-2.8286-1.1718L28.1714 11.8355C27.4214 11.0854 27 10.068 27 9.00727V.524872ZM25 52.5249h-7.7758V39.3516c0-2.2381-1.8128-4.0509-4.0509-4.0509H0l7.2e-7-7.7758H8.48411c1.06096 0 2.07849.4215 2.82859 1.1717l12.5159 12.5176c.75.7502 1.1714 1.7675 1.1714 2.8283v8.4824Zm2 0h7.7758V39.3516c0-2.2381 1.8128-4.0509 4.0509-4.0509H52v-7.7758h-8.4841c-1.061 0-2.0785.4215-2.8286 1.1717L28.1714 41.2142c-.75.7502-1.1714 1.7675-1.1714 2.8283v8.4824Zm2.8369-29.837H22.163v7.6739h7.6739v-7.6739Z"></path>    <clip-path id="hive-gateway-clip-path">      <use href="#hive-gateway-path"></use>    </clip-path>  </defs>  <use href="#hive-gateway-path" clip-path="url(#hive-gateway-clip-path)"></use></svg>';
const html = `<html lang=en><head><meta charset=utf-8><title>Welcome to __PRODUCT_NAME__</title><link rel="shortcut icon" type=image/png href=data:image/png;base64,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><link rel=stylesheet href=https://cdnjs.cloudflare.com/ajax/libs/highlight.js/11.11.1/styles/github.min.css><script src=https://cdnjs.cloudflare.com/ajax/libs/highlight.js/11.11.1/highlight.min.js><\/script><script src=https://cdnjs.cloudflare.com/ajax/libs/highlight.js/11.11.1/languages/typescript.min.js><\/script><script src=https://cdnjs.cloudflare.com/ajax/libs/highlight.js/11.11.1/languages/shell.min.js><\/script><script>hljs.highlightAll()<\/script><style>:root{--background-color:#a5c4cb;--background-light-color:#adcad0;--primary-color:#00342c;--accent-color:#e1ff00;--primary-light-color:#245850;--primary-light-hover-color:#3b736a}*{box-sizing:border-box}body,html{padding:50px 25px;margin:0;background-color:var(--background-color);color:var(--primary-color);font-family:-apple-system,BlinkMacSystemFont,'Segoe UI',Roboto,Helvetica,Arial,sans-serif,'Apple Color Emoji','Segoe UI Emoji','Segoe UI Symbol'}main{z-index:1;position:relative}footer{margin-top:50px;text-align:center}footer{display:flex;justify-content:center;align-items:center}.the-guild{display:flex;margin-left:5px;color:#000;width:3.2rem}.the-guild svg.logo{width:2em}.the-guild svg.name{margin-left:3px;width:2.5em}.watermark{z-index:0;position:absolute;overflow:hidden;top:0;left:0;width:100%;height:100%}a{color:var(--primary-color);font-weight:700}code{background-color:#fff;color:var(--primary-color);padding:4px;border-radius:4px;font-family:monospace}pre{max-width:100%}pre code{border-radius:16px}.hero{display:flex;flex-direction:column;align-items:center}.hero .logo{font-size:2rem;display:flex;flex-wrap:wrap;justify-content:center;gap:10px}.hero .logo svg{min-width:50px;max-width:50px}.hero .logo h1{margin:0;text-align:center}.hero .description{color:#245850;max-width:600px;text-align:center}.hero .links{display:flex;gap:10px;flex-wrap:wrap;justify-content:center}.content{position:relative;margin:50px auto;display:flex;flex-direction:column;max-width:800px;align-items:center}.content p{text-align:center}.shell{background-color:var(--background-light-color);border-radius:16px;display:flex;padding:6px 16px}.shell .dollar{margin-top:11px;margin-right:10px;color:var(--accent-color)}.shell .command{user-select:all}.curl code{padding-left:30px!important;background-color:var(--primary-light-color);color:#fff}.four-oh-four{position:relative;display:flex;flex-direction:column;align-items:center;border-radius:16px;margin:0 auto;padding:20px 30px;max-width:800px;opacity:.4;transition:opacity .3s ease-in-out}.four-oh-four:hover{opacity:1}.four-oh-four p{text-align:center}a.button{display:inline-block;padding:12px 24px;font-size:1.2rem;transition:background-color .1s ease-in-out;color:#fff;background-color:var(--primary-light-color);text-decoration:none;border-radius:8px;border:1px solid var(--primary-light-color)}a.button:hover{background-color:var(--primary-light-hover-color)}a.button.accent{color:#000;background-color:var(--accent-color)}a.button.accent:hover{background-color:#fff}</style></head><body id=body><div class=watermark><svg viewBox="0 1 52 51" fill=currentColor style=position:absolute;left:-20%;top:-10vh;width:40%;color:var(--background-light-color) xmlns=http://www.w3.org/2000/svg xmlns:xlink=http://www.w3.org/1999/xlink><defs><path id=hive-gateway-path d="m25 .524872-7.7758.000001V13.6981c0 2.2382-1.8128 4.051-4.0509 4.051H0l7.2e-7 7.7758H8.48411c1.06096 0 2.07849-.4215 2.82859-1.1718l12.5159-12.5176C24.5786 11.0854 25 10.068 25 9.00727V.524872Zm2 0 7.7758.000001V13.6981c0 2.2382 1.8128 4.051 4.0509 4.051H52v7.7758h-8.4841c-1.061 0-2.0785-.4215-2.8286-1.1718L28.1714 11.8355C27.4214 11.0854 27 10.068 27 9.00727V.524872ZM25 52.5249h-7.7758V39.3516c0-2.2381-1.8128-4.0509-4.0509-4.0509H0l7.2e-7-7.7758H8.48411c1.06096 0 2.07849.4215 2.82859 1.1717l12.5159 12.5176c.75.7502 1.1714 1.7675 1.1714 2.8283v8.4824Zm2 0h7.7758V39.3516c0-2.2381 1.8128-4.0509 4.0509-4.0509H52v-7.7758h-8.4841c-1.061 0-2.0785.4215-2.8286 1.1717L28.1714 41.2142c-.75.7502-1.1714 1.7675-1.1714 2.8283v8.4824Zm2.8369-29.837H22.163v7.6739h7.6739v-7.6739Z"></path><clipPath id=hive-gateway-clip-path><use href=#hive-gateway-path></use></clipPath></defs><use href=#hive-gateway-path clip-path=url(#hive-gateway-clip-path)></use></svg><svg viewBox="0 1 52 51" fill=currentColor style=position:absolute;right:-25%;bottom:5vh;width:50%;color:var(--background-light-color) xmlns=http://www.w3.org/2000/svg xmlns:xlink=http://www.w3.org/1999/xlink><defs><path id=hive-gateway-path d="m25 .524872-7.7758.000001V13.6981c0 2.2382-1.8128 4.051-4.0509 4.051H0l7.2e-7 7.7758H8.48411c1.06096 0 2.07849-.4215 2.82859-1.1718l12.5159-12.5176C24.5786 11.0854 25 10.068 25 9.00727V.524872Zm2 0 7.7758.000001V13.6981c0 2.2382 1.8128 4.051 4.0509 4.051H52v7.7758h-8.4841c-1.061 0-2.0785-.4215-2.8286-1.1718L28.1714 11.8355C27.4214 11.0854 27 10.068 27 9.00727V.524872ZM25 52.5249h-7.7758V39.3516c0-2.2381-1.8128-4.0509-4.0509-4.0509H0l7.2e-7-7.7758H8.48411c1.06096 0 2.07849.4215 2.82859 1.1717l12.5159 12.5176c.75.7502 1.1714 1.7675 1.1714 2.8283v8.4824Zm2 0h7.7758V39.3516c0-2.2381 1.8128-4.0509 4.0509-4.0509H52v-7.7758h-8.4841c-1.061 0-2.0785.4215-2.8286 1.1717L28.1714 41.2142c-.75.7502-1.1714 1.7675-1.1714 2.8283v8.4824Zm2.8369-29.837H22.163v7.6739h7.6739v-7.6739Z"></path><clipPath id=hive-gateway-clip-path><use href=#hive-gateway-path></use></clipPath></defs><use href=#hive-gateway-path clip-path=url(#hive-gateway-clip-path)></use></svg></div><main><section class=hero><div class=logo><svg viewBox="0 1 52 51" fill=currentColor xmlns=http://www.w3.org/2000/svg xmlns:xlink=http://www.w3.org/1999/xlink><defs><path id=hive-gateway-path d="m25 .524872-7.7758.000001V13.6981c0 2.2382-1.8128 4.051-4.0509 4.051H0l7.2e-7 7.7758H8.48411c1.06096 0 2.07849-.4215 2.82859-1.1718l12.5159-12.5176C24.5786 11.0854 25 10.068 25 9.00727V.524872Zm2 0 7.7758.000001V13.6981c0 2.2382 1.8128 4.051 4.0509 4.051H52v7.7758h-8.4841c-1.061 0-2.0785-.4215-2.8286-1.1718L28.1714 11.8355C27.4214 11.0854 27 10.068 27 9.00727V.524872ZM25 52.5249h-7.7758V39.3516c0-2.2381-1.8128-4.0509-4.0509-4.0509H0l7.2e-7-7.7758H8.48411c1.06096 0 2.07849.4215 2.82859 1.1717l12.5159 12.5176c.75.7502 1.1714 1.7675 1.1714 2.8283v8.4824Zm2 0h7.7758V39.3516c0-2.2381 1.8128-4.0509 4.0509-4.0509H52v-7.7758h-8.4841c-1.061 0-2.0785.4215-2.8286 1.1717L28.1714 41.2142c-.75.7502-1.1714 1.7675-1.1714 2.8283v8.4824Zm2.8369-29.837H22.163v7.6739h7.6739v-7.6739Z"></path><clipPath id=hive-gateway-clip-path><use href=#hive-gateway-path></use></clipPath></defs><use href=#hive-gateway-path clip-path=url(#hive-gateway-clip-path)></use></svg><h1>__PRODUCT_NAME__</h1></div><p class=description>__PRODUCT_DESCRIPTION__</p><br><div class=links><a href=__PRODUCT_LINK__ class=button>\u{1F4DA} Read the Documentation</a><a href=__GRAPHIQL_PATHNAME__ class="button accent">\u{1F5C3}\uFE0F Visit GraphiQL</a></div></section><section class=content><p>You can interact with this endpoint by sending a POST request</p><div class=shell><span class=dollar>$</span><pre class=command>curl --url &#x27;__GRAPHQL_URL__&#x27; \\
  --header &#x27;content-type: application/json&#x27; \\
  --data &#x27;{&quot;query&quot;:&quot;{ __typename }&quot;}&#x27;</pre></div></section><section class=four-oh-four><h2>Not the Page You Expected To See?</h2><p>This page is shown be default whenever a 404 is hit.<br>You can disable this by behavior via the <code>landingPage</code> option.</p><pre><code class=language-typescript>import { defineConfig } from &#x27;__PRODUCT_PACKAGE_NAME__&#x27;;

export const gatewayConfig = defineConfig({
  landingPage: false,
});</code></pre><p>If you expected <u>this</u> page to be the GraphQL route, you need to configure Hive Gateway.<br>Currently, the GraphQL route is configured to be on <a href=__GRAPHIQL_PATHNAME__ class=graphiql>__GRAPHIQL_PATHNAME__</a>.</p><pre><code class=language-typescript>import { defineConfig } from &#x27;__PRODUCT_PACKAGE_NAME__&#x27;;

export const gatewayConfig = defineConfig({
  graphqlEndpoint: &#x27;__REQUEST_PATHNAME__&#x27;,
});
</code></pre></section></main><footer>Developed with \u2764\uFE0F by <a title="View our website" href=https://the-guild.dev rel="noopener noreferrer" class=the-guild><svg viewBox="0 0 51 54" fill=currentColor class=logo><path fill-rule=evenodd clip-rule=evenodd d="M2.06194 20.2745C2.68522 20.4867 3.35002 20.6073 4.04393 20.6073C4.6672 20.6073 5.26838 20.5117 5.83612 20.3391V36.7481C5.83612 37.328 6.14561 37.8684 6.64488 38.1582L22.3391 47.2835C23.0814 46.4108 24.1808 45.8554 25.4084 45.8554C26.7446 45.8554 27.927 46.5134 28.6639 47.5218C28.6769 47.5403 28.6909 47.5576 28.7039 47.5756C28.7557 47.6494 28.8041 47.7248 28.8511 47.8026L28.9049 47.891C28.9465 47.9626 28.9849 48.0355 29.0214 48.1093C29.0414 48.1489 29.0603 48.1891 29.0792 48.2294C29.1105 48.2978 29.14 48.3673 29.1681 48.4378C29.1881 48.4882 29.2059 48.5388 29.2237 48.5899C29.2462 48.6544 29.2684 48.7195 29.2873 48.7852C29.3056 48.8477 29.3202 48.9107 29.3359 48.9737L29.3762 49.1513C29.3918 49.23 29.4021 49.3097 29.4129 49.3902C29.4188 49.4379 29.428 49.4847 29.4323 49.5324C29.4448 49.6627 29.4523 49.7941 29.4523 49.9277C29.4523 50.1406 29.4313 50.3474 29.3994 50.5516L29.3881 50.6275C29.0576 52.5406 27.4007 54 25.4084 54C23.6318 54 22.1227 52.8386 21.5809 51.2314L4.7578 41.4502C3.08905 40.4806 2.06194 38.6876 2.06194 36.7481V20.2745ZM46.0991 10.2908C48.3291 10.2908 50.1428 12.1173 50.1428 14.3631C50.1428 15.5848 49.6037 16.6794 48.755 17.4265V36.7481C48.755 38.6876 47.7279 40.4806 46.0591 41.4502L31.6051 49.8539C31.5889 48.479 31.1274 47.2135 30.3619 46.1876L44.1722 38.1582C44.6713 37.8684 44.9809 37.328 44.9809 36.7481V18.2736C43.2938 17.7838 42.0554 16.2179 42.0554 14.3631C42.0554 13.4601 42.3524 12.6277 42.8485 11.9517C42.856 11.9409 42.8641 11.9306 42.8717 11.9197C42.9655 11.7948 43.0657 11.6743 43.1725 11.5608L43.187 11.545C43.4086 11.3127 43.6567 11.1079 43.9274 10.9337C43.9553 10.9152 43.985 10.8984 44.0136 10.8804C44.1209 10.8158 44.2303 10.755 44.3435 10.7002C44.3765 10.6844 44.4094 10.6671 44.4427 10.6519C44.5846 10.5878 44.7291 10.5286 44.879 10.4814C44.879 10.4819 44.8796 10.4814 44.879 10.4814L45.173 10.3994C45.4705 10.3287 45.7805 10.2908 46.0991 10.2908ZM40.5727 19.0708V32.5386C40.5727 34.1339 39.7202 35.6206 38.3486 36.4181L27.5398 42.696L26.5424 43.2466L26.5543 42.0944V37.3194L35.4506 32.1471V27.4102L27.8779 25.24L40.5727 19.0708ZM10.2444 19.0627L15.3665 21.593V32.1467L24.1279 37.2409V43.1973L12.4684 36.4189C11.0968 35.6206 10.2444 34.1339 10.2444 32.5388V19.0627ZM23.1844 9.96788C24.5349 9.18328 26.2818 9.18328 27.6325 9.96788L39.4904 16.8956L38.3636 17.4327L33.9644 19.6061L25.4084 14.6315L16.8523 19.6061L11.3442 16.8843L12.4026 16.2425C12.4123 16.2338 12.4398 16.2153 12.4694 16.1985L23.1844 9.96788ZM25.4083 0C26.3394 0 27.27 0.242165 28.1041 0.72704L42.644 9.18112C41.5737 9.9076 40.7455 10.9637 40.2899 12.2006L26.217 4.01908C25.9718 3.87572 25.6919 3.80081 25.4083 3.80081C25.1248 3.80081 24.8454 3.87572 24.5995 4.01908L8.02283 13.6574C8.06272 13.887 8.08753 14.1216 8.08753 14.3632C8.08753 16.1154 6.98116 17.608 5.43643 18.1814C5.42457 18.1858 5.41217 18.1906 5.40031 18.1944C5.27792 18.2385 5.15392 18.2765 5.02666 18.3085L4.95065 18.328C4.83419 18.3551 4.71503 18.3764 4.59533 18.3931L4.49775 18.4079C4.3484 18.4246 4.19742 18.4356 4.04377 18.4356C3.87932 18.4356 3.71758 18.4225 3.55743 18.403C3.5143 18.3974 3.47225 18.3899 3.42965 18.3834C3.30673 18.3643 3.18595 18.34 3.06679 18.3101C3.03012 18.3008 2.99347 18.2921 2.95681 18.2819C2.64139 18.1922 2.3416 18.0679 2.06177 17.9088L1.82144 17.7607C0.725648 17.0318 0 15.7822 0 14.3632C0 12.1175 1.81431 10.2909 4.04377 10.2909C4.62229 10.2909 5.17117 10.4158 5.66881 10.6368L22.7124 0.72704C23.5465 0.242165 24.4777 0 25.4083 0Z"></path></svg><svg viewBox="0 0 47 25" fill=currentColor class=name><path d="M0.313477 2.77294H3.57946V10.6541H6.26751V2.77294H9.53349V0.163818H0.313477V2.77294Z"></path><path d="M17.8588 0.163818V4.23889H13.5848V0.163818H10.9102V10.6541H13.5848V6.75386H17.8588V10.6541H20.5468V0.163818H17.8588Z"></path><path d="M22.568 10.6541H30.6187V8.05842H25.2561V6.71352H29.6645V4.27923H25.2561V2.77294H30.6187V0.163818H22.568V10.6541Z"></path><path d="M5.53497 20.9193H8.05247V21.2043C7.55963 21.9036 6.76042 22.3569 5.82801 22.3569C4.25624 22.3569 3.00414 21.1395 3.00414 19.6113C3.00414 18.0831 4.25624 16.8657 5.82801 16.8657C6.73378 16.8657 7.53299 17.2672 8.05247 17.9018L10.2237 16.4772C9.22464 15.208 7.61291 14.3661 5.82801 14.3661C2.81766 14.3661 0.313477 16.7232 0.313477 19.6113C0.313477 22.4994 2.81766 24.8564 5.82801 24.8564C6.89362 24.8564 7.94591 24.4679 8.45208 23.7167V24.6622H10.5433V18.7695H5.53497V20.9193Z"></path><path d="M19.0352 14.5604V20.0905C19.0352 21.5539 18.3026 22.3569 16.904 22.3569C15.5187 22.3569 14.7994 21.5539 14.7994 20.0905V14.5604H12.1354V20.2459C12.1354 22.849 13.7871 24.8564 16.904 24.8564C20.0076 24.8564 21.6859 22.849 21.6859 20.2459V14.5604H19.0352Z"></path><path d="M23.5364 14.5604V24.6622H26.2004V14.5604H23.5364Z"></path><path d="M28.1958 24.6622H35.8283V22.1626H30.8465V14.5604H28.1958V24.6622Z"></path><path d="M37.1999 24.6622H42.0218C45.2719 24.6622 46.937 22.3698 46.937 19.6113C46.937 16.8657 45.2719 14.5604 42.0218 14.5604H37.1999V24.6622ZM41.822 17.0729C43.4071 17.0729 44.2463 18.096 44.2463 19.6113C44.2463 21.1266 43.4071 22.1626 41.822 22.1626H39.864V17.0729H41.822Z"></path></svg></a></footer></body></html>`;

function useCacheDebug({
  log: rootLog
}) {
  function shouldLog(log) {
    let shouldLog2 = false;
    log.debug(() => shouldLog2 = true);
    return shouldLog2;
  }
  return {
    onContextBuilding({ context }) {
      rootLog = context.log;
    },
    onCacheGet({ key }) {
      if (!shouldLog(rootLog)) {
        return;
      }
      const log = rootLog.child({ key }, "[useCacheDebug] ");
      log.debug("Get");
      return {
        onCacheGetError({ error }) {
          log.error({ key, error }, "Error");
        },
        onCacheHit({ value }) {
          log.debug({ key, value }, "Hit");
        },
        onCacheMiss() {
          log.debug({ key }, "Miss");
        }
      };
    },
    onCacheSet({ key, value, ttl }) {
      if (!shouldLog(rootLog)) {
        return;
      }
      const log = rootLog.child({ key, value, ttl }, "[useCacheDebug] ");
      log.debug("Set");
      return {
        onCacheSetError({ error }) {
          log.error({ error }, "Error");
        },
        onCacheSetDone() {
          log.debug("Done");
        }
      };
    },
    onCacheDelete({ key }) {
      if (!shouldLog(rootLog)) {
        return;
      }
      const log = rootLog.child({ key }, "[useCacheDebug] ");
      log.debug("Delete");
      return {
        onCacheDeleteError({ error }) {
          log.error({ error }, "Error");
        },
        onCacheDeleteDone() {
          log.debug("Done");
        }
      };
    }
  };
}

function useConfigInServerContext({
  configContext
}) {
  const configInServerContextPlugin = {
    onRequest({ serverContext, request }) {
      Object.assign(serverContext, configContext, {
        // @ts-expect-error - We know sometimes req is there
        headers: serverContext.req?.headers || getHeadersObj(request.headers)
      });
    }
  };
  return {
    onPluginInit({ plugins }) {
      if (!plugins.includes(configInServerContextPlugin)) {
        plugins.unshift(configInServerContextPlugin);
      }
    }
  };
}

function useContentEncoding({
  subgraphs
} = {}) {
  if (!subgraphs?.length) {
    return useContentEncoding$1();
  }
  const compressionAlgorithm = "gzip";
  let fetchAPI;
  const execReqWithContentEncoding = /* @__PURE__ */ new WeakSet();
  return {
    onYogaInit({ yoga }) {
      fetchAPI = yoga.fetchAPI;
    },
    onPluginInit({ addPlugin }) {
      addPlugin(useContentEncoding$1());
    },
    onSubgraphExecute({ subgraphName, executionRequest }) {
      if (subgraphs.includes(subgraphName) || subgraphs.includes("*")) {
        execReqWithContentEncoding.add(executionRequest);
      }
    },
    onFetch({ executionRequest, options, setOptions }) {
      if (options.body && !options.headers?.["Content-Encoding"] && executionRequest && execReqWithContentEncoding.has(executionRequest) && fetchAPI.CompressionStream) {
        const compressionStream = new fetchAPI.CompressionStream(
          compressionAlgorithm
        );
        let bodyStream;
        if (options.body instanceof fetchAPI.ReadableStream) {
          bodyStream = options.body;
        } else {
          bodyStream = new fetchAPI.Response(options.body).body;
        }
        setOptions({
          ...options,
          headers: {
            "Accept-Encoding": "gzip, deflate",
            ...options.headers,
            "Content-Encoding": compressionAlgorithm
          },
          body: bodyStream.pipeThrough(compressionStream)
        });
      }
    }
  };
}

function useCustomAgent(agentFactory) {
  return {
    onFetch(payload) {
      const agent = agentFactory(payload);
      if (agent != null) {
        payload.setOptions({
          ...payload.options,
          // @ts-expect-error - `agent` is there
          agent
        });
      }
    }
  };
}

function useMaybeDelegationPlanDebug({ log: rootLog }) {
  let activePlugin;
  return {
    onPluginInit({ plugins }) {
      let shouldLog = false;
      rootLog.debug(() => shouldLog = true);
      if (shouldLog) {
        activePlugin = useDelegationPlanDebug();
        plugins.push(
          // @ts-expect-error TODO: fix types
          activePlugin
        );
      } else if (activePlugin) {
        const index = plugins.indexOf(
          // @ts-expect-error TODO: fix types
          activePlugin
        );
        if (
          // must be
          index > -1
        ) {
          plugins.splice(index, 1);
        }
        activePlugin = void 0;
      }
    }
  };
}
function useDelegationPlanDebug() {
  let fetchAPI;
  const stageExecuteLogById = /* @__PURE__ */ new WeakMap();
  return {
    onYogaInit({ yoga }) {
      fetchAPI = yoga.fetchAPI;
    },
    onDelegationPlan({
      typeName,
      variables,
      fragments,
      fieldNodes,
      context,
      info
    }) {
      const planId = fetchAPI.crypto.randomUUID();
      const log = context.log.child(
        { planId, typeName },
        "[useDelegationPlanDebug] "
      );
      const logObj = {};
      if (variables && Object.keys(variables).length) {
        logObj["variables"] = variables;
      }
      if (fragments && Object.keys(fragments).length) {
        logObj["fragments"] = Object.fromEntries(
          Object.entries(fragments).map(([name, fragment]) => [
            name,
            print(fragment)
          ])
        );
      }
      if (fieldNodes && fieldNodes.length) {
        logObj["fieldNodes"] = fieldNodes.map((fieldNode) => print(fieldNode));
      }
      if (info?.path) {
        logObj["path"] = pathToArray(info.path).join(" | ");
      }
      log.debug(logObj, "Start");
      return ({ delegationPlan }) => {
        log.debug(
          {
            delegationPlan: delegationPlan.map((plan) => {
              const planObj = {};
              for (const [subschema, selectionSet] of plan) {
                if (subschema.name) {
                  planObj[subschema.name] = print(selectionSet);
                }
              }
              return planObj;
            })
          },
          "Done"
        );
      };
    },
    onDelegationStageExecute({
      object,
      info,
      context,
      subgraph,
      selectionSet,
      key,
      typeName
    }) {
      let contextLog = stageExecuteLogById.get(context);
      if (!contextLog) {
        contextLog = /* @__PURE__ */ new Set();
        stageExecuteLogById.set(context, contextLog);
      }
      const logAttr = {
        key: JSON.stringify(key),
        object: JSON.stringify(object),
        selectionSet: print(selectionSet)
      };
      const logStr = JSON.stringify(logAttr);
      if (contextLog.has(logStr)) {
        return;
      }
      contextLog.add(logStr);
      const logMeta = {
        stageId: fetchAPI.crypto.randomUUID(),
        subgraph,
        typeName
      };
      const log = context.log.child(logMeta, "[useDelegationPlanDebug] ");
      log.debug(
        {
          ...logMeta,
          path: pathToArray(info.path).join(" | ")
        },
        "Stage start"
      );
      return ({ result }) => {
        log.debug(result, "Stage done");
      };
    }
  };
}

function getDepthOfListType(type) {
  let depth = 0;
  while (isListType(type)) {
    depth++;
    type = type.ofType;
  }
  return depth;
}
const getCostListSizeDirectiveNames = memoize1(
  function getCostListSizeDirectiveNames2(schema) {
    const costDirectiveName = getDirectiveNameForFederationDirective({
      schema,
      directiveName: "cost",
      specUrl: "https://specs.apollo.dev/cost/v0.1"
    });
    const listSizeDirectiveName = getDirectiveNameForFederationDirective({
      schema,
      directiveName: "listSize",
      specUrl: "https://specs.apollo.dev/cost/v0.1"
    });
    return {
      cost: costDirectiveName,
      listSize: listSizeDirectiveName
    };
  }
);
function createCalculateCost({
  listSize,
  operationTypeCost,
  typeCost,
  fieldCost
}) {
  return memoize3(function calculateCost(schema, document, variables) {
    const { cost: costDirectiveName, listSize: listSizeDirectiveName } = getCostListSizeDirectiveNames(schema);
    let cost = 0;
    const factorQueue = [];
    function timesFactor(c) {
      for (const f of factorQueue) {
        c *= f;
      }
      return c;
    }
    const fieldFactorMap = /* @__PURE__ */ new Map();
    const typeInfo = getTypeInfo(schema);
    visit(
      document,
      visitWithTypeInfo(typeInfo, {
        OperationTypeDefinition(node) {
          cost += operationTypeCost(node.operation) || 0;
        },
        Field: {
          enter(node) {
            let currentFieldCost = 0;
            const field = typeInfo.getFieldDef();
            if (field) {
              const fieldAnnotations = getDirectiveExtensions(field, schema);
              const factoryResult = fieldCost?.(node, typeInfo);
              if (factoryResult) {
                currentFieldCost += factoryResult;
              } else if (fieldAnnotations?.[costDirectiveName]) {
                for (const costAnnotation of fieldAnnotations[costDirectiveName]) {
                  if (costAnnotation?.weight) {
                    const weight = Number(costAnnotation.weight);
                    if (weight && !isNaN(weight)) {
                      currentFieldCost += weight;
                    }
                  }
                }
              }
              const returnType = typeInfo.getType();
              let factor = 1;
              const sizedFieldFactor = fieldFactorMap.get(node.name.value);
              if (sizedFieldFactor) {
                factor = sizedFieldFactor;
                fieldFactorMap.delete(field.name);
              } else if (fieldAnnotations?.[listSizeDirectiveName]) {
                for (const listSizeAnnotation of fieldAnnotations[listSizeDirectiveName]) {
                  if (listSizeAnnotation) {
                    if ("slicingArguments" in listSizeAnnotation) {
                      const slicingArguments = listSizeAnnotation.slicingArguments;
                      const argValues = getArgumentValues(
                        field,
                        node,
                        variables
                      );
                      let factorSet = false;
                      let slicingArgumentFactor = 1;
                      for (const slicingArgument of slicingArguments) {
                        const value = argValues[slicingArgument];
                        const numValue = Number(value);
                        if (numValue && !isNaN(numValue)) {
                          slicingArgumentFactor = Math.max(
                            slicingArgumentFactor,
                            numValue
                          );
                          if (factorSet && listSizeAnnotation.requireOneSlicingArgument !== false) {
                            throw createGraphQLError(
                              `Only one slicing argument is allowed on field "${field.name}"; found multiple slicing arguments "${slicingArguments.join(", ")}"`,
                              {
                                extensions: {
                                  code: "COST_QUERY_PARSE_FAILURE"
                                }
                              }
                            );
                          }
                          factorSet = true;
                        }
                      }
                      if (listSizeAnnotation.sizedFields?.length) {
                        for (const sizedField of listSizeAnnotation.sizedFields) {
                          fieldFactorMap.set(sizedField, slicingArgumentFactor);
                        }
                      } else {
                        factor = slicingArgumentFactor;
                      }
                    } else if ("assumedSize" in listSizeAnnotation) {
                      const assumedSizeVal = listSizeAnnotation.assumedSize;
                      const numValue = Number(assumedSizeVal);
                      if (numValue && !isNaN(numValue)) {
                        factor = numValue;
                      }
                    }
                  }
                }
              } else if (listSize && returnType) {
                const depth = getDepthOfListType(returnType);
                if (depth > 0) {
                  factor = listSize * depth;
                }
              }
              factorQueue.push(factor);
              if (returnType) {
                const namedReturnType = getNamedType(returnType);
                if (isIntrospectionType(namedReturnType)) {
                  return;
                }
                const namedReturnTypeAnnotations = getDirectiveExtensions(
                  namedReturnType,
                  schema
                );
                if (namedReturnTypeAnnotations?.[costDirectiveName]) {
                  for (const costAnnotation of namedReturnTypeAnnotations[costDirectiveName]) {
                    if (costAnnotation?.weight) {
                      const weight = Number(costAnnotation?.weight);
                      if (weight && !isNaN(weight)) {
                        currentFieldCost += weight;
                      }
                    }
                  }
                } else {
                  currentFieldCost += typeCost(namedReturnType);
                }
              }
              if (currentFieldCost) {
                cost += timesFactor(currentFieldCost);
              }
            }
          },
          leave() {
            factorQueue.pop();
          }
        },
        Directive() {
          const directive = typeInfo.getDirective();
          if (directive) {
            const directiveCostAnnotations = getDirective(
              schema,
              directive,
              "cost"
            );
            if (directiveCostAnnotations) {
              for (const costAnnotation of directiveCostAnnotations) {
                if (costAnnotation["weight"]) {
                  const weight = Number(costAnnotation["weight"]);
                  if (weight && !isNaN(weight)) {
                    cost += timesFactor(weight);
                  }
                }
              }
            }
          }
        },
        Argument() {
          const argument = typeInfo.getArgument();
          if (argument) {
            const argumentCostAnnotations = getDirective(
              schema,
              argument,
              "cost"
            );
            if (argumentCostAnnotations) {
              for (const costAnnotation of argumentCostAnnotations) {
                if (costAnnotation["weight"]) {
                  const weight = Number(costAnnotation["weight"]);
                  if (weight && !isNaN(weight)) {
                    cost += timesFactor(weight);
                  }
                }
              }
            }
          }
        }
      })
    );
    return cost;
  });
}

function useDemandControl({
  listSize = 0,
  maxCost,
  includeExtensionMetadata = getNodeEnv() === "development",
  operationTypeCost = (operationType) => operationType === "mutation" ? 10 : 0,
  fieldCost,
  typeCost = (type) => isCompositeType(type) ? 1 : 0
}) {
  const calculateCost = createCalculateCost({
    listSize,
    operationTypeCost,
    fieldCost,
    typeCost
  });
  const costByContextMap = /* @__PURE__ */ new WeakMap();
  return {
    onSubgraphExecute({ subgraph, executionRequest, log }) {
      if (!subgraph) {
        return;
      }
      let costByContext = executionRequest.context ? costByContextMap.get(executionRequest.context) || 0 : 0;
      const operationCost = calculateCost(
        subgraph,
        executionRequest.document,
        executionRequest.variables || EMPTY_OBJECT
      );
      costByContext += operationCost;
      if (executionRequest.context) {
        costByContextMap.set(executionRequest.context, costByContext);
      }
      log.debug(
        {
          operationCost,
          totalCost: costByContext
        },
        "[useDemandControl]"
      );
      if (maxCost != null && costByContext > maxCost) {
        throw createGraphQLError(
          `Operation estimated cost ${costByContext} exceeded configured maximum ${maxCost}`,
          {
            extensions: {
              code: "COST_ESTIMATED_TOO_EXPENSIVE",
              cost: {
                estimated: costByContext,
                max: maxCost
              }
            }
          }
        );
      }
    },
    onExecutionResult({ result, setResult, context }) {
      if (includeExtensionMetadata) {
        const costByContext = costByContextMap.get(context) || 0;
        if (isAsyncIterable(result)) {
          setResult(
            mapAsyncIterator(result, (value) => ({
              ...value,
              extensions: {
                ...value.extensions || {},
                cost: {
                  estimated: costByContext,
                  max: maxCost
                }
              }
            }))
          );
        } else {
          setResult({
            ...result || {},
            extensions: {
              ...result?.extensions || {},
              cost: {
                estimated: costByContext,
                max: maxCost
              }
            }
          });
        }
      }
    }
  };
}

function useFetchDebug() {
  let fetchAPI;
  return {
    onYogaInit({ yoga }) {
      fetchAPI = yoga.fetchAPI;
    },
    onFetch({ url, options, context }) {
      let shouldLog = false;
      context.log.debug(() => shouldLog = true);
      if (!shouldLog) {
        return;
      }
      const fetchId = fetchAPI.crypto.randomUUID();
      const log = context.log.child({ fetchId }, "[useFetchDebug] ");
      log.debug(
        {
          url,
          body: options?.body?.toString(),
          headers: options?.headers,
          signal: options?.signal?.aborted ? options?.signal?.reason : false
        },
        "Request"
      );
      const start = performance.now();
      return function onFetchDone({ response }) {
        log.debug(
          {
            status: response.status,
            headers: Object.fromEntries(response.headers.entries()),
            duration: performance.now() - start
          },
          "Response"
        );
      };
    }
  };
}

function usePropagateHeaders(opts) {
  const resHeadersByRequest = /* @__PURE__ */ new WeakMap();
  return {
    onSubgraphExecute({ executionRequest, subgraphName }) {
      if (opts.fromClientToSubgraphs) {
        const request = executionRequest?.context?.request;
        if (request) {
          return handleMaybePromise(
            () => opts.fromClientToSubgraphs?.({
              context: executionRequest.context,
              request,
              subgraphName
            }),
            (propagatingHeaders) => {
              const existingHeaders = executionRequest.extensions?.["headers"];
              let headers = existingHeaders;
              for (const key in propagatingHeaders) {
                const value = propagatingHeaders[key];
                if (value != null && headers?.[key] == null) {
                  headers ||= {};
                  headers[key] = value;
                }
              }
              if (headers != null && Object.keys(headers).length > 0) {
                const extensions = executionRequest.extensions ||= {};
                extensions["headers"] = headers;
              }
            }
          );
        }
      }
    },
    onFetch({ executionRequest }) {
      if (opts.fromSubgraphsToClient) {
        return function onFetchDone({ response }) {
          const request = executionRequest?.context?.request;
          const subgraphName = executionRequest?.subgraphName;
          if (opts.fromSubgraphsToClient && subgraphName && request) {
            return handleMaybePromise(
              () => opts.fromSubgraphsToClient?.({
                context: executionRequest.context,
                response,
                subgraphName
              }),
              (headers) => {
                if (headers && request) {
                  let existingHeaders = resHeadersByRequest.get(request);
                  if (!existingHeaders) {
                    existingHeaders = {};
                    resHeadersByRequest.set(request, existingHeaders);
                  }
                  for (const key in headers) {
                    const value = headers[key];
                    if (value != null) {
                      const headerAsArray = Array.isArray(value) ? value : [value];
                      if (existingHeaders[key]) {
                        existingHeaders[key].push(...headerAsArray);
                      } else {
                        existingHeaders[key] = headerAsArray;
                      }
                    }
                  }
                }
              }
            );
          }
        };
      }
      return;
    },
    onResponse({ response, request }) {
      const headers = resHeadersByRequest.get(request);
      if (headers) {
        for (const key in headers) {
          const value = headers[key];
          if (value) {
            for (const v of value) {
              if (!opts.deduplicateHeaders || key === "set-cookie") {
                response.headers.append(key, v);
              } else {
                response.headers.set(key, v);
              }
            }
          }
        }
      }
    }
  };
}

const defaultGenerateRequestId = ({
  fetchAPI = globalThis
}) => fetchAPI.crypto.randomUUID();
const defaultRequestIdHeader = "x-request-id";
function useRequestId(opts) {
  const requestIdByRequest = /* @__PURE__ */ new WeakMap();
  const headerName = opts?.headerName || defaultRequestIdHeader;
  const generateRequestId = opts?.generateRequestId || defaultGenerateRequestId;
  return {
    onRequest({ request, fetchAPI, serverContext }) {
      const requestId = request.headers.get(headerName) || generateRequestId({
        request,
        fetchAPI,
        // @ts-expect-error - Server context is not typed
        context: serverContext
      });
      requestIdByRequest.set(request, requestId);
      serverContext.log = serverContext.log.child({ requestId });
      serverContext.logger = LegacyLogger.from(serverContext.log);
    },
    onFetch({ context, options, setOptions }) {
      if ("request" in context) {
        const requestId = requestIdByRequest.get(context.request);
        if (requestId) {
          setOptions({
            ...options || {},
            headers: {
              ...options.headers || {},
              [headerName]: requestId
            }
          });
        }
      }
    },
    onResponse({ request, response }) {
      const requestId = requestIdByRequest.get(request);
      if (requestId) {
        response.headers.set(headerName, requestId);
      }
    }
  };
}

function useRetryOnSchemaReload() {
  const execHandlerByContext = /* @__PURE__ */ new WeakMap();
  function handleOnExecute(args) {
    if (args.contextValue) {
      const operation = getOperationAST(args.document, args.operationName);
      if (operation?.operation !== "query") {
        execHandlerByContext.delete(args.contextValue);
      }
    }
  }
  function handleExecutionResult({
    context,
    result,
    setResult
  }) {
    const execHandler = execHandlerByContext.get(context);
    if (execHandler && result?.errors?.some((e) => e.extensions?.["code"] === "SCHEMA_RELOAD")) {
      context.log.info(
        "[useRetryOnSchemaReload] The operation has been aborted after the supergraph schema reloaded, retrying the operation..."
      );
      if (execHandler) {
        return handleMaybePromise(
          execHandler,
          (newResult) => setResult(newResult)
        );
      }
    }
  }
  return {
    onParams({ request, params, context, paramsHandler }) {
      execHandlerByContext.set(
        context,
        () => paramsHandler({
          request,
          params,
          context
        })
      );
    },
    onExecute({ args }) {
      handleOnExecute(args);
    },
    onSubscribe({ args }) {
      handleOnExecute(args);
    },
    onExecutionResult({ request, context, result, setResult }) {
      if (isAsyncIterable$1(result)) {
        return;
      }
      return handleExecutionResult({ context, result, setResult});
    },
    onResultProcess({ result, setResult, serverContext, request }) {
      if (isAsyncIterable$1(result) || Array.isArray(result)) {
        return;
      }
      return handleExecutionResult({
        context: serverContext,
        result,
        setResult});
    }
  };
}

function useSubgraphErrorPlugin({
  errorCode = "DOWNSTREAM_SERVICE_ERROR",
  subgraphNameProp = "serviceName"
} = {}) {
  function extendError(error, subgraphName) {
    const errorExtensions = error.extensions ||= {};
    if (errorCode) {
      errorExtensions.code ||= errorCode;
    }
    if (subgraphNameProp) {
      errorExtensions[subgraphNameProp] ||= subgraphName;
    }
  }
  return {
    onSubgraphExecute({ subgraphName }) {
      return function({ result }) {
        if (isAsyncIterable(result)) {
          return {
            onNext({ result: result2 }) {
              if (result2.errors) {
                for (const error of result2.errors) {
                  extendError(error, subgraphName);
                }
              }
            }
          };
        }
        if (result.errors) {
          for (const error of result.errors) {
            extendError(error, subgraphName);
          }
        }
        return;
      };
    }
  };
}

function useSubgraphExecuteDebug() {
  return {
    onSubgraphExecute({ executionRequest }) {
      let log = executionRequest.context?.log.child(
        "[useSubgraphExecuteDebug] "
      );
      let shouldLog = false;
      log?.debug(() => shouldLog = true);
      if (!log || !shouldLog) {
        return;
      }
      const logData = {};
      if (executionRequest.document) {
        logData["query"] = defaultPrintFn(executionRequest.document);
      }
      if (executionRequest.variables && Object.keys(executionRequest.variables).length) {
        logData["variables"] = executionRequest.variables;
      }
      log.debug(logData, "Start");
      const start = performance.now();
      return function onSubgraphExecuteDone({ result }) {
        if (isAsyncIterable$1(result)) {
          return {
            onNext({ result: result2 }) {
              log.debug(result2, "Next");
            },
            onEnd() {
              log.debug({ duration: performance.now() - start }, "End");
            }
          };
        }
        log.debug(result, "Done");
        return void 0;
      };
    }
  };
}

function useUpstreamCancel() {
  return {
    onFetch({ context, options, executionRequest, info }) {
      const signals = [];
      if ("request" in context && context.request.signal) {
        signals.push(context.request.signal);
      }
      const execRequestSignal = executionRequest?.signal || executionRequest?.info?.signal;
      if (execRequestSignal) {
        signals.push(execRequestSignal);
      }
      const signalInInfo = info?.signal;
      if (signalInInfo) {
        signals.push(signalInInfo);
      }
      if (options.signal) {
        signals.push(options.signal);
      }
      options.signal = abortSignalAny(signals);
    },
    onSubgraphExecute({ executionRequest }) {
      const signals = [];
      if (executionRequest.info?.signal) {
        signals.push(executionRequest.info.signal);
      }
      if (executionRequest.context?.request?.signal) {
        signals.push(executionRequest.context.request.signal);
      }
      if (executionRequest.signal) {
        signals.push(executionRequest.signal);
      }
      executionRequest.signal = abortSignalAny(signals);
    }
  };
}

const RETRY_SYMBOL = Symbol.for("@hive-gateway/runtime/upstreamRetry");
function useUpstreamRetry(opts) {
  const timeouts = /* @__PURE__ */ new Set();
  const retryOptions = typeof opts === "function" ? opts : () => opts;
  const executionRequestResponseMap = /* @__PURE__ */ new WeakMap();
  return {
    onSubgraphExecute({
      subgraphName,
      executionRequest,
      executor,
      setExecutor
    }) {
      const optsForReq = retryOptions({ subgraphName, executionRequest });
      if (optsForReq) {
        const {
          maxRetries,
          retryDelay = 1e3,
          retryDelayFactor = 1.25,
          shouldRetry = ({ response, executionResult }) => {
            if (response) {
              if (response.status >= 500 || response.status === 429 || response.headers.get("Retry-After")) {
                return true;
              }
            }
            if (!executionResult || !isAsyncIterable(executionResult) && executionResult.errors?.length && executionResult.errors.some((e) => !isOriginalGraphQLError(e))) {
              return true;
            }
            return false;
          }
        } = optsForReq;
        if (maxRetries > 0) {
          setExecutor(function(executionRequest2) {
            let attemptsLeft = maxRetries + 1;
            let executionResult;
            let currRetryDelay = retryDelay;
            function retry() {
              try {
                if (attemptsLeft <= 0) {
                  return executionResult;
                }
                const requestTime = Date.now();
                attemptsLeft--;
                executionRequest2[RETRY_SYMBOL] = {
                  attempt: maxRetries - attemptsLeft,
                  executionRequest: executionRequest2
                };
                return handleMaybePromise(
                  () => executor(executionRequest2),
                  (currRes) => {
                    executionResult = currRes;
                    let retryAfterSecondsFromHeader;
                    const response = executionRequestResponseMap.get(executionRequest2);
                    executionRequestResponseMap.delete(executionRequest2);
                    const retryAfterHeader = response?.headers.get("Retry-After");
                    if (retryAfterHeader) {
                      retryAfterSecondsFromHeader = parseInt(retryAfterHeader) * 1e3;
                      if (isNaN(retryAfterSecondsFromHeader)) {
                        const dateTime = new Date(retryAfterHeader).getTime();
                        if (!isNaN(dateTime)) {
                          retryAfterSecondsFromHeader = dateTime - requestTime;
                        }
                      }
                    }
                    currRetryDelay = retryAfterSecondsFromHeader || currRetryDelay * retryDelayFactor;
                    if (shouldRetry({
                      executionRequest: executionRequest2,
                      executionResult,
                      response
                    })) {
                      return new Promise((resolve) => {
                        const timeout = setTimeout(() => {
                          timeouts.delete(timeout);
                          resolve(retry());
                        }, currRetryDelay);
                        timeouts.add(timeout);
                      });
                    }
                    return executionResult;
                  },
                  (e) => {
                    if (attemptsLeft <= 0) {
                      throw e;
                    }
                    return retry();
                  }
                );
              } catch (e) {
                if (attemptsLeft <= 0) {
                  throw e;
                }
                return retry();
              }
            }
            return retry();
          });
        }
      }
    },
    onFetch({ executionRequest }) {
      if (executionRequest) {
        return function onFetchDone({ response }) {
          executionRequestResponseMap.set(executionRequest, response);
        };
      }
      return void 0;
    },
    onDispose() {
      for (const timeout of timeouts) {
        clearTimeout(timeout);
        timeouts.delete(timeout);
      }
    }
  };
}
function isRetryExecutionRequest(executionRequest) {
  return !!executionRequest?.[RETRY_SYMBOL];
}
function getRetryInfo(executionRequest) {
  return executionRequest[RETRY_SYMBOL];
}

function useUpstreamTimeout(opts) {
  const timeoutFactory = typeof opts === "function" ? opts : () => opts;
  const timeoutSignalsByExecutionRequest = /* @__PURE__ */ new WeakMap();
  const errorExtensionsByExecRequest = /* @__PURE__ */ new WeakMap();
  return {
    onSubgraphExecute({
      subgraphName,
      executionRequest,
      executor,
      setExecutor
    }) {
      const timeout = timeoutFactory({ subgraphName, executionRequest });
      if (timeout) {
        setExecutor(function timeoutExecutor(executionRequest2) {
          let timeoutSignal = timeoutSignalsByExecutionRequest.get(executionRequest2);
          if (!timeoutSignal) {
            timeoutSignal = AbortSignal.timeout(timeout);
            timeoutSignalsByExecutionRequest.set(
              executionRequest2,
              timeoutSignal
            );
          }
          const timeoutDeferred = createDeferred();
          function rejectDeferred() {
            timeoutDeferred.reject(timeoutSignal?.reason);
          }
          timeoutSignal.addEventListener("abort", rejectDeferred, {
            once: true
          });
          const signals = [];
          signals.push(timeoutSignal);
          if (executionRequest2.signal) {
            signals.push(executionRequest2.signal);
          }
          const res$ = executor({
            ...executionRequest2,
            signal: abortSignalAny(signals)
          });
          if (!isPromise(res$)) {
            return res$;
          }
          return Promise.race([timeoutDeferred.promise, res$]).then((result) => {
            if (isAsyncIterable(result)) {
              return {
                [Symbol.asyncIterator]() {
                  const iterator = result[Symbol.asyncIterator]();
                  if (iterator.return) {
                    timeoutSignal.addEventListener(
                      "abort",
                      () => {
                        iterator.return?.(timeoutSignal.reason);
                      },
                      {
                        once: true
                      }
                    );
                  }
                  return iterator;
                }
              };
            }
            return result;
          }).catch((e) => {
            if (e === timeoutSignal.reason) {
              const upstreamErrorExtensions = errorExtensionsByExecRequest.get(executionRequest2);
              throw createGraphQLError(e.message, {
                extensions: {
                  ...upstreamErrorExtensions,
                  code: "GATEWAY_TIMEOUT",
                  http: {
                    status: 504
                  }
                }
              });
            }
            throw e;
          }).finally(() => {
            timeoutDeferred.resolve(void 0);
            timeoutSignal.removeEventListener("abort", rejectDeferred);
            errorExtensionsByExecRequest.delete(executionRequest2);
            timeoutSignalsByExecutionRequest.delete(executionRequest2);
          });
        });
      }
      return void 0;
    },
    onFetch({ url, executionRequest, options, setOptions }) {
      const subgraphName = executionRequest?.subgraphName;
      if (!executionRequest || !timeoutSignalsByExecutionRequest.has(executionRequest)) {
        const timeout = timeoutFactory({ subgraphName, executionRequest });
        if (timeout) {
          let timeoutSignal;
          if (executionRequest) {
            timeoutSignal = timeoutSignalsByExecutionRequest.get(executionRequest);
            if (!timeoutSignal) {
              timeoutSignal = AbortSignal.timeout(timeout);
              timeoutSignalsByExecutionRequest.set(
                executionRequest,
                timeoutSignal
              );
            }
          } else {
            timeoutSignal = AbortSignal.timeout(timeout);
          }
          const signals = [];
          signals.push(timeoutSignal);
          if (options.signal) {
            signals.push(options.signal);
          }
          setOptions({
            ...options,
            signal: abortSignalAny(signals)
          });
        }
      }
      if (executionRequest) {
        const upstreamErrorExtensions = {
          serviceName: subgraphName,
          request: {
            url,
            method: options.method,
            body: options.body
          }
        };
        errorExtensionsByExecRequest.set(
          executionRequest,
          upstreamErrorExtensions
        );
        return function onFetchDone({ response }) {
          timeoutSignalsByExecutionRequest.delete(executionRequest);
          upstreamErrorExtensions.response = {
            status: response.status,
            statusText: response.statusText,
            headers: getHeadersObj(response.headers)
          };
        };
      }
      return void 0;
    }
  };
}

function useWebhooks({
  log: rootLog,
  pubsub
}) {
  const log = rootLog.child("[useWebhooks] ");
  if (!pubsub) {
    throw new Error(`You must provide a pubsub instance to webhooks feature!
    Example:
      import { PubSub } from '@graphql-hive/gateway'
      export const gatewayConfig = defineConfig({
        pubsub: new PubSub(),
        webhooks: true,
      })
    See documentation: https://the-guild.dev/docs/mesh/pubsub`);
  }
  return {
    onRequest({ request, url, endResponse, fetchAPI }) {
      return handleMaybePromise(
        () => pubsub.subscribedTopics(),
        (topics) => {
          if (Array(topics).length === 0) return;
          const requestMethod = request.method.toLowerCase();
          const pathname = url.pathname;
          const expectedEventName = `webhook:${requestMethod}:${pathname}`;
          for (const eventName of topics) {
            if (eventName === expectedEventName) {
              log.debug({ pathname }, "Received webhook request");
              return handleMaybePromise(
                () => request.text(),
                function handleWebhookPayload(webhookPayload) {
                  log.debug(
                    { pathname, payload: webhookPayload },
                    "Emitted webhook request"
                  );
                  webhookPayload = request.headers.get("content-type") === "application/json" ? JSON.parse(webhookPayload) : webhookPayload;
                  return handleMaybePromise(
                    () => pubsub.publish(eventName, webhookPayload),
                    () => {
                      endResponse(
                        new fetchAPI.Response(null, {
                          status: 204,
                          statusText: "OK"
                        })
                      );
                    }
                  );
                }
              );
            }
          }
        }
      );
    }
  };
}

function wrapFetchWithHooks(onFetchHooks, log, instrumentation) {
  let wrappedFetchFn = function wrappedFetchFn2(url, options, context = {}, info) {
    let fetchFn;
    let response$;
    const onFetchDoneHooks = [];
    context.log ||= log;
    return handleMaybePromise(
      () => iterateAsync(
        onFetchHooks,
        (onFetch, endEarly) => onFetch({
          fetchFn,
          setFetchFn(newFetchFn) {
            fetchFn = newFetchFn;
          },
          url,
          setURL(newUrl) {
            url = String(newUrl);
          },
          // @ts-expect-error TODO: why?
          options,
          setOptions(newOptions) {
            options = newOptions;
          },
          context,
          logger: LegacyLogger.from(log),
          // @ts-expect-error TODO: why?
          info,
          get executionRequest() {
            return info?.executionRequest || // @ts-expect-error might be in the root value, see packages/fusion-runtime/src/utils.ts
            info?.rootValue?.executionRequest;
          },
          endResponse(newResponse) {
            response$ = newResponse;
            endEarly();
          }
        }),
        onFetchDoneHooks
      ),
      function handleIterationResult() {
        if (response$) {
          return response$;
        }
        return handleMaybePromise(
          () => fetchFn(url, options, context, info),
          function(response) {
            return handleMaybePromise(
              () => iterateAsync(
                onFetchDoneHooks,
                (onFetchDone) => onFetchDone({
                  response,
                  setResponse(newResponse) {
                    response = newResponse;
                  }
                })
              ),
              function handleOnFetchDone() {
                return response;
              }
            );
          }
        );
      }
    );
  };
  if (instrumentation) {
    const originalWrappedFetch = wrappedFetchFn;
    wrappedFetchFn = function wrappedFetchFn2(url, options, context, info) {
      const fetchInstrument = instrumentation()?.fetch;
      const instrumentedFetch = fetchInstrument ? getInstrumented({
        get executionRequest() {
          return info?.executionRequest;
        }
      }).asyncFn(fetchInstrument, originalWrappedFetch) : originalWrappedFetch;
      return instrumentedFetch(url, options, context, info);
    };
  }
  return wrappedFetchFn;
}

function createGatewayRuntime(config) {
  let fetchAPI = config.fetchAPI;
  const log = createLoggerFromLogging(config.logging);
  let instrumentation;
  const onFetchHooks = [];
  const onCacheGetHooks = [];
  const onCacheSetHooks = [];
  const onCacheDeleteHooks = [];
  const wrappedFetchFn = wrapFetchWithHooks(
    onFetchHooks,
    log,
    () => instrumentation
  );
  const wrappedCache = config.cache ? wrapCacheWithHooks({
    cache: config.cache,
    onCacheGet: onCacheGetHooks,
    onCacheSet: onCacheSetHooks,
    onCacheDelete: onCacheDeleteHooks
  }) : void 0;
  const pubsub = config.pubsub;
  const configContext = {
    fetch: wrappedFetchFn,
    log,
    cwd: config.cwd || (typeof process !== "undefined" ? process.cwd() : ""),
    cache: wrappedCache,
    pubsub
  };
  let unifiedGraphPlugin;
  const readinessCheckEndpoint = config.readinessCheckEndpoint || "/readiness";
  const onSubgraphExecuteHooks = [];
  const onDelegateHooks = [];
  const onDelegationPlanHooks = [];
  const onDelegationStageExecuteHooks = [];
  let unifiedGraph;
  let schemaInvalidator;
  let getSchema = () => unifiedGraph;
  let contextBuilder;
  let readinessChecker;
  let getExecutor;
  let replaceSchema = (newSchema) => {
    unifiedGraph = newSchema;
  };
  let allowArbitraryDocumentsForPersistedDocuments = false;
  if (config.persistedDocuments?.allowArbitraryDocuments != null) {
    allowArbitraryDocumentsForPersistedDocuments = config.persistedDocuments?.allowArbitraryDocuments;
  } else if (config.persistedDocuments?.allowArbitraryOperations) {
    allowArbitraryDocumentsForPersistedDocuments = config.persistedDocuments?.allowArbitraryOperations;
  }
  const reportingWithMaybePersistedDocumentsPlugin = getReportingPlugin(
    config,
    configContext,
    allowArbitraryDocumentsForPersistedDocuments
  );
  let persistedDocumentsPlugin = {};
  if (config.reporting?.type !== "hive" && config.persistedDocuments && "type" in config.persistedDocuments && config.persistedDocuments?.type === "hive") {
    persistedDocumentsPlugin = useHiveConsole({
      ...configContext,
      enabled: false,
      // disables only usage reporting
      log: configContext.log.child("[useHiveConsole.persistedDocuments] "),
      experimental__persistedDocuments: {
        cdn: {
          endpoint: config.persistedDocuments.endpoint,
          accessToken: config.persistedDocuments.token
        },
        circuitBreaker: config.persistedDocuments.circuitBreaker,
        // @ts-expect-error - Hive Console plugin options are not compatible yet
        allowArbitraryDocuments: allowArbitraryDocumentsForPersistedDocuments
      }
    });
  } else if (config.persistedDocuments && "getPersistedOperation" in config.persistedDocuments) {
    const plugin = usePersistedOperations({
      extractPersistedOperationId: defaultExtractPersistedOperationId,
      ...configContext,
      ...config.persistedDocuments,
      allowArbitraryOperations: allowArbitraryDocumentsForPersistedDocuments
    });
    persistedDocumentsPlugin = plugin;
  }
  if ("proxy" in config) {
    let continuePolling2 = function() {
      if (currentTimeout) {
        clearTimeout(currentTimeout);
      }
      if (pollingInterval) {
        currentTimeout = setTimeout(schemaFetcher.fetch, pollingInterval);
      }
    }, pausePolling2 = function() {
      if (currentTimeout) {
        clearTimeout(currentTimeout);
      }
    };
    const transportExecutorStack = new AsyncDisposableStack();
    const proxyExecutor = getProxyExecutor({
      config,
      configContext,
      getSchema() {
        return unifiedGraph;
      },
      onSubgraphExecuteHooks,
      transportExecutorStack,
      instrumentation: () => instrumentation
    });
    getExecutor = () => proxyExecutor;
    let currentTimeout;
    const pollingInterval = config.pollingInterval;
    let initialFetch$;
    let schemaFetcher;
    if (config.schema && typeof config.schema === "object" && "type" in config.schema) {
      let ensureSdl2 = function(endpoint2) {
        endpoint2 = endpoint2.replace(/\/services$/, "/sdl");
        if (!/\/sdl(\.graphql)*$/.test(endpoint2)) {
          endpoint2 = joinUrl(endpoint2, "sdl");
        }
        return endpoint2;
      };
      const { endpoint, key, circuitBreaker } = config.schema;
      const fetcher = createCDNArtifactFetcher({
        endpoint: Array.isArray(endpoint) ? (
          // no endpoint.map just to make ts happy without casting
          [ensureSdl2(endpoint[0]), ensureSdl2(endpoint[1])]
        ) : ensureSdl2(endpoint),
        circuitBreaker,
        accessKey: key,
        logger: configContext.log.child("[hiveSchemaFetcher] ")
      });
      schemaFetcher = {
        fetch: function fetchSchemaFromCDN() {
          pausePolling2();
          initialFetch$ = handleMaybePromise(
            fetcher.fetch,
            ({ contents }) => {
              {
                unifiedGraph = buildSchema(contents, {
                  assumeValid: true,
                  assumeValidSDL: true
                });
              }
              continuePolling2();
              return true;
            }
          );
          return initialFetch$;
        },
        dispose: () => fetcher.dispose()
      };
    } else if (config.schema) {
      if (!isDynamicUnifiedGraphSchema(config.schema)) {
        delete config.pollingInterval;
      }
      schemaFetcher = {
        fetch: function fetchSchema() {
          pausePolling2();
          initialFetch$ = handleMaybePromise(
            () => handleUnifiedGraphConfig(
              // @ts-expect-error TODO: what's up with type narrowing
              config.schema,
              configContext
            ),
            (schema) => {
              if (isSchema(schema)) {
                unifiedGraph = schema;
              } else if (isDocumentNode(schema)) {
                unifiedGraph = buildASTSchema(schema, {
                  assumeValid: true,
                  assumeValidSDL: true
                });
              } else {
                unifiedGraph = buildSchema(schema, {
                  noLocation: true,
                  assumeValid: true,
                  assumeValidSDL: true
                });
              }
              continuePolling2();
              return true;
            }
          );
          return initialFetch$;
        }
      };
    } else {
      schemaFetcher = {
        fetch: function fetchSchemaWithExecutor() {
          pausePolling2();
          return handleMaybePromise(
            () => schemaFromExecutor(proxyExecutor, configContext, {
              assumeValid: true
            }),
            (schema) => {
              unifiedGraph = schema;
              continuePolling2();
              return true;
            }
          );
        }
      };
    }
    const instrumentedFetcher = schemaFetcher.fetch;
    schemaFetcher = {
      ...schemaFetcher,
      fetch: (...args) => getInstrumented$1(null).asyncFn(
        instrumentation?.schema,
        instrumentedFetcher
      )(...args)
    };
    getSchema = () => {
      if (unifiedGraph != null) {
        return unifiedGraph;
      }
      if (initialFetch$ != null) {
        return handleMaybePromise(
          () => initialFetch$,
          () => unifiedGraph
        );
      }
      return handleMaybePromise(schemaFetcher.fetch, () => unifiedGraph);
    };
    const shouldSkipValidation = "skipValidation" in config ? config.skipValidation : false;
    unifiedGraphPlugin = {
      onValidate({ params, setResult }) {
        if (shouldSkipValidation || !params.schema) {
          setResult([]);
        }
      },
      onDispose() {
        pausePolling2();
        return handleMaybePromise(
          () => transportExecutorStack.disposeAsync(),
          () => schemaFetcher.dispose?.()
        );
      }
    };
    readinessChecker = () => handleMaybePromise(
      () => proxyExecutor({
        document: parse(`query ReadinessCheck { __typename }`, {
          noLocation: true
        })
      }),
      (res) => !isAsyncIterable$1(res) && !!res.data?.__typename
    );
    schemaInvalidator = () => {
      unifiedGraph = void 0;
      initialFetch$ = schemaFetcher.fetch();
    };
  } else if ("subgraph" in config) {
    let getSubschemaConfig2 = function() {
      if (getSubschemaConfig$ == null) {
        getSubschemaConfig$ = handleMaybePromise(
          () => handleUnifiedGraphConfig(subgraphInConfig, configContext),
          (newUnifiedGraph) => {
            if (isSchema(newUnifiedGraph)) {
              unifiedGraph = newUnifiedGraph;
            } else if (isDocumentNode(newUnifiedGraph)) {
              unifiedGraph = buildASTSchema(newUnifiedGraph, {
                assumeValid: true,
                assumeValidSDL: true
              });
            } else {
              unifiedGraph = buildSchema(newUnifiedGraph, {
                noLocation: true,
                assumeValid: true,
                assumeValidSDL: true
              });
            }
            unifiedGraph = restoreExtraDirectives(unifiedGraph);
            subschemaConfig = {
              name: getDirectiveExtensions(unifiedGraph)?.["transport"]?.[0]?.["subgraph"],
              schema: unifiedGraph
            };
            const transportEntryMap = getTransportEntryMapUsingFusionAndFederationDirectives(
              unifiedGraph,
              config.transportEntries
            );
            const additionalTypeDefs = [];
            const stitchingDirectivesTransformer = getStitchingDirectivesTransformerForSubschema();
            const onSubgraphExecute = getOnSubgraphExecute({
              onSubgraphExecuteHooks,
              ...config.transports ? { transports: config.transports } : {},
              transportContext: {
                ...configContext,
                logger: LegacyLogger.from(configContext.log)
              },
              transportEntryMap,
              getSubgraphSchema() {
                return unifiedGraph;
              },
              transportExecutorStack,
              instrumentation: () => instrumentation
            });
            subschemaConfig = handleFederationSubschema({
              subschemaConfig,
              additionalTypeDefs,
              stitchingDirectivesTransformer,
              onSubgraphExecute
            });
            unifiedGraph = wrapSchema(subschemaConfig);
            const entities = Object.keys(subschemaConfig.merge || {});
            let entitiesDef = "union _Entity";
            if (entities.length) {
              entitiesDef += ` = ${entities.join(" | ")}`;
            }
            const additionalResolvers = asArray(
              "additionalResolvers" in config ? config.additionalResolvers : []
            ).filter((r) => r != null);
            const queryTypeName = unifiedGraph.getQueryType()?.name || "Query";
            const finalTypeDefs = handleResolveToDirectives(
              parse(
                /* GraphQL */
                `
                type ${queryTypeName} {
                  ${entities.length ? "_entities(representations: [_Any!]!): [_Entity]!" : ""}
                  _service: _Service!
                }

                scalar _Any
                ${entities.length ? entitiesDef : ""}
                type _Service {
                  sdl: String
                }
              `
              ),
              additionalTypeDefs,
              additionalResolvers
            );
            additionalResolvers.push({
              [queryTypeName]: {
                _service() {
                  return {
                    sdl() {
                      if (isSchema(newUnifiedGraph)) {
                        return printSchemaWithDirectives(newUnifiedGraph);
                      }
                      if (isDocumentNode(newUnifiedGraph)) {
                        return defaultPrintFn$1(newUnifiedGraph);
                      }
                      return newUnifiedGraph;
                    }
                  };
                }
              }
            });
            if (entities.length) {
              additionalResolvers.push({
                [queryTypeName]: {
                  _entities(_root, args, context, info) {
                    if (Array.isArray(args.representations)) {
                      return args.representations.map((representation) => {
                        const typeName = representation.__typename;
                        const mergeConfig = subschemaConfig.merge?.[typeName];
                        const entryPoints = mergeConfig?.entryPoints || [
                          mergeConfig
                        ];
                        const satisfiedEntryPoint = entryPoints.find(
                          (entryPoint) => {
                            if (entryPoint?.selectionSet) {
                              const selectionSet = parseSelectionSet(
                                entryPoint.selectionSet,
                                {
                                  noLocation: true
                                }
                              );
                              return checkIfDataSatisfiesSelectionSet(
                                selectionSet,
                                representation
                              );
                            }
                            return true;
                          }
                        );
                        if (satisfiedEntryPoint) {
                          if (satisfiedEntryPoint.key) {
                            return handleMaybePromise(
                              () => batchDelegateToSchema({
                                schema: subschemaConfig,
                                ...satisfiedEntryPoint.fieldName ? {
                                  fieldName: satisfiedEntryPoint.fieldName
                                } : {},
                                key: satisfiedEntryPoint.key(representation),
                                ...satisfiedEntryPoint.argsFromKeys ? {
                                  argsFromKeys: satisfiedEntryPoint.argsFromKeys
                                } : {},
                                ...satisfiedEntryPoint.valuesFromResults ? {
                                  valuesFromResults: satisfiedEntryPoint.valuesFromResults
                                } : {},
                                context,
                                info
                              }),
                              (res) => mergeDeep([representation, res])
                            );
                          }
                          if (satisfiedEntryPoint.args) {
                            return handleMaybePromise(
                              () => delegateToSchema({
                                schema: subschemaConfig,
                                ...satisfiedEntryPoint.fieldName ? {
                                  fieldName: satisfiedEntryPoint.fieldName
                                } : {},
                                args: satisfiedEntryPoint.args(
                                  representation
                                ),
                                context,
                                info
                              }),
                              (res) => mergeDeep([representation, res])
                            );
                          }
                        }
                        return representation;
                      });
                    }
                    return [];
                  }
                }
              });
            }
            unifiedGraph = mergeSchemas({
              assumeValid: true,
              assumeValidSDL: true,
              schemas: [unifiedGraph],
              typeDefs: finalTypeDefs,
              resolvers: additionalResolvers,
              defaultFieldResolver: defaultMergedResolver
            });
            contextBuilder = (base) => Object.assign(
              // @ts-expect-error - Typings are wrong in legacy Mesh
              base,
              getInContextSDK(
                unifiedGraph,
                // @ts-expect-error - Typings are wrong in legacy Mesh
                [subschemaConfig],
                LegacyLogger.from(configContext.log),
                onDelegateHooks
              )
            );
            return true;
          }
        );
      }
      return getSubschemaConfig$;
    };
    const subgraphInConfig = config.subgraph;
    let getSubschemaConfig$;
    let subschemaConfig;
    const transportExecutorStack = new AsyncDisposableStack();
    getSchema = () => handleMaybePromise(getSubschemaConfig2, () => unifiedGraph);
    schemaInvalidator = () => {
      getSubschemaConfig$ = void 0;
    };
    unifiedGraphPlugin = {
      onDispose() {
        return transportExecutorStack.disposeAsync();
      }
    };
  } else {
    let unifiedGraphFetcher;
    if (typeof config.supergraph === "object" && "type" in config.supergraph) {
      if (config.supergraph.type === "hive") {
        let ensureSupergraph2 = function(endpoint2) {
          if (!/\/supergraph(\.graphql)*$/.test(endpoint2)) {
            endpoint2 = joinUrl(endpoint2, "supergraph");
          }
          return endpoint2;
        };
        const { endpoint, key, circuitBreaker } = config.supergraph;
        const fetcher = createCDNArtifactFetcher({
          endpoint: Array.isArray(endpoint) ? (
            // no endpoint.map just to make ts happy without casting
            [ensureSupergraph2(endpoint[0]), ensureSupergraph2(endpoint[1])]
          ) : ensureSupergraph2(endpoint),
          accessKey: key,
          logger: configContext.log.child("[hiveSupergraphFetcher] "),
          // @ts-expect-error - MeshFetch is not compatible with `typeof fetch`
          fetch: configContext.fetch,
          circuitBreaker,
          name: "hive-gateway",
          version: globalThis.__VERSION__
        });
        unifiedGraphFetcher = {
          fetch: () => fetcher.fetch().then(({ contents }) => contents),
          dispose: () => fetcher.dispose()
        };
      } else if (config.supergraph.type === "graphos") {
        const graphosFetcherContainer = createGraphOSFetcher({
          graphosOpts: config.supergraph,
          configContext,
          pollingInterval: config.pollingInterval
        });
        unifiedGraphFetcher = {
          fetch: graphosFetcherContainer.unifiedGraphFetcher
        };
      } else {
        unifiedGraphFetcher = {
          fetch: () => {
            throw new Error(
              `Unknown supergraph configuration: ${config.supergraph}`
            );
          }
        };
      }
    } else {
      if (!isDynamicUnifiedGraphSchema(config.supergraph)) {
        log.debug(`Disabling polling for static supergraph`);
        delete config.pollingInterval;
      } else if (!config.pollingInterval) {
        log.debug(
          `Polling interval not set for supergraph, if you want to get updates of supergraph, we recommend setting a polling interval`
        );
      }
      unifiedGraphFetcher = {
        fetch: () => handleUnifiedGraphConfig(
          // @ts-expect-error TODO: what's up with type narrowing
          config.supergraph,
          configContext
        )
      };
    }
    const instrumentedGraphFetcher = unifiedGraphFetcher.fetch;
    unifiedGraphFetcher = {
      ...unifiedGraphFetcher,
      fetch: (...args) => getInstrumented$1(null).asyncFn(
        instrumentation?.schema,
        instrumentedGraphFetcher
      )(...args)
    };
    const unifiedGraphManager = new UnifiedGraphManager({
      handleUnifiedGraph: config.unifiedGraphHandler,
      getUnifiedGraph: unifiedGraphFetcher.fetch,
      onUnifiedGraphChange(newUnifiedGraph) {
        unifiedGraph = newUnifiedGraph;
        replaceSchema(newUnifiedGraph);
      },
      transports: config.transports,
      transportEntryAdditions: config.transportEntries,
      pollingInterval: config.pollingInterval,
      transportContext: {
        ...configContext,
        logger: LegacyLogger.from(configContext.log)
      },
      onDelegateHooks,
      onSubgraphExecuteHooks,
      onDelegationPlanHooks,
      onDelegationStageExecuteHooks,
      additionalTypeDefs: config.additionalTypeDefs,
      additionalResolvers: config.additionalResolvers,
      instrumentation: () => instrumentation,
      batch: config.__experimental__batchExecution,
      batchDelegateOptions: config.__experimental__batchDelegateOptions,
      handleProgressiveOverride: config.progressiveOverride
    });
    getSchema = () => unifiedGraphManager.getUnifiedGraph();
    readinessChecker = () => {
      const log2 = configContext.log.child("[readiness] ");
      log2.debug("checking");
      return handleMaybePromise(
        () => unifiedGraphManager.getUnifiedGraph(),
        (schema) => {
          if (!schema) {
            log2.debug(
              "failed because supergraph has not been loaded yet or failed to load"
            );
            return false;
          }
          log2.debug("passed");
          return true;
        },
        (err) => {
          log2.error(err, "loading supergraph failed due to errors");
          return false;
        }
      );
    };
    schemaInvalidator = () => unifiedGraphManager.invalidateUnifiedGraph();
    contextBuilder = (base) => unifiedGraphManager.getContext(base);
    getExecutor = () => unifiedGraphManager.getExecutor();
    unifiedGraphPlugin = {
      onDispose() {
        return handleMaybePromise(
          () => dispose(unifiedGraphManager),
          () => unifiedGraphFetcher.dispose?.()
        );
      }
    };
  }
  const readinessCheckPlugin = useReadinessCheck({
    endpoint: readinessCheckEndpoint,
    // @ts-expect-error PromiseLike is not compatible with Promise
    check: readinessChecker
  });
  const defaultGatewayPlugin = {
    onFetch({ setFetchFn }) {
      if (fetchAPI?.fetch) {
        setFetchFn(fetchAPI.fetch);
      }
    },
    onRequestParse() {
      return handleMaybePromise(getSchema, (schema) => {
        replaceSchema(schema);
      });
    },
    onPluginInit({ plugins, setSchema }) {
      replaceSchema = setSchema;
      onFetchHooks.splice(0, onFetchHooks.length);
      onSubgraphExecuteHooks.splice(0, onSubgraphExecuteHooks.length);
      onDelegateHooks.splice(0, onDelegateHooks.length);
      for (const plugin of plugins) {
        if (plugin.instrumentation) {
          instrumentation = instrumentation ? chain(instrumentation, plugin.instrumentation) : plugin.instrumentation;
        }
        if (plugin.onFetch) {
          onFetchHooks.push(plugin.onFetch);
        }
        if (plugin.onSubgraphExecute) {
          onSubgraphExecuteHooks.push(plugin.onSubgraphExecute);
        }
        if (plugin.onDelegate) {
          onDelegateHooks.push(plugin.onDelegate);
        }
        if (plugin.onDelegationPlan) {
          onDelegationPlanHooks.push(plugin.onDelegationPlan);
        }
        if (plugin.onDelegationStageExecute) {
          onDelegationStageExecuteHooks.push(plugin.onDelegationStageExecute);
        }
        if (plugin.onCacheGet) {
          onCacheGetHooks.push(plugin.onCacheGet);
        }
        if (plugin.onCacheSet) {
          onCacheSetHooks.push(plugin.onCacheSet);
        }
        if (plugin.onCacheDelete) {
          onCacheDeleteHooks.push(plugin.onCacheDelete);
        }
      }
    }
  };
  if (getExecutor) {
    const onExecute = ({
      setExecuteFn
    }) => handleMaybePromise(
      () => getExecutor?.(),
      (executor) => {
        if (executor) {
          const executeFn = getExecuteFnFromExecutor(executor);
          setExecuteFn(executeFn);
        }
      }
    );
    const onSubscribe = ({
      setSubscribeFn
    }) => handleMaybePromise(
      () => getExecutor?.(),
      (executor) => {
        if (executor) {
          const subscribeFn = getExecuteFnFromExecutor(executor);
          setSubscribeFn(subscribeFn);
        }
      }
    );
    defaultGatewayPlugin.onExecute = onExecute;
    defaultGatewayPlugin.onSubscribe = onSubscribe;
  }
  const productName = config.productName || "Hive Gateway";
  const productDescription = config.productDescription || "Unify and accelerate your data graph across diverse services with Hive Gateway, which seamlessly integrates with Apollo Federation.";
  const productPackageName = config.productPackageName || "@graphql-hive/gateway";
  const productLink = config.productLink || "https://the-guild.dev/graphql/hive/docs/gateway";
  let graphiqlOptionsOrFactory;
  const graphiqlLogo = `<div style="height: 20px;display: flex;margin: 0 5px 0 auto">${logoSvg}</div>`;
  if (config.graphiql == null || config.graphiql === true) {
    graphiqlOptionsOrFactory = {
      title: productName,
      logo: graphiqlLogo,
      favicon: `data:image/png;base64,${iconBase64}`,
      defaultQuery: defaultQueryText
    };
  } else if (config.graphiql === false) {
    graphiqlOptionsOrFactory = false;
  } else if (typeof config.graphiql === "object") {
    graphiqlOptionsOrFactory = {
      title: productName,
      logo: graphiqlLogo,
      favicon: `data:image/png;base64,${iconBase64}`,
      defaultQuery: defaultQueryText,
      ...config.graphiql
    };
  } else if (typeof config.graphiql === "function") {
    const userGraphiqlFactory = config.graphiql;
    graphiqlOptionsOrFactory = function graphiqlOptionsFactoryForMesh(...args) {
      return handleMaybePromise(
        () => userGraphiqlFactory(...args),
        (resolvedOpts) => {
          if (resolvedOpts === false) {
            return false;
          }
          if (resolvedOpts === true) {
            return {
              title: productName,
              logo: graphiqlLogo,
              defaultQuery: defaultQueryText
            };
          }
          return {
            title: productName,
            logo: graphiqlLogo,
            favicon: `data:image/png;base64,${iconBase64}`,
            defaultQuery: defaultQueryText,
            ...resolvedOpts
          };
        }
      );
    };
  }
  let landingPageRenderer;
  if (config.landingPage == null || config.landingPage === true) {
    landingPageRenderer = (opts) => new opts.fetchAPI.Response(
      html.replace(/__GRAPHIQL_PATHNAME__/g, opts.graphqlEndpoint).replace(/__REQUEST_PATHNAME__/g, opts.url.pathname).replace(/__GRAPHQL_URL__/g, opts.url.origin + opts.graphqlEndpoint).replaceAll(/__PRODUCT_NAME__/g, productName).replaceAll(/__PRODUCT_DESCRIPTION__/g, productDescription).replaceAll(/__PRODUCT_PACKAGE_NAME__/g, productPackageName).replace(/__PRODUCT_LINK__/, productLink),
      {
        status: 200,
        statusText: "OK",
        headers: {
          "Content-Type": "text/html"
        }
      }
    );
  } else if (typeof config.landingPage === "function") {
    landingPageRenderer = config.landingPage;
  } else if (config.landingPage === false) {
    landingPageRenderer = false;
  }
  const basePlugins = [
    useConfigInServerContext({ configContext }),
    defaultGatewayPlugin,
    unifiedGraphPlugin,
    readinessCheckPlugin,
    persistedDocumentsPlugin,
    reportingWithMaybePersistedDocumentsPlugin,
    useRetryOnSchemaReload()
  ];
  if (config.subgraphErrors !== false) {
    basePlugins.push(
      useSubgraphErrorPlugin(
        typeof config.subgraphErrors === "object" ? config.subgraphErrors : void 0
      )
    );
  }
  if (config.requestId !== false) {
    const reqIdPlugin = useRequestId(
      typeof config.requestId === "object" ? config.requestId : void 0
    );
    basePlugins.push(reqIdPlugin);
  }
  if (isDisposable(wrappedCache)) {
    const cacheDisposePlugin = {
      onDispose() {
        return dispose(wrappedCache);
      }
    };
    basePlugins.push(cacheDisposePlugin);
  }
  if (isDisposable(pubsub)) {
    const cacheDisposePlugin = {
      onDispose() {
        return dispose(pubsub);
      }
    };
    basePlugins.push(cacheDisposePlugin);
  }
  const extraPlugins = [];
  if (config.webhooks) {
    extraPlugins.push(useWebhooks(configContext));
  }
  if (config.contentEncoding) {
    extraPlugins.push(
      useContentEncoding(
        typeof config.contentEncoding === "object" ? config.contentEncoding : {}
      )
    );
  }
  if (config.deferStream) {
    extraPlugins.push(useDeferStream());
  }
  if (config.executionCancellation) {
    extraPlugins.push(useExecutionCancellation());
  }
  if (config.upstreamCancellation) {
    extraPlugins.push(useUpstreamCancel());
  }
  if (config.disableIntrospection) {
    extraPlugins.push(
      useDisableIntrospection(
        // @ts-expect-error - Should be fixed in the envelop plugin
        typeof config.disableIntrospection === "object" ? config.disableIntrospection : {}
      )
    );
  }
  if (config.csrfPrevention) {
    extraPlugins.push(
      useCSRFPrevention(
        typeof config.csrfPrevention === "object" ? config.csrfPrevention : {}
      )
    );
  }
  if (config.customAgent) {
    extraPlugins.push(useCustomAgent(config.customAgent));
  }
  if (config.genericAuth) {
    extraPlugins.push(useGenericAuth(config.genericAuth));
  }
  if (config.hmacSignature) {
    extraPlugins.push(useHmacUpstreamSignature(config.hmacSignature));
  }
  if (config.propagateHeaders) {
    extraPlugins.push(usePropagateHeaders(config.propagateHeaders));
  }
  if (config.upstreamTimeout) {
    extraPlugins.push(useUpstreamTimeout(config.upstreamTimeout));
  }
  if (config.upstreamRetry) {
    extraPlugins.push(useUpstreamRetry(config.upstreamRetry));
  }
  if (config.demandControl) {
    if ("proxy" in config && config.schema == null) {
      log.warn(
        '`demandControl` is enabled in proxy mode without a defined schemaIf you use directives like "@cost" or "@listSize", these won\'t be available for cost calculation.You have to define "schema" in the gateway config to make them available.'
      );
    }
    extraPlugins.push(useDemandControl(config.demandControl));
  }
  if (config.cookies) {
    extraPlugins.push(useCookies());
  }
  if (config.responseCaching) {
    extraPlugins.push(
      // @ts-expect-error TODO: what's up with type narrowing
      useMeshResponseCache({
        ...configContext,
        ...config.responseCaching
      })
    );
  }
  extraPlugins.push(
    useSubgraphExecuteDebug(),
    useFetchDebug(),
    useMaybeDelegationPlanDebug({ log: configContext.log }),
    useCacheDebug({ log: configContext.log })
  );
  const yoga = createYoga({
    // @ts-expect-error Types???
    schema: unifiedGraph,
    // @ts-expect-error MeshFetch is not compatible with YogaFetch
    fetchAPI: config.fetchAPI,
    logging: LegacyLogger.from(log),
    plugins: [
      ...basePlugins,
      ...extraPlugins,
      ...config.plugins?.(configContext) || []
    ],
    context(ctx) {
      if (!ctx.headers) {
        ctx["headers"] = getHeadersObj(
          ctx["req"]?.headers || ctx?.request?.headers
        );
      }
      if (ctx["connectionParams"]) {
        ctx["headers"] = { ...ctx["headers"], ...ctx["connectionParams"] };
      }
      return contextBuilder?.(ctx) ?? ctx;
    },
    cors: config.cors,
    graphiql: graphiqlOptionsOrFactory,
    renderGraphiQL: config.renderGraphiQL,
    batching: config.batching,
    graphqlEndpoint: config.graphqlEndpoint,
    maskedErrors: config.maskedErrors,
    healthCheckEndpoint: config.healthCheckEndpoint || "/healthcheck",
    landingPage: landingPageRenderer,
    disposeOnProcessTerminate: true,
    multipart: config.multipart ?? false
  });
  fetchAPI ||= yoga.fetchAPI;
  Object.defineProperties(yoga, {
    version: {
      get() {
        return globalThis.__VERSION__;
      }
    },
    invalidateUnifiedGraph: {
      value: schemaInvalidator,
      configurable: true
    },
    getSchema: {
      value: getSchema,
      configurable: true
    }
  });
  return yoga;
}
function isDynamicUnifiedGraphSchema(schema) {
  if (isSchema(schema)) {
    return false;
  }
  if (isDocumentNode(schema)) {
    return false;
  }
  if (typeof schema === "string") {
    if (isUrl(schema)) {
      return true;
    }
    if (isValidPath(schema)) {
      return false;
    }
    try {
      parse(schema, { noLocation: true });
      return false;
    } catch (e) {
    }
  }
  return true;
}

function useCustomFetch(fetch) {
  return {
    onFetch({ setFetchFn }) {
      setFetchFn(fetch);
    }
  };
}

const useStaticFiles = ({
  baseDir,
  staticFiles = "public"
}) => {
  return {
    onRequest({ request, url, endResponse, fetchAPI }) {
      if (request.method === "GET") {
        let relativePath = url.pathname;
        if (relativePath === "/" || !relativePath) {
          relativePath = "index.html";
        }
        const absoluteStaticFilesPath = path.join(baseDir, staticFiles);
        const absolutePath = path.join(absoluteStaticFilesPath, relativePath);
        if (absolutePath.startsWith(absoluteStaticFilesPath)) {
          return pathExists(absolutePath).then((exists) => {
            if (exists) {
              const readStream = fs.createReadStream(absolutePath);
              endResponse(
                new fetchAPI.Response(readStream, {
                  status: 200
                })
              );
            }
          });
        }
      }
    }
  };
};

function getGraphQLWSOptions(gwRuntime, onContext) {
  return {
    execute: (args) => args.rootValue.execute(args),
    subscribe: (args) => args.rootValue.subscribe(args),
    onSubscribe: async (ctx, idOrMessage, payloadOrUndefined) => {
      let payload;
      if (typeof idOrMessage === "string") {
        payload = payloadOrUndefined;
      } else {
        payload = idOrMessage.payload;
      }
      const { schema, execute: execute2, subscribe: subscribe2, contextFactory, parse, validate } = gwRuntime.getEnveloped({
        connectionParams: ctx.connectionParams,
        waitUntil: gwRuntime.waitUntil,
        ...await onContext(ctx)
      });
      const args = {
        schema: schema || await gwRuntime.getSchema(),
        operationName: payload.operationName,
        document: parse(payload.query),
        variableValues: payload.variables,
        contextValue: await contextFactory(),
        rootValue: {
          execute: execute2,
          subscribe: subscribe2
        }
      };
      if (args.schema) {
        const errors = validate(args.schema, args.document);
        if (errors.length) return errors;
      }
      return args;
    }
  };
}

export { createGatewayRuntime, createLoggerFromLogging, getGraphQLWSOptions, getProxyExecutor, getRetryInfo, isRetryExecutionRequest, useCustomFetch, usePropagateHeaders, useStaticFiles, useUpstreamRetry, useUpstreamTimeout };