@mintlify/prebuild 1.0.1189 → 1.0.1191

package/dist/prebuild/update/docsConfig/generateSdkDivisions.js

@@ -0,0 +1,304 @@
+import { generateSdkReference } from '@mintlify/scraping';
+import { Unzip, UnzipInflate } from 'fflate';
+import fse from 'fs-extra';
+import os from 'node:os';
+import path from 'node:path';
+import { getGeneratedRouteKey } from './generatedRouteCollisions.js';
+import { loadRemoteFile } from './loadRemoteGraphqlSdl.js';
+const DEFAULT_OUTPUT_DIR = 'sdk-reference';
+const REMOTE_ARTIFACT_LABEL = 'SDK artifact';
+const MAX_REMOTE_SDK_ARTIFACT_BYTES = 50 * 1024 * 1024;
+const MAX_EXTRACTED_SDK_ARTIFACT_BYTES = 200 * 1024 * 1024;
+const REMOTE_SDK_ARTIFACT_TIMEOUT_MS = 30_000;
+export async function generateSdkDivisionsFromDocsConfig(docsConfig, loadReference) {
+    const references = new Map();
+    const pagesByRouteKey = new Map();
+    function load(config) {
+        const key = `${config.format}:${config.source}`;
+        let pending = references.get(key);
+        if (!pending) {
+            pending = loadReference(config);
+            references.set(key, pending);
+        }
+        return pending;
+    }
+    async function processNode(value) {
+        if (Array.isArray(value))
+            return Promise.all(value.map(processNode));
+        if (typeof value !== 'object' || value === null)
+            return value;
+        const node = value;
+        if ('tab' in node && 'sdk' in node) {
+            const { sdk, ...tab } = node;
+            const config = sdk;
+            const directory = config.directory ?? DEFAULT_OUTPUT_DIR;
+            const reference = await load(config);
+            const pageBySlug = new Map(reference.pages.map((page) => [page.slug, page]));
+            const referenceSlugs = new Set(reference.pages.map((page) => page.slug));
+            const groups = reference.groups.map((group) => ({
+                group: group.group,
+                pages: group.pages.map((slug) => path.posix.join(directory, slug)),
+            }));
+            for (const page of reference.pages) {
+                assertSafeSlug(page.slug, config);
+                const slug = path.posix.join(directory, page.slug);
+                const generatedPage = {
+                    slug,
+                    title: page.title,
+                    ...(page.description ? { description: page.description } : {}),
+                    ...(page.tag ? { tag: page.tag } : {}),
+                    content: prefixInternalLinks(stripLeadingDescription(page.content, page.description), directory, referenceSlugs),
+                    format: config.format,
+                    source: config.source,
+                };
+                const routeKey = getGeneratedRouteKey(slug);
+                const existingPage = pagesByRouteKey.get(routeKey);
+                if (existingPage &&
+                    (existingPage.slug !== slug ||
+                        existingPage.format !== generatedPage.format ||
+                        existingPage.source !== generatedPage.source)) {
+                    throw new Error(`Multiple SDK references generate colliding routes "${existingPage.slug}" and "${slug}"`);
+                }
+                pagesByRouteKey.set(routeKey, generatedPage);
+            }
+            const orphanedSlugs = reference.pages
+                .map((page) => page.slug)
+                .filter((slug) => !reference.groups.some((group) => group.pages.includes(slug)));
+            if (orphanedSlugs.length > 0 && pageBySlug.size > 0) {
+                groups.push({
+                    group: 'Reference',
+                    pages: orphanedSlugs.map((slug) => path.posix.join(directory, slug)),
+                });
+            }
+            return { ...tab, groups: [...(tab.groups ?? []), ...groups] };
+        }
+        return Object.fromEntries(await Promise.all(Object.entries(node).map(async ([key, entry]) => [key, await processNode(entry)])));
+    }
+    const navigation = (await processNode(docsConfig.navigation));
+    const generatedPages = [...pagesByRouteKey.values()].sort((left, right) => left.slug.localeCompare(right.slug));
+    const pagesAcc = Object.fromEntries(generatedPages.map((page) => [
+        page.slug,
+        {
+            href: `/${page.slug}`,
+            title: page.title,
+            ...(page.description ? { description: page.description } : {}),
+            ...(page.tag ? { tag: page.tag } : {}),
+        },
+    ]));
+    return {
+        newDocsConfig: { ...docsConfig, navigation },
+        pagesAcc,
+        generatedPages,
+        generatedRoutes: generatedPages.map(({ slug }) => slug),
+    };
+}
+export const isRemoteSdkSource = (source) => {
+    try {
+        return new URL(source).protocol === 'https:';
+    }
+    catch {
+        return false;
+    }
+};
+function assertSafeArchiveEntry(name, source) {
+    const segments = name.split('/');
+    if (name.includes('\\') ||
+        path.posix.isAbsolute(name) ||
+        path.win32.isAbsolute(name) ||
+        segments.some((segment) => segment === '.' || segment === '..')) {
+        throw new Error(`SDK artifact ${source} contains an unsafe archive entry "${name}"`);
+    }
+}
+function unzipWithSizeCap(bytes, source) {
+    const entries = new Map();
+    let extractedBytes = 0;
+    let failure;
+    const overflow = () => new Error(`SDK artifact ${source} exceeds the ${MAX_EXTRACTED_SDK_ARTIFACT_BYTES} byte extracted size limit`);
+    const unzip = new Unzip((file) => {
+        try {
+            assertSafeArchiveEntry(file.name, source);
+        }
+        catch (error) {
+            failure ??= error instanceof Error ? error : new Error(String(error));
+            return;
+        }
+        if (file.name.endsWith('/'))
+            return;
+        const chunks = [];
+        file.ondata = (error, data, final) => {
+            if (failure)
+                return;
+            if (error) {
+                failure = error;
+                return;
+            }
+            extractedBytes += data.byteLength;
+            if (extractedBytes > MAX_EXTRACTED_SDK_ARTIFACT_BYTES) {
+                failure = overflow();
+                file.terminate();
+                return;
+            }
+            chunks.push(data);
+            if (final) {
+                const merged = new Uint8Array(chunks.reduce((size, chunk) => size + chunk.byteLength, 0));
+                let offset = 0;
+                for (const chunk of chunks) {
+                    merged.set(chunk, offset);
+                    offset += chunk.byteLength;
+                }
+                entries.set(file.name, merged);
+            }
+        };
+        file.start();
+    });
+    unzip.register(UnzipInflate);
+    unzip.push(bytes, true);
+    if (failure)
+        throw failure;
+    return entries;
+}
+async function extractRemoteArtifact(buffer, source, tempDir) {
+    const bytes = new Uint8Array(buffer.buffer, buffer.byteOffset, buffer.byteLength);
+    if (bytes[0] !== 0x50 || bytes[1] !== 0x4b) {
+        const basename = path.posix.basename(new URL(source).pathname) || 'artifact';
+        const filePath = path.join(tempDir, basename.replace(/[^\w.-]+/g, '-'));
+        await fse.writeFile(filePath, buffer);
+        return filePath;
+    }
+    const entries = unzipWithSizeCap(bytes, source);
+    for (const [name, data] of entries) {
+        await fse.outputFile(path.join(tempDir, name), Buffer.from(data));
+    }
+    let root = tempDir;
+    for (;;) {
+        const rootEntries = await fse.readdir(root, { withFileTypes: true });
+        if (rootEntries.length !== 1 || !rootEntries[0])
+            return root;
+        const only = path.join(root, rootEntries[0].name);
+        if (rootEntries[0].isFile())
+            return only;
+        root = only;
+    }
+}
+async function loadRemoteSdkReference(config, remoteOptions) {
+    const buffer = await loadRemoteFile(config.source, {
+        label: REMOTE_ARTIFACT_LABEL,
+        maxBytes: MAX_REMOTE_SDK_ARTIFACT_BYTES,
+        timeoutMs: REMOTE_SDK_ARTIFACT_TIMEOUT_MS,
+        ...remoteOptions,
+    });
+    const tempDir = await fse.mkdtemp(path.join(os.tmpdir(), 'mintlify-sdk-'));
+    try {
+        const artifactPath = await extractRemoteArtifact(buffer, config.source, tempDir);
+        return await generateSdkReference(config.format, artifactPath);
+    }
+    finally {
+        await fse.remove(tempDir);
+    }
+}
+export async function loadSdkReferenceSource(config, contentDirectoryPath, remoteOptions) {
+    const { format, source } = config;
+    if (isRemoteSdkSource(source)) {
+        return loadRemoteSdkReference(config, remoteOptions);
+    }
+    if (path.isAbsolute(source) || path.win32.isAbsolute(source)) {
+        throw new Error(`Unable to load SDK reference ${source}: path must be relative`);
+    }
+    const contentRoot = await fse.realpath(contentDirectoryPath);
+    const candidatePath = path.resolve(contentRoot, source);
+    const assertContained = (target, label) => {
+        const relativePath = path.relative(contentRoot, target);
+        if (relativePath === '..' ||
+            relativePath.startsWith(`..${path.sep}`) ||
+            path.isAbsolute(relativePath)) {
+            throw new Error(`Unable to load SDK reference ${source}: ${label}`);
+        }
+    };
+    assertContained(candidatePath, 'path escapes the content directory');
+    const realSourcePath = await fse.realpath(candidatePath);
+    assertContained(realSourcePath, 'path resolves outside the content directory');
+    return generateSdkReference(format, realSourcePath);
+}
+function prefixInternalLinks(content, directory, slugs) {
+    return content.replace(/\]\(\/([^)#\s]+)((?:#[^)\s]*)?)\)/g, (match, target, fragment) => slugs.has(target) ? `](/${path.posix.join(directory, target)}${fragment})` : match);
+}
+function assertSafeSlug(slug, config) {
+    const segments = slug.split('/');
+    if (!slug ||
+        slug.includes('\\') ||
+        path.posix.isAbsolute(slug) ||
+        segments.some((segment) => segment === '' || segment === '.' || segment === '..')) {
+        throw new Error(`SDK reference ${config.format}:${config.source} produced an unsafe page slug "${slug}"`);
+    }
+}
+function normalizeProse(text) {
+    return text
+        .replace(/!?\[([^\]]*)\]\([^)]*\)/g, '$1')
+        .replace(/[`*_\\]/g, '')
+        .replace(/\s+/g, ' ')
+        .trim();
+}
+function stripLeadingDescription(content, description) {
+    if (!description)
+        return content;
+    const [firstChunk = '', ...rest] = content.split('\n\n');
+    if (/^[#<>`-]/.test(firstChunk.trim()))
+        return content;
+    const matches = normalizeProse(firstChunk) === normalizeProse(description);
+    return matches ? rest.join('\n\n').trim() : content;
+}
+function frontmatter(page) {
+    const fields = [
+        `title: ${JSON.stringify(page.title)}`,
+        ...(page.description ? [`description: ${JSON.stringify(page.description)}`] : []),
+        ...(page.tag ? [`tag: ${JSON.stringify(page.tag)}`] : []),
+    ];
+    return `---\n${fields.join('\n')}\n---\n\n`;
+}
+function getContainedSdkPagePath(targetDir, page) {
+    const propsDirectory = path.resolve(targetDir ?? '', 'src', '_props');
+    const pagePath = path.resolve(propsDirectory, `${page}.mdx`);
+    const relativePath = path.relative(propsDirectory, pagePath);
+    if (relativePath.startsWith(`..${path.sep}`) ||
+        relativePath === '..' ||
+        path.isAbsolute(relativePath)) {
+        return undefined;
+    }
+    return pagePath;
+}
+export async function writeSdkArtifacts(result, targetDir) {
+    const propsDirectory = path.resolve(targetDir ?? '', 'src', '_props');
+    const manifestPath = path.join(propsDirectory, 'sdk-data.json');
+    let previousPages = [];
+    try {
+        const previousManifest = JSON.parse(await fse.readFile(manifestPath, 'utf8'));
+        if (Array.isArray(previousManifest.pages)) {
+            previousPages = previousManifest.pages.filter((page) => typeof page === 'string');
+        }
+    }
+    catch { }
+    await Promise.all(previousPages.map(async (page) => {
+        const pagePath = getContainedSdkPagePath(targetDir, page);
+        if (!pagePath)
+            return;
+        try {
+            await fse.remove(pagePath);
+        }
+        catch (error) {
+            console.warn(`Failed to remove stale SDK reference page ${page}: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }));
+    await fse.remove(manifestPath);
+    if (result.generatedPages.length === 0)
+        return;
+    await fse.outputFile(manifestPath, JSON.stringify({ pages: result.generatedRoutes }), {
+        flag: 'w',
+    });
+    await Promise.all(result.generatedPages.map((page) => {
+        const pagePath = getContainedSdkPagePath(targetDir, page.slug);
+        if (!pagePath) {
+            throw new Error(`SDK reference page "${page.slug}" resolves outside the output directory`);
+        }
+        return fse.outputFile(pagePath, `${frontmatter(page)}${page.content}\n`, { flag: 'w' });
+    }));
+}

package/dist/prebuild/update/docsConfig/index.d.ts

@@ -24,6 +24,8 @@ export declare function updateDocsConfigFile({ contentDirectoryPath, openApiFile
 }>;
 export { generateOpenApiDivisions } from './generateOpenApiDivisions.js';
 export { generateOpenApiFromDocsConfig } from './generateOpenApiFromDocsConfig.js';
+export { generateSdkDivisionsFromDocsConfig, loadSdkReferenceSource, writeSdkArtifacts, } from './generateSdkDivisions.js';
+export type { GeneratedSdkPage, GenerateSdkDivisionsResult, SdkReferenceLoader, } from './generateSdkDivisions.js';
 export { getOpenApiFilesFromConfig } from '../read/getOpenApiFilesFromConfig.js';
 export { generateAsyncApiDivisions } from './generateAsyncApiDivisions.js';
 export { generateAsyncApiFromDocsConfig } from './generateAsyncApiFromDocsConfig.js';

package/dist/prebuild/update/docsConfig/index.js

@@ -1,8 +1,10 @@
 import { getConfigPath } from '../../../utils.js';
 import { DocsConfigUpdater } from '../ConfigUpdater.js';
 import { generateAsyncApiDivisions } from './generateAsyncApiDivisions.js';
+import { assertNoGeneratedRouteCollisions } from './generatedRouteCollisions.js';
 import { generateGraphqlDivisionsFromDocsConfig, loadGraphqlSdlSource, writeGraphqlArtifacts, } from './generateGraphqlDivisions.js';
 import { generateOpenApiDivisions } from './generateOpenApiDivisions.js';
+import { generateSdkDivisionsFromDocsConfig, loadSdkReferenceSource, writeSdkArtifacts, } from './generateSdkDivisions.js';
 import { getCustomLanguages } from './getCustomLanguages.js';
 const NOT_CORRECT_PATH_ERROR = 'must be run in a directory where a docs.json file exists.';
 export async function updateDocsConfigFile({ contentDirectoryPath, openApiFiles, asyncApiFiles, docsConfig, localSchema, disableOpenApi, strict, invalidSpecFiles, allowSourceRefs, }) {
@@ -30,16 +32,24 @@ export async function updateDocsConfigFile({ contentDirectoryPath, openApiFiles,
             flushWrites: async () => { },
         };
     const { newDocsConfig: docsConfigWithAsyncApiPages, pagesAcc: pagesAccWithAsyncApiPages, asyncApiFiles: newAsyncApiFiles, flushWrites: flushAsyncApiWrites, } = await generateAsyncApiDivisions(docsConfigWithOpenApiPages, asyncApiFiles, undefined, localSchema, pagesAccWithGraphqlPages, true, true);
+    const sdkResult = await generateSdkDivisionsFromDocsConfig(docsConfigWithAsyncApiPages, (config) => loadSdkReferenceSource(config, contentDirectoryPath));
+    const { newDocsConfig: docsConfigWithSdkPages, pagesAcc: pagesAccWithSdkPages } = sdkResult;
+    const sdkRoutes = { label: 'SDK', pages: pagesAccWithSdkPages };
+    assertNoGeneratedRouteCollisions({ label: 'GraphQL', pages: pagesAccWithGraphqlPages }, sdkRoutes);
+    assertNoGeneratedRouteCollisions({ label: 'OpenAPI', pages: pagesAccWithOpenApiPages }, sdkRoutes);
+    assertNoGeneratedRouteCollisions({ label: 'AsyncAPI', pages: pagesAccWithAsyncApiPages }, sdkRoutes);
     const pagesAcc = {
         ...pagesAccWithOpenApiPages,
         ...pagesAccWithAsyncApiPages,
         ...pagesAccWithGraphqlPages,
+        ...pagesAccWithSdkPages,
     };
     await Promise.all([flushOpenApiWrites(), flushAsyncApiWrites()]);
     await writeGraphqlArtifacts(graphqlResult);
-    await DocsConfigUpdater.writeConfigFile(docsConfigWithAsyncApiPages);
+    await writeSdkArtifacts(sdkResult);
+    await DocsConfigUpdater.writeConfigFile(docsConfigWithSdkPages);
     return {
-        docsConfig: docsConfigWithAsyncApiPages,
+        docsConfig: docsConfigWithSdkPages,
         pagesAcc,
         newOpenApiFiles,
         newAsyncApiFiles,
@@ -48,6 +58,7 @@ export async function updateDocsConfigFile({ contentDirectoryPath, openApiFiles,
 }
 export { generateOpenApiDivisions } from './generateOpenApiDivisions.js';
 export { generateOpenApiFromDocsConfig } from './generateOpenApiFromDocsConfig.js';
+export { generateSdkDivisionsFromDocsConfig, loadSdkReferenceSource, writeSdkArtifacts, } from './generateSdkDivisions.js';
 export { getOpenApiFilesFromConfig } from '../read/getOpenApiFilesFromConfig.js';
 export { generateAsyncApiDivisions } from './generateAsyncApiDivisions.js';
 export { generateAsyncApiFromDocsConfig } from './generateAsyncApiFromDocsConfig.js';

package/dist/prebuild/update/docsConfig/loadRemoteGraphqlSdl.d.ts

@@ -9,10 +9,13 @@ type ResolveHostname = (hostname: string) => Promise<ResolvedAddress[]>;
 type HttpsRequest = typeof request;
 export declare const isGlobalIpAddress: (address: string) => boolean;
 export declare function createPinnedLookup(resolved: ResolvedAddress): LookupFunction;
-export declare function loadRemoteGraphqlSdl(source: string, options?: {
+export type LoadRemoteFileOptions = {
     timeoutMs?: number;
     maxBytes?: number;
     resolveHostname?: ResolveHostname;
     requestImpl?: HttpsRequest;
-}): Promise<string>;
+    label?: string;
+};
+export declare function loadRemoteGraphqlSdl(source: string, options?: LoadRemoteFileOptions): Promise<string>;
+export declare function loadRemoteFile(source: string, options?: LoadRemoteFileOptions): Promise<Buffer>;
 export {};

package/dist/prebuild/update/docsConfig/loadRemoteGraphqlSdl.js

@@ -4,6 +4,7 @@ import { BlockList, isIP } from 'node:net';
 const MAX_REMOTE_REDIRECTS = 5;
 export const MAX_GRAPHQL_SCHEMA_BYTES = 5 * 1024 * 1024;
 const REMOTE_SCHEMA_TIMEOUT_MS = 10_000;
+const DEFAULT_LABEL = 'GraphQL schema';
 const blockedAddresses = new BlockList();
 for (const [network, prefix] of [
     ['0.0.0.0', 8],
@@ -66,17 +67,25 @@ async function defaultResolveHostname(hostname) {
     return (await lookup(hostname, { all: true }));
 }
 export function createPinnedLookup(resolved) {
-    return ((_hostname, _options, callback) => {
-        callback(null, resolved.address, resolved.family);
+    return ((_hostname, options, callback) => {
+        const withAll = typeof options === 'object' && options?.all;
+        if (withAll) {
+            callback(null, [
+                resolved,
+            ]);
+        }
+        else {
+            callback(null, resolved.address, resolved.family);
+        }
     });
 }
-async function resolveAndValidate(url, resolveHostname) {
+async function resolveAndValidate(url, resolveHostname, label) {
     if (url.protocol !== 'https:') {
-        throw new Error(`GraphQL schema redirects must use HTTPS: ${url.href}`);
+        throw new Error(`${label} redirects must use HTTPS: ${url.href}`);
     }
     const hostname = url.hostname.toLowerCase().replace(/^\[|\]$/g, '');
     if (hostname === 'localhost' || hostname.endsWith('.localhost')) {
-        throw new Error(`GraphQL schema host must be public: ${hostname}`);
+        throw new Error(`${label} host must be public: ${hostname}`);
     }
     let addresses;
     try {
@@ -84,15 +93,15 @@ async function resolveAndValidate(url, resolveHostname) {
     }
     catch (error) {
         const detail = error instanceof Error ? `: ${error.message}` : '';
-        throw new Error(`Unable to resolve GraphQL schema host ${hostname}${detail}`);
+        throw new Error(`Unable to resolve ${label} host ${hostname}${detail}`);
     }
     // Reject ambiguous split-horizon answers so every address associated with the host is safe.
     if (addresses.length === 0 || addresses.some(({ address }) => !isGlobalIpAddress(address))) {
-        throw new Error(`GraphQL schema host must resolve only to public addresses: ${hostname}`);
+        throw new Error(`${label} host must resolve only to public addresses: ${hostname}`);
     }
     return addresses[0];
 }
-function requestPinned(url, resolved, requestImpl, timeoutMs, maxBytes) {
+function requestPinned(url, resolved, requestImpl, timeoutMs, maxBytes, label) {
     return new Promise((resolve, reject) => {
         let responseRef;
         let requestRef;
@@ -125,7 +134,7 @@ function requestPinned(url, resolved, requestImpl, timeoutMs, maxBytes) {
                 const contentLength = Number(response.headers['content-length']);
                 if (Number.isFinite(contentLength) && contentLength > maxBytes) {
                     response.destroy();
-                    finish(reject, new Error(`GraphQL schema ${url.href} exceeds the ${maxBytes} byte limit`));
+                    finish(reject, new Error(`${label} ${url.href} exceeds the ${maxBytes} byte limit`));
                     return;
                 }
                 response.on('data', (chunk) => {
@@ -133,7 +142,7 @@ function requestPinned(url, resolved, requestImpl, timeoutMs, maxBytes) {
                     totalBytes += bytes.byteLength;
                     if (totalBytes > maxBytes) {
                         response.destroy();
-                        finish(reject, new Error(`GraphQL schema ${url.href} exceeds the ${maxBytes} byte limit`));
+                        finish(reject, new Error(`${label} ${url.href} exceeds the ${maxBytes} byte limit`));
                         return;
                     }
                     chunks.push(new Uint8Array(bytes));
@@ -143,7 +152,7 @@ function requestPinned(url, resolved, requestImpl, timeoutMs, maxBytes) {
                         statusCode: response.statusCode ?? 0,
                         statusMessage: response.statusMessage ?? '',
                         headers: response.headers,
-                        body: Buffer.concat(chunks).toString('utf8'),
+                        body: Buffer.concat(chunks),
                     });
                 });
                 response.on('error', (error) => finish(reject, error));
@@ -158,10 +167,14 @@ function requestPinned(url, resolved, requestImpl, timeoutMs, maxBytes) {
     });
 }
 export async function loadRemoteGraphqlSdl(source, options = {}) {
+    return (await loadRemoteFile(source, options)).toString('utf8');
+}
+export async function loadRemoteFile(source, options = {}) {
     const timeoutMs = options.timeoutMs ?? REMOTE_SCHEMA_TIMEOUT_MS;
     const maxBytes = options.maxBytes ?? MAX_GRAPHQL_SCHEMA_BYTES;
     const resolveHostname = options.resolveHostname ?? defaultResolveHostname;
     const requestImpl = options.requestImpl ?? request;
+    const label = options.label ?? DEFAULT_LABEL;
     const deadline = Date.now() + timeoutMs;
     let currentUrl = new URL(source);
     const withTimeout = async (pending, remainingMs) => {
@@ -182,36 +195,36 @@ export async function loadRemoteGraphqlSdl(source, options = {}) {
     for (let redirects = 0; redirects <= MAX_REMOTE_REDIRECTS; redirects++) {
         let remainingMs = deadline - Date.now();
         if (remainingMs <= 0)
-            throw new Error(`Timed out loading GraphQL schema ${source}`);
+            throw new Error(`Timed out loading ${label} ${source}`);
         let response;
         try {
-            const resolved = await withTimeout(resolveAndValidate(currentUrl, resolveHostname), remainingMs);
+            const resolved = await withTimeout(resolveAndValidate(currentUrl, resolveHostname, label), remainingMs);
             remainingMs = deadline - Date.now();
             if (remainingMs <= 0)
                 throw new Error('timeout');
-            response = await requestPinned(currentUrl, resolved, requestImpl, remainingMs, maxBytes);
+            response = await requestPinned(currentUrl, resolved, requestImpl, remainingMs, maxBytes, label);
         }
         catch (error) {
             if (Date.now() >= deadline || (error instanceof Error && error.message === 'timeout')) {
-                throw new Error(`Timed out loading GraphQL schema ${source}`);
+                throw new Error(`Timed out loading ${label} ${source}`);
             }
             throw error;
         }
         if (response.statusCode >= 300 && response.statusCode < 400) {
             const location = response.headers.location;
             if (typeof location !== 'string') {
-                throw new Error(`GraphQL schema redirect from ${currentUrl.href} has no location`);
+                throw new Error(`${label} redirect from ${currentUrl.href} has no location`);
             }
             if (redirects === MAX_REMOTE_REDIRECTS) {
-                throw new Error(`Too many redirects loading GraphQL schema ${source}`);
+                throw new Error(`Too many redirects loading ${label} ${source}`);
             }
             currentUrl = new URL(location, currentUrl);
             continue;
         }
         if (response.statusCode < 200 || response.statusCode >= 300) {
-            throw new Error(`Unable to load GraphQL schema ${currentUrl.href}: ${response.statusCode} ${response.statusMessage}`);
+            throw new Error(`Unable to load ${label} ${currentUrl.href}: ${response.statusCode} ${response.statusMessage}`);
         }
         return response.body;
     }
-    throw new Error(`Too many redirects loading GraphQL schema ${source}`);
+    throw new Error(`Too many redirects loading ${label} ${source}`);
 }