@mnaoumov/typescript-dev-toolkit 3.0.0 → 3.2.0

package/dist/lib/esm/docs-site/link-check.mjs

@@ -46,20 +46,47 @@ const LINK_ATTRIBUTE_REGEX = /\b(?:href|src)=(?<quote>['"])(?<value>.*?)\k<quote
 const ID_ATTRIBUTE_REGEX = /\bid=(?<quote>['"])(?<value>.*?)\k<quote>/giu;
 const HTTP_OK_STATUS = 200;
 const NETWORK_FAILURE_STATUS = 0;
-async function collectBrokenExternalLinks(targets, fetchUrlStatus, concurrency) {
-  const entries = [...targets];
-  const results = Array.from({ length: entries.length }, () => null);
-  let nextIndex = 0;
+const DEFAULT_EXTERNAL_LINK_PER_HOST_CONCURRENCY = 8;
+const DEFAULT_EXTERNAL_LINK_RETRY_INITIAL_DELAY_IN_MILLISECONDS = 1e3;
+const DEFAULT_EXTERNAL_LINK_RETRY_MAX_DELAY_IN_MILLISECONDS = 16e3;
+const DEFAULT_EXTERNAL_LINK_RETRY_TOTAL_BUDGET_IN_MILLISECONDS = 45e3;
+const HTTP_TOO_MANY_REQUESTS_STATUS = 429;
+const HTTP_SERVER_ERROR_MIN_STATUS = 500;
+const MILLISECONDS_PER_SECOND = 1e3;
+const JITTER_FLOOR = 0.5;
+const BACKOFF_FACTOR = 2;
+async function collectBrokenExternalLinks(targets, fetchUrlStatus, concurrency, options = {}) {
+  const perHostConcurrency = Math.max(1, options.perHostConcurrency ?? DEFAULT_EXTERNAL_LINK_PER_HOST_CONCURRENCY);
+  const pending = [...targets].map(([url, pageUrl], index) => ({ host: new URL(url).host, index, pageUrl, url }));
+  const results = Array.from({ length: pending.length }, () => null);
+  const inFlightByHost = /* @__PURE__ */ new Map();
+  const waiters = [];
   async function runWorker() {
-    for (let index = nextIndex++; index < entries.length; index = nextIndex++) {
-      const [externalUrl, pageUrl] = ensureNonNullable(entries[index]);
-      const httpStatus = await fetchUrlStatus(externalUrl);
-      if (httpStatus !== HTTP_OK_STATUS) {
-        results[index] = { httpStatus, pageUrl, reason: "external-error", targetUrl: externalUrl };
+    while (pending.length > 0) {
+      const position = pending.findIndex((probe2) => (inFlightByHost.get(probe2.host) ?? 0) < perHostConcurrency);
+      if (position === -1) {
+        await new Promise((resolvePromise) => {
+          waiters.push(resolvePromise);
+        });
+        continue;
+      }
+      const [probe] = pending.splice(position, 1);
+      const { host, index, pageUrl, url } = ensureNonNullable(probe);
+      inFlightByHost.set(host, (inFlightByHost.get(host) ?? 0) + 1);
+      try {
+        const httpStatus = await probeWithRetry(url, fetchUrlStatus, options.retry ?? {});
+        if (httpStatus !== HTTP_OK_STATUS) {
+          results[index] = { httpStatus, pageUrl, reason: "external-error", targetUrl: url };
+        }
+      } finally {
+        inFlightByHost.set(host, ensureNonNullable(inFlightByHost.get(host)) - 1);
+        for (const wake of waiters.splice(0)) {
+          wake();
+        }
       }
     }
   }
-  const workerCount = Math.max(1, Math.min(concurrency, entries.length));
+  const workerCount = Math.max(1, Math.min(concurrency, pending.length));
   await Promise.all(Array.from({ length: workerCount }, () => runWorker()));
   return results.filter((brokenLink) => brokenLink !== null);
 }
@@ -139,6 +166,17 @@ function isInternalDocUrl(targetUrl, siteBaseUrl) {
   const base = new URL(siteBaseUrl);
   return targetUrl.origin === base.origin && targetUrl.pathname.startsWith(base.pathname);
 }
+function parseRetryAfterInMilliseconds(headerValue, nowInMilliseconds) {
+  const trimmed = headerValue?.trim() ?? "";
+  if (trimmed === "") {
+    return void 0;
+  }
+  if (/^\d+$/u.test(trimmed)) {
+    return Number(trimmed) * MILLISECONDS_PER_SECOND;
+  }
+  const dateInMilliseconds = Date.parse(trimmed);
+  return Number.isNaN(dateInMilliseconds) ? void 0 : Math.max(0, dateInMilliseconds - nowInMilliseconds);
+}
 function resolveWithinRoot(outputRootPath, outputRelativePath) {
   const root = normalize(outputRootPath.replaceAll("\\", "/")).replace(/\/$/u, "");
   let joined = normalize(`${root}/${outputRelativePath.replaceAll("\\", "/")}`);
@@ -150,7 +188,40 @@ function resolveWithinRoot(outputRootPath, outputRelativePath) {
 function describeHttpStatus(httpStatus) {
   return httpStatus === void 0 || httpStatus === NETWORK_FAILURE_STATUS ? "a network failure" : `HTTP ${String(httpStatus)}`;
 }
+function isTransientStatus(status) {
+  return status === NETWORK_FAILURE_STATUS || status === HTTP_TOO_MANY_REQUESTS_STATUS || status >= HTTP_SERVER_ERROR_MIN_STATUS;
+}
+async function probeWithRetry(url, fetchUrlStatus, retry) {
+  const initialDelayInMilliseconds = retry.initialDelayInMilliseconds ?? DEFAULT_EXTERNAL_LINK_RETRY_INITIAL_DELAY_IN_MILLISECONDS;
+  const maxDelayInMilliseconds = retry.maxDelayInMilliseconds ?? DEFAULT_EXTERNAL_LINK_RETRY_MAX_DELAY_IN_MILLISECONDS;
+  const totalBudgetInMilliseconds = retry.totalBudgetInMilliseconds ?? DEFAULT_EXTERNAL_LINK_RETRY_TOTAL_BUDGET_IN_MILLISECONDS;
+  const random = retry.random ?? Math.random;
+  const sleep = retry.sleep ?? sleepWithTimeout;
+  let waitedInMilliseconds = 0;
+  for (let attempt = 0; ; attempt++) {
+    const probeResult = await fetchUrlStatus(url);
+    const { retryAfterInMilliseconds, status } = typeof probeResult === "number" ? { retryAfterInMilliseconds: void 0, status: probeResult } : probeResult;
+    const remainingInMilliseconds = totalBudgetInMilliseconds - waitedInMilliseconds;
+    if (!isTransientStatus(status) || remainingInMilliseconds <= 0) {
+      return status;
+    }
+    const backoffInMilliseconds = Math.min(maxDelayInMilliseconds, initialDelayInMilliseconds * BACKOFF_FACTOR ** attempt);
+    const jitteredInMilliseconds = backoffInMilliseconds * (JITTER_FLOOR + (1 - JITTER_FLOOR) * random());
+    const delayInMilliseconds = Math.min(remainingInMilliseconds, Math.max(jitteredInMilliseconds, retryAfterInMilliseconds ?? 0));
+    await sleep(delayInMilliseconds);
+    waitedInMilliseconds += delayInMilliseconds;
+  }
+}
+function sleepWithTimeout(milliseconds) {
+  return new Promise((resolvePromise) => {
+    globalThis.setTimeout(resolvePromise, milliseconds);
+  });
+}
 export {
+  DEFAULT_EXTERNAL_LINK_PER_HOST_CONCURRENCY,
+  DEFAULT_EXTERNAL_LINK_RETRY_INITIAL_DELAY_IN_MILLISECONDS,
+  DEFAULT_EXTERNAL_LINK_RETRY_MAX_DELAY_IN_MILLISECONDS,
+  DEFAULT_EXTERNAL_LINK_RETRY_TOTAL_BUDGET_IN_MILLISECONDS,
   NETWORK_FAILURE_STATUS,
   collectBrokenExternalLinks,
   collectBrokenLinks,
@@ -161,6 +232,7 @@ export {
   getOutputRelativePath,
   getPageUrl,
   isInternalDocUrl,
+  parseRetryAfterInMilliseconds,
   resolveWithinRoot
 };
-//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../../../src/docs-site/link-check.ts"],"sourcesContent":["/**\n * @file\n *\n * Validation of the links emitted by the built documentation HTML.\n *\n * Internal (same-site) links are validated offline: every `href`/`src` must resolve to a real\n * file in the build output, and every `#fragment` must resolve to a real element id on the\n * target page.\n *\n * External links can only be validated over the network, so those requests are heavily\n * deduplicated — each unique external URL is fetched at most once regardless of how many of the\n * thousands of generated pages reference it — and run through a bounded concurrency pool.\n */\n\nimport { getMandatoryNamedGroup } from '@mnaoumov/typescript-lib/reg-exp';\nimport {\n  assertNever,\n  ensureNonNullable\n} from '@mnaoumov/typescript-lib/type-guards';\nimport { normalize } from 'node:path/posix';\n\nconst LINK_ATTRIBUTE_REGEX = /\\b(?:href|src)=(?<quote>['\"])(?<value>.*?)\\k<quote>/giu;\nconst ID_ATTRIBUTE_REGEX = /\\bid=(?<quote>['\"])(?<value>.*?)\\k<quote>/giu;\nconst HTTP_OK_STATUS = 200;\n\n/**\n * The {@link BrokenLink.httpStatus} sentinel for a network-level failure (timeout, DNS,\n * connection refused) where no HTTP response was received.\n */\nexport const NETWORK_FAILURE_STATUS = 0;\n\n/**\n * A single link that does not resolve.\n */\nexport interface BrokenLink {\n  /**\n   * The HTTP status returned by an external link, when {@link BrokenLink.reason} is\n   * `external-error`. `0` denotes a network-level failure (timeout, DNS, connection refused).\n   */\n  httpStatus?: number;\n\n  /**\n   * The absolute URL of the page that contains the broken link.\n   */\n  pageUrl: string;\n\n  /**\n   * Why the link is considered broken.\n   */\n  reason: 'external-error' | 'missing-fragment' | 'missing-page';\n\n  /**\n   * The resolved absolute URL the link points at.\n   */\n  targetUrl: string;\n}\n\n/**\n * A single built documentation page to validate.\n */\nexport interface DocumentationPage {\n  /**\n   * The page's rendered HTML.\n   */\n  html: string;\n\n  /**\n   * The page's path relative to the build-output root, e.g. `api/foo/index.html`.\n   */\n  relativePath: string;\n}\n\n/**\n * Filesystem access the link checker needs, injected so the pure decision logic can be tested\n * against an in-memory stub instead of a real build output.\n */\nexport interface LinkCheckFileSystem {\n  /**\n   * Reads the element ids present on an already-resolved page.\n   *\n   * @param pageKey - The key returned by {@link LinkCheckFileSystem.resolveExistingPage}.\n   * @returns The set of element ids on that page.\n   */\n  readIds: (pageKey: string) => Set<string>;\n\n  /**\n   * Resolves an output-relative path to an existing page.\n   *\n   * @param outputRelativePath - The decoded path relative to the build-output root.\n   * @returns A stable key (e.g. the resolved absolute file path) for the existing page, or\n   *   `null` when nothing exists at that path or the path escapes the build-output root.\n   */\n  resolveExistingPage: (outputRelativePath: string) => null | string;\n}\n\n/**\n * Validates the deduplicated external URLs over the network through a bounded concurrency pool.\n *\n * @param targets - The unique external URL → referencing page map from {@link collectExternalTargets}.\n * @param fetchUrlStatus - Injected probe returning the HTTP status for a URL (`0` for a network failure).\n * @param concurrency - The maximum number of in-flight probes.\n * @returns Every external URL that did not return HTTP `200`, in the map's iteration order.\n */\nexport async function collectBrokenExternalLinks(\n  targets: Map<string, string>,\n  fetchUrlStatus: (url: string) => Promise<number>,\n  concurrency: number\n): Promise<BrokenLink[]> {\n  const entries = [...targets];\n  const results: (BrokenLink | null)[] = Array.from({ length: entries.length }, () => null);\n  let nextIndex = 0;\n\n  async function runWorker(): Promise<void> {\n    for (let index = nextIndex++; index < entries.length; index = nextIndex++) {\n      const [externalUrl, pageUrl] = ensureNonNullable(entries[index]);\n      const httpStatus = await fetchUrlStatus(externalUrl);\n      if (httpStatus !== HTTP_OK_STATUS) {\n        results[index] = { httpStatus, pageUrl, reason: 'external-error', targetUrl: externalUrl };\n      }\n    }\n  }\n\n  const workerCount = Math.max(1, Math.min(concurrency, entries.length));\n  await Promise.all(Array.from({ length: workerCount }, () => runWorker()));\n\n  // Indexed assignment above keeps failures in the map's iteration order; drop the successful gaps.\n  return results.filter((brokenLink): brokenLink is BrokenLink => brokenLink !== null);\n}\n\n/**\n * Finds every internal link across the built documentation pages that does not resolve.\n *\n * External and non-HTTP links are ignored. Each internal link must resolve to an existing page,\n * and each `#fragment` must resolve to an existing element id on the target page.\n *\n * @param pages - The built documentation pages to validate.\n * @param fileSystem - Injected access to the build output.\n * @param siteBaseUrl - The absolute base URL the site is served from (with a trailing slash).\n * @returns Every broken internal link, in page-then-document order.\n */\nexport function collectBrokenLinks(pages: DocumentationPage[], fileSystem: LinkCheckFileSystem, siteBaseUrl: string): BrokenLink[] {\n  const brokenLinks: BrokenLink[] = [];\n\n  for (const page of pages) {\n    const pageUrl = getPageUrl(page.relativePath, siteBaseUrl);\n    for (const rawLink of extractLinks(page.html)) {\n      const targetUrl = new URL(rawLink, pageUrl);\n      if (!isInternalDocUrl(targetUrl, siteBaseUrl)) {\n        continue;\n      }\n\n      const pageKey = fileSystem.resolveExistingPage(getOutputRelativePath(targetUrl, siteBaseUrl));\n      if (pageKey === null) {\n        brokenLinks.push({ pageUrl, reason: 'missing-page', targetUrl: targetUrl.href });\n        continue;\n      }\n\n      const fragment = targetUrl.hash.slice(1);\n      if (fragment.length > 0 && !fileSystem.readIds(pageKey).has(fragment)) {\n        brokenLinks.push({ pageUrl, reason: 'missing-fragment', targetUrl: targetUrl.href });\n      }\n    }\n  }\n\n  return brokenLinks;\n}\n\n/**\n * Collects every unique external URL referenced across the built pages, deduplicated.\n *\n * Only HTTP(S) links that are not {@link isInternalDocUrl} are returned. Each unique URL maps to\n * the first page that referenced it, so a later failure can be reported with a concrete example\n * page even though the URL is fetched only once.\n *\n * @param pages - The built documentation pages to scan.\n * @param siteBaseUrl - The absolute base URL the site is served from (with a trailing slash).\n * @returns A map from each unique external URL to one referencing page URL.\n */\nexport function collectExternalTargets(pages: DocumentationPage[], siteBaseUrl: string): Map<string, string> {\n  const targets = new Map<string, string>();\n\n  for (const page of pages) {\n    const pageUrl = getPageUrl(page.relativePath, siteBaseUrl);\n    for (const rawLink of extractLinks(page.html)) {\n      const targetUrl = new URL(rawLink, pageUrl);\n      if ((targetUrl.protocol !== 'http:' && targetUrl.protocol !== 'https:') || isInternalDocUrl(targetUrl, siteBaseUrl)) {\n        continue;\n      }\n\n      const externalUrl = `${targetUrl.origin}${targetUrl.pathname}${targetUrl.search}`;\n      if (!targets.has(externalUrl)) {\n        targets.set(externalUrl, pageUrl);\n      }\n    }\n  }\n\n  return targets;\n}\n\n/**\n * Extracts the values of every `id` attribute in a chunk of HTML.\n *\n * @param html - The HTML to scan.\n * @returns The set of element ids.\n */\nexport function extractIds(html: string): Set<string> {\n  return new Set([...html.matchAll(ID_ATTRIBUTE_REGEX)].map((match) => getMandatoryNamedGroup(match, 'value')));\n}\n\n/**\n * Extracts the values of every `href`/`src` attribute in a chunk of HTML.\n *\n * @param html - The HTML to scan.\n * @returns The raw link values, in document order (duplicates preserved).\n */\nexport function extractLinks(html: string): string[] {\n  return [...html.matchAll(LINK_ATTRIBUTE_REGEX)].map((match) => getMandatoryNamedGroup(match, 'value'));\n}\n\n/**\n * Formats broken links into a human-readable multi-line report.\n *\n * @param brokenLinks - The broken links to describe.\n * @returns One line per broken link.\n */\nexport function formatBrokenLinks(brokenLinks: BrokenLink[]): string {\n  return brokenLinks\n    .map((brokenLink) => {\n      switch (brokenLink.reason) {\n        case 'external-error': {\n          return `${brokenLink.pageUrl} links to external URL ${brokenLink.targetUrl} that returned ${describeHttpStatus(brokenLink.httpStatus)}.`;\n        }\n        case 'missing-fragment': {\n          return `${brokenLink.pageUrl} links to missing fragment ${brokenLink.targetUrl}.`;\n        }\n        case 'missing-page': {\n          return `${brokenLink.pageUrl} links to missing page ${brokenLink.targetUrl}.`;\n        }\n        default: {\n          return assertNever(brokenLink.reason);\n        }\n      }\n    })\n    .join('\\n');\n}\n\n/**\n * Computes the build-output-relative path for an internal documentation URL.\n *\n * @param targetUrl - The resolved absolute link URL (must be {@link isInternalDocUrl}).\n * @param siteBaseUrl - The absolute base URL the site is served from (with a trailing slash).\n * @returns The decoded path relative to the build-output root.\n */\nexport function getOutputRelativePath(targetUrl: URL, siteBaseUrl: string): string {\n  const base = new URL(siteBaseUrl);\n  return decodeURIComponent(targetUrl.pathname.slice(base.pathname.length));\n}\n\n/**\n * Computes the absolute URL a built page is served at.\n *\n * @param relativePath - The page's path relative to the build-output root.\n * @param siteBaseUrl - The absolute base URL the site is served from (with a trailing slash).\n * @returns The page's absolute URL.\n */\nexport function getPageUrl(relativePath: string, siteBaseUrl: string): string {\n  const normalized = relativePath.replaceAll('\\\\', '/');\n  const urlPath = normalized === 'index.html' ? '' : normalized.replace(/index\\.html$/u, '');\n  return new URL(urlPath, siteBaseUrl).href;\n}\n\n/**\n * Determines whether a resolved link points at a page hosted by this documentation site.\n *\n * @param targetUrl - The resolved absolute link URL.\n * @param siteBaseUrl - The absolute base URL the site is served from (with a trailing slash).\n * @returns `true` when the link is same-origin and under the site base path.\n */\nexport function isInternalDocUrl(targetUrl: URL, siteBaseUrl: string): boolean {\n  const base = new URL(siteBaseUrl);\n  return targetUrl.origin === base.origin && targetUrl.pathname.startsWith(base.pathname);\n}\n\n/**\n * Resolves an output-relative path to an absolute path inside the build-output root, rejecting\n * paths that escape it via `..` segments.\n *\n * @param outputRootPath - The absolute build-output root path.\n * @param outputRelativePath - The decoded output-relative path.\n * @returns The joined path when it stays within the root, otherwise `null`.\n */\nexport function resolveWithinRoot(outputRootPath: string, outputRelativePath: string): null | string {\n  const root = normalize(outputRootPath.replaceAll('\\\\', '/')).replace(/\\/$/u, '');\n  let joined = normalize(`${root}/${outputRelativePath.replaceAll('\\\\', '/')}`);\n  if (joined.length > 1) {\n    joined = joined.replace(/\\/$/u, '');\n  }\n\n  return joined !== root && !joined.startsWith(`${root}/`) ? null : joined;\n}\n\nfunction describeHttpStatus(httpStatus: number | undefined): string {\n  return httpStatus === undefined || httpStatus === NETWORK_FAILURE_STATUS ? 'a network failure' : `HTTP ${String(httpStatus)}`;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAcA,SAAS,8BAA8B;AACvC;AAAA,EACE;AAAA,EACA;AAAA,OACK;AACP,SAAS,iBAAiB;AAE1B,MAAM,uBAAuB;AAC7B,MAAM,qBAAqB;AAC3B,MAAM,iBAAiB;AAMhB,MAAM,yBAAyB;AA0EtC,eAAsB,2BACpB,SACA,gBACA,aACuB;AACvB,QAAM,UAAU,CAAC,GAAG,OAAO;AAC3B,QAAM,UAAiC,MAAM,KAAK,EAAE,QAAQ,QAAQ,OAAO,GAAG,MAAM,IAAI;AACxF,MAAI,YAAY;AAEhB,iBAAe,YAA2B;AACxC,aAAS,QAAQ,aAAa,QAAQ,QAAQ,QAAQ,QAAQ,aAAa;AACzE,YAAM,CAAC,aAAa,OAAO,IAAI,kBAAkB,QAAQ,KAAK,CAAC;AAC/D,YAAM,aAAa,MAAM,eAAe,WAAW;AACnD,UAAI,eAAe,gBAAgB;AACjC,gBAAQ,KAAK,IAAI,EAAE,YAAY,SAAS,QAAQ,kBAAkB,WAAW,YAAY;AAAA,MAC3F;AAAA,IACF;AAAA,EACF;AAEA,QAAM,cAAc,KAAK,IAAI,GAAG,KAAK,IAAI,aAAa,QAAQ,MAAM,CAAC;AACrE,QAAM,QAAQ,IAAI,MAAM,KAAK,EAAE,QAAQ,YAAY,GAAG,MAAM,UAAU,CAAC,CAAC;AAGxE,SAAO,QAAQ,OAAO,CAAC,eAAyC,eAAe,IAAI;AACrF;AAaO,SAAS,mBAAmB,OAA4B,YAAiC,aAAmC;AACjI,QAAM,cAA4B,CAAC;AAEnC,aAAW,QAAQ,OAAO;AACxB,UAAM,UAAU,WAAW,KAAK,cAAc,WAAW;AACzD,eAAW,WAAW,aAAa,KAAK,IAAI,GAAG;AAC7C,YAAM,YAAY,IAAI,IAAI,SAAS,OAAO;AAC1C,UAAI,CAAC,iBAAiB,WAAW,WAAW,GAAG;AAC7C;AAAA,MACF;AAEA,YAAM,UAAU,WAAW,oBAAoB,sBAAsB,WAAW,WAAW,CAAC;AAC5F,UAAI,YAAY,MAAM;AACpB,oBAAY,KAAK,EAAE,SAAS,QAAQ,gBAAgB,WAAW,UAAU,KAAK,CAAC;AAC/E;AAAA,MACF;AAEA,YAAM,WAAW,UAAU,KAAK,MAAM,CAAC;AACvC,UAAI,SAAS,SAAS,KAAK,CAAC,WAAW,QAAQ,OAAO,EAAE,IAAI,QAAQ,GAAG;AACrE,oBAAY,KAAK,EAAE,SAAS,QAAQ,oBAAoB,WAAW,UAAU,KAAK,CAAC;AAAA,MACrF;AAAA,IACF;AAAA,EACF;AAEA,SAAO;AACT;AAaO,SAAS,uBAAuB,OAA4B,aAA0C;AAC3G,QAAM,UAAU,oBAAI,IAAoB;AAExC,aAAW,QAAQ,OAAO;AACxB,UAAM,UAAU,WAAW,KAAK,cAAc,WAAW;AACzD,eAAW,WAAW,aAAa,KAAK,IAAI,GAAG;AAC7C,YAAM,YAAY,IAAI,IAAI,SAAS,OAAO;AAC1C,UAAK,UAAU,aAAa,WAAW,UAAU,aAAa,YAAa,iBAAiB,WAAW,WAAW,GAAG;AACnH;AAAA,MACF;AAEA,YAAM,cAAc,GAAG,UAAU,MAAM,GAAG,UAAU,QAAQ,GAAG,UAAU,MAAM;AAC/E,UAAI,CAAC,QAAQ,IAAI,WAAW,GAAG;AAC7B,gBAAQ,IAAI,aAAa,OAAO;AAAA,MAClC;AAAA,IACF;AAAA,EACF;AAEA,SAAO;AACT;AAQO,SAAS,WAAW,MAA2B;AACpD,SAAO,IAAI,IAAI,CAAC,GAAG,KAAK,SAAS,kBAAkB,CAAC,EAAE,IAAI,CAAC,UAAU,uBAAuB,OAAO,OAAO,CAAC,CAAC;AAC9G;AAQO,SAAS,aAAa,MAAwB;AACnD,SAAO,CAAC,GAAG,KAAK,SAAS,oBAAoB,CAAC,EAAE,IAAI,CAAC,UAAU,uBAAuB,OAAO,OAAO,CAAC;AACvG;AAQO,SAAS,kBAAkB,aAAmC;AACnE,SAAO,YACJ,IAAI,CAAC,eAAe;AACnB,YAAQ,WAAW,QAAQ;AAAA,MACzB,KAAK,kBAAkB;AACrB,eAAO,GAAG,WAAW,OAAO,0BAA0B,WAAW,SAAS,kBAAkB,mBAAmB,WAAW,UAAU,CAAC;AAAA,MACvI;AAAA,MACA,KAAK,oBAAoB;AACvB,eAAO,GAAG,WAAW,OAAO,8BAA8B,WAAW,SAAS;AAAA,MAChF;AAAA,MACA,KAAK,gBAAgB;AACnB,eAAO,GAAG,WAAW,OAAO,0BAA0B,WAAW,SAAS;AAAA,MAC5E;AAAA,MACA,SAAS;AACP,eAAO,YAAY,WAAW,MAAM;AAAA,MACtC;AAAA,IACF;AAAA,EACF,CAAC,EACA,KAAK,IAAI;AACd;AASO,SAAS,sBAAsB,WAAgB,aAA6B;AACjF,QAAM,OAAO,IAAI,IAAI,WAAW;AAChC,SAAO,mBAAmB,UAAU,SAAS,MAAM,KAAK,SAAS,MAAM,CAAC;AAC1E;AASO,SAAS,WAAW,cAAsB,aAA6B;AAC5E,QAAM,aAAa,aAAa,WAAW,MAAM,GAAG;AACpD,QAAM,UAAU,eAAe,eAAe,KAAK,WAAW,QAAQ,iBAAiB,EAAE;AACzF,SAAO,IAAI,IAAI,SAAS,WAAW,EAAE;AACvC;AASO,SAAS,iBAAiB,WAAgB,aAA8B;AAC7E,QAAM,OAAO,IAAI,IAAI,WAAW;AAChC,SAAO,UAAU,WAAW,KAAK,UAAU,UAAU,SAAS,WAAW,KAAK,QAAQ;AACxF;AAUO,SAAS,kBAAkB,gBAAwB,oBAA2C;AACnG,QAAM,OAAO,UAAU,eAAe,WAAW,MAAM,GAAG,CAAC,EAAE,QAAQ,QAAQ,EAAE;AAC/E,MAAI,SAAS,UAAU,GAAG,IAAI,IAAI,mBAAmB,WAAW,MAAM,GAAG,CAAC,EAAE;AAC5E,MAAI,OAAO,SAAS,GAAG;AACrB,aAAS,OAAO,QAAQ,QAAQ,EAAE;AAAA,EACpC;AAEA,SAAO,WAAW,QAAQ,CAAC,OAAO,WAAW,GAAG,IAAI,GAAG,IAAI,OAAO;AACpE;AAEA,SAAS,mBAAmB,YAAwC;AAClE,SAAO,eAAe,UAAa,eAAe,yBAAyB,sBAAsB,QAAQ,OAAO,UAAU,CAAC;AAC7H;","names":[]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../../../src/docs-site/link-check.ts"],"sourcesContent":["/**\n * @file\n *\n * Validation of the links emitted by the built documentation HTML.\n *\n * Internal (same-site) links are validated offline: every `href`/`src` must resolve to a real\n * file in the build output, and every `#fragment` must resolve to a real element id on the\n * target page.\n *\n * External links can only be validated over the network, so those requests are heavily\n * deduplicated — each unique external URL is fetched at most once regardless of how many of the\n * thousands of generated pages reference it — and run through a bounded concurrency pool.\n */\n\nimport { getMandatoryNamedGroup } from '@mnaoumov/typescript-lib/reg-exp';\nimport {\n  assertNever,\n  ensureNonNullable\n} from '@mnaoumov/typescript-lib/type-guards';\nimport { normalize } from 'node:path/posix';\n\nconst LINK_ATTRIBUTE_REGEX = /\\b(?:href|src)=(?<quote>['\"])(?<value>.*?)\\k<quote>/giu;\nconst ID_ATTRIBUTE_REGEX = /\\bid=(?<quote>['\"])(?<value>.*?)\\k<quote>/giu;\nconst HTTP_OK_STATUS = 200;\n\n/**\n * The {@link BrokenLink.httpStatus} sentinel for a network-level failure (timeout, DNS,\n * connection refused) where no HTTP response was received.\n */\nexport const NETWORK_FAILURE_STATUS = 0;\n\n/**\n * A single link that does not resolve.\n */\nexport interface BrokenLink {\n  /**\n   * The HTTP status returned by an external link, when {@link BrokenLink.reason} is\n   * `external-error`. `0` denotes a network-level failure (timeout, DNS, connection refused).\n   */\n  httpStatus?: number;\n\n  /**\n   * The absolute URL of the page that contains the broken link.\n   */\n  pageUrl: string;\n\n  /**\n   * Why the link is considered broken.\n   */\n  reason: 'external-error' | 'missing-fragment' | 'missing-page';\n\n  /**\n   * The resolved absolute URL the link points at.\n   */\n  targetUrl: string;\n}\n\n/**\n * Options for {@link collectBrokenExternalLinks}.\n */\nexport interface CollectBrokenExternalLinksOptions {\n  /**\n   * The maximum number of in-flight probes against one host. Defaults to {@link DEFAULT_EXTERNAL_LINK_PER_HOST_CONCURRENCY}.\n   */\n  readonly perHostConcurrency?: number;\n\n  /**\n   * How a transient failure is retried.\n   */\n  readonly retry?: ExternalLinkRetryOptions;\n}\n\n/**\n * A single built documentation page to validate.\n */\nexport interface DocumentationPage {\n  /**\n   * The page's rendered HTML.\n   */\n  html: string;\n\n  /**\n   * The page's path relative to the build-output root, e.g. `api/foo/index.html`.\n   */\n  relativePath: string;\n}\n\n/**\n * What one probe of an external URL learned.\n */\nexport interface ExternalLinkProbeResult {\n  /**\n   * How long the server asked the client to wait before asking again (its `Retry-After` header), when it said.\n   */\n  readonly retryAfterInMilliseconds?: number | undefined;\n\n  /**\n   * The HTTP status, or {@link NETWORK_FAILURE_STATUS} when no response was received.\n   */\n  readonly status: number;\n}\n\n/**\n * How {@link collectBrokenExternalLinks} retries a transient failure: a network failure, an HTTP `429` or an HTTP `5xx`.\n *\n * Each wait doubles from {@link ExternalLinkRetryOptions.initialDelayInMilliseconds} up to\n * {@link ExternalLinkRetryOptions.maxDelayInMilliseconds}, is jittered into its upper half, and is never shorter than the\n * server's `Retry-After`. The waits of one URL never add up to more than\n * {@link ExternalLinkRetryOptions.totalBudgetInMilliseconds}; the status of the last attempt is final.\n */\nexport interface ExternalLinkRetryOptions {\n  /**\n   * The first wait. Defaults to {@link DEFAULT_EXTERNAL_LINK_RETRY_INITIAL_DELAY_IN_MILLISECONDS}.\n   */\n  readonly initialDelayInMilliseconds?: number;\n\n  /**\n   * The longest single wait the backoff grows to. Defaults to {@link DEFAULT_EXTERNAL_LINK_RETRY_MAX_DELAY_IN_MILLISECONDS}.\n   */\n  readonly maxDelayInMilliseconds?: number;\n\n  /**\n   * Returns a number in `[0, 1)` for the jitter. Defaults to `Math.random`.\n   */\n  readonly random?: () => number;\n\n  /**\n   * Waits the given time. Defaults to a `setTimeout`.\n   */\n  readonly sleep?: (milliseconds: number) => Promise<void>;\n\n  /**\n   * The most one URL may spend waiting between its attempts. Defaults to\n   * {@link DEFAULT_EXTERNAL_LINK_RETRY_TOTAL_BUDGET_IN_MILLISECONDS}.\n   */\n  readonly totalBudgetInMilliseconds?: number;\n}\n\n/**\n * Filesystem access the link checker needs, injected so the pure decision logic can be tested\n * against an in-memory stub instead of a real build output.\n */\nexport interface LinkCheckFileSystem {\n  /**\n   * Reads the element ids present on an already-resolved page.\n   *\n   * @param pageKey - The key returned by {@link LinkCheckFileSystem.resolveExistingPage}.\n   * @returns The set of element ids on that page.\n   */\n  readIds: (pageKey: string) => Set<string>;\n\n  /**\n   * Resolves an output-relative path to an existing page.\n   *\n   * @param outputRelativePath - The decoded path relative to the build-output root.\n   * @returns A stable key (e.g. the resolved absolute file path) for the existing page, or\n   *   `null` when nothing exists at that path or the path escapes the build-output root.\n   */\n  resolveExistingPage: (outputRelativePath: string) => null | string;\n}\n\n/**\n * The default {@link CollectBrokenExternalLinksOptions.perHostConcurrency}. A documentation site links thousands of\n * pages of its sibling sites, all on one host, and GitHub Pages answers a burst of them with a `503`.\n */\nexport const DEFAULT_EXTERNAL_LINK_PER_HOST_CONCURRENCY = 8;\n\n/**\n * The default {@link ExternalLinkRetryOptions.initialDelayInMilliseconds}.\n */\nexport const DEFAULT_EXTERNAL_LINK_RETRY_INITIAL_DELAY_IN_MILLISECONDS = 1000;\n\n/**\n * The default {@link ExternalLinkRetryOptions.maxDelayInMilliseconds}.\n */\nexport const DEFAULT_EXTERNAL_LINK_RETRY_MAX_DELAY_IN_MILLISECONDS = 16_000;\n\n/**\n * The default {@link ExternalLinkRetryOptions.totalBudgetInMilliseconds}.\n */\nexport const DEFAULT_EXTERNAL_LINK_RETRY_TOTAL_BUDGET_IN_MILLISECONDS = 45_000;\n\nconst HTTP_TOO_MANY_REQUESTS_STATUS = 429;\nconst HTTP_SERVER_ERROR_MIN_STATUS = 500;\nconst MILLISECONDS_PER_SECOND = 1000;\nconst JITTER_FLOOR = 0.5;\nconst BACKOFF_FACTOR = 2;\n\ninterface PendingProbe {\n  readonly host: string;\n  readonly index: number;\n  readonly pageUrl: string;\n  readonly url: string;\n}\n\n/**\n * Validates the deduplicated external URLs over the network through a bounded concurrency pool.\n *\n * A network failure, an HTTP `429` and an HTTP `5xx` are retried with an exponential, jittered backoff that honors\n * `Retry-After` (see {@link ExternalLinkRetryOptions}); any other status, a `404` included, is final at once. Probes of\n * one host are also capped at {@link CollectBrokenExternalLinksOptions.perHostConcurrency}, and a probe of another host\n * is started while one host is at its cap.\n *\n * @param targets - The unique external URL → referencing page map from {@link collectExternalTargets}.\n * @param fetchUrlStatus - Injected probe returning the HTTP status for a URL (`0` for a network failure), or an\n *   {@link ExternalLinkProbeResult} that also carries the server's `Retry-After`.\n * @param concurrency - The maximum number of in-flight probes.\n * @param options - The per-host cap and the retry policy.\n * @returns Every external URL that did not return HTTP `200`, in the map's iteration order.\n */\nexport async function collectBrokenExternalLinks(\n  targets: Map<string, string>,\n  fetchUrlStatus: (url: string) => Promise<ExternalLinkProbeResult | number>,\n  concurrency: number,\n  options: CollectBrokenExternalLinksOptions = {}\n): Promise<BrokenLink[]> {\n  const perHostConcurrency = Math.max(1, options.perHostConcurrency ?? DEFAULT_EXTERNAL_LINK_PER_HOST_CONCURRENCY);\n  const pending: PendingProbe[] = [...targets].map(([url, pageUrl], index) => ({ host: new URL(url).host, index, pageUrl, url }));\n  const results: (BrokenLink | null)[] = Array.from({ length: pending.length }, () => null);\n  const inFlightByHost = new Map<string, number>();\n  const waiters: (() => void)[] = [];\n\n  async function runWorker(): Promise<void> {\n    while (pending.length > 0) {\n      const position = pending.findIndex((probe) => (inFlightByHost.get(probe.host) ?? 0) < perHostConcurrency);\n      if (position === -1) {\n        // Every pending URL is on a host at its cap, so a probe is in flight there and wakes this worker when it ends.\n        await new Promise<void>((resolvePromise) => {\n          waiters.push(resolvePromise);\n        });\n        continue;\n      }\n\n      const [probe] = pending.splice(position, 1);\n      const { host, index, pageUrl, url } = ensureNonNullable(probe);\n      inFlightByHost.set(host, (inFlightByHost.get(host) ?? 0) + 1);\n      try {\n        const httpStatus = await probeWithRetry(url, fetchUrlStatus, options.retry ?? {});\n        if (httpStatus !== HTTP_OK_STATUS) {\n          results[index] = { httpStatus, pageUrl, reason: 'external-error', targetUrl: url };\n        }\n      } finally {\n        inFlightByHost.set(host, ensureNonNullable(inFlightByHost.get(host)) - 1);\n        for (const wake of waiters.splice(0)) {\n          wake();\n        }\n      }\n    }\n  }\n\n  const workerCount = Math.max(1, Math.min(concurrency, pending.length));\n  await Promise.all(Array.from({ length: workerCount }, () => runWorker()));\n\n  // Indexed assignment above keeps failures in the map's iteration order; drop the successful gaps.\n  return results.filter((brokenLink): brokenLink is BrokenLink => brokenLink !== null);\n}\n\n/**\n * Finds every internal link across the built documentation pages that does not resolve.\n *\n * External and non-HTTP links are ignored. Each internal link must resolve to an existing page,\n * and each `#fragment` must resolve to an existing element id on the target page.\n *\n * @param pages - The built documentation pages to validate.\n * @param fileSystem - Injected access to the build output.\n * @param siteBaseUrl - The absolute base URL the site is served from (with a trailing slash).\n * @returns Every broken internal link, in page-then-document order.\n */\nexport function collectBrokenLinks(pages: DocumentationPage[], fileSystem: LinkCheckFileSystem, siteBaseUrl: string): BrokenLink[] {\n  const brokenLinks: BrokenLink[] = [];\n\n  for (const page of pages) {\n    const pageUrl = getPageUrl(page.relativePath, siteBaseUrl);\n    for (const rawLink of extractLinks(page.html)) {\n      const targetUrl = new URL(rawLink, pageUrl);\n      if (!isInternalDocUrl(targetUrl, siteBaseUrl)) {\n        continue;\n      }\n\n      const pageKey = fileSystem.resolveExistingPage(getOutputRelativePath(targetUrl, siteBaseUrl));\n      if (pageKey === null) {\n        brokenLinks.push({ pageUrl, reason: 'missing-page', targetUrl: targetUrl.href });\n        continue;\n      }\n\n      const fragment = targetUrl.hash.slice(1);\n      if (fragment.length > 0 && !fileSystem.readIds(pageKey).has(fragment)) {\n        brokenLinks.push({ pageUrl, reason: 'missing-fragment', targetUrl: targetUrl.href });\n      }\n    }\n  }\n\n  return brokenLinks;\n}\n\n/**\n * Collects every unique external URL referenced across the built pages, deduplicated.\n *\n * Only HTTP(S) links that are not {@link isInternalDocUrl} are returned. Each unique URL maps to\n * the first page that referenced it, so a later failure can be reported with a concrete example\n * page even though the URL is fetched only once.\n *\n * @param pages - The built documentation pages to scan.\n * @param siteBaseUrl - The absolute base URL the site is served from (with a trailing slash).\n * @returns A map from each unique external URL to one referencing page URL.\n */\nexport function collectExternalTargets(pages: DocumentationPage[], siteBaseUrl: string): Map<string, string> {\n  const targets = new Map<string, string>();\n\n  for (const page of pages) {\n    const pageUrl = getPageUrl(page.relativePath, siteBaseUrl);\n    for (const rawLink of extractLinks(page.html)) {\n      const targetUrl = new URL(rawLink, pageUrl);\n      if ((targetUrl.protocol !== 'http:' && targetUrl.protocol !== 'https:') || isInternalDocUrl(targetUrl, siteBaseUrl)) {\n        continue;\n      }\n\n      const externalUrl = `${targetUrl.origin}${targetUrl.pathname}${targetUrl.search}`;\n      if (!targets.has(externalUrl)) {\n        targets.set(externalUrl, pageUrl);\n      }\n    }\n  }\n\n  return targets;\n}\n\n/**\n * Extracts the values of every `id` attribute in a chunk of HTML.\n *\n * @param html - The HTML to scan.\n * @returns The set of element ids.\n */\nexport function extractIds(html: string): Set<string> {\n  return new Set([...html.matchAll(ID_ATTRIBUTE_REGEX)].map((match) => getMandatoryNamedGroup(match, 'value')));\n}\n\n/**\n * Extracts the values of every `href`/`src` attribute in a chunk of HTML.\n *\n * @param html - The HTML to scan.\n * @returns The raw link values, in document order (duplicates preserved).\n */\nexport function extractLinks(html: string): string[] {\n  return [...html.matchAll(LINK_ATTRIBUTE_REGEX)].map((match) => getMandatoryNamedGroup(match, 'value'));\n}\n\n/**\n * Formats broken links into a human-readable multi-line report.\n *\n * @param brokenLinks - The broken links to describe.\n * @returns One line per broken link.\n */\nexport function formatBrokenLinks(brokenLinks: BrokenLink[]): string {\n  return brokenLinks\n    .map((brokenLink) => {\n      switch (brokenLink.reason) {\n        case 'external-error': {\n          return `${brokenLink.pageUrl} links to external URL ${brokenLink.targetUrl} that returned ${describeHttpStatus(brokenLink.httpStatus)}.`;\n        }\n        case 'missing-fragment': {\n          return `${brokenLink.pageUrl} links to missing fragment ${brokenLink.targetUrl}.`;\n        }\n        case 'missing-page': {\n          return `${brokenLink.pageUrl} links to missing page ${brokenLink.targetUrl}.`;\n        }\n        default: {\n          return assertNever(brokenLink.reason);\n        }\n      }\n    })\n    .join('\\n');\n}\n\n/**\n * Computes the build-output-relative path for an internal documentation URL.\n *\n * @param targetUrl - The resolved absolute link URL (must be {@link isInternalDocUrl}).\n * @param siteBaseUrl - The absolute base URL the site is served from (with a trailing slash).\n * @returns The decoded path relative to the build-output root.\n */\nexport function getOutputRelativePath(targetUrl: URL, siteBaseUrl: string): string {\n  const base = new URL(siteBaseUrl);\n  return decodeURIComponent(targetUrl.pathname.slice(base.pathname.length));\n}\n\n/**\n * Computes the absolute URL a built page is served at.\n *\n * @param relativePath - The page's path relative to the build-output root.\n * @param siteBaseUrl - The absolute base URL the site is served from (with a trailing slash).\n * @returns The page's absolute URL.\n */\nexport function getPageUrl(relativePath: string, siteBaseUrl: string): string {\n  const normalized = relativePath.replaceAll('\\\\', '/');\n  const urlPath = normalized === 'index.html' ? '' : normalized.replace(/index\\.html$/u, '');\n  return new URL(urlPath, siteBaseUrl).href;\n}\n\n/**\n * Determines whether a resolved link points at a page hosted by this documentation site.\n *\n * @param targetUrl - The resolved absolute link URL.\n * @param siteBaseUrl - The absolute base URL the site is served from (with a trailing slash).\n * @returns `true` when the link is same-origin and under the site base path.\n */\nexport function isInternalDocUrl(targetUrl: URL, siteBaseUrl: string): boolean {\n  const base = new URL(siteBaseUrl);\n  return targetUrl.origin === base.origin && targetUrl.pathname.startsWith(base.pathname);\n}\n\n/**\n * Reads an HTTP `Retry-After` header, which is either a number of seconds or an HTTP date.\n *\n * @param headerValue - The header's value, or `null` when the response has none.\n * @param nowInMilliseconds - The current time, against which a date is measured.\n * @returns How long to wait, never negative, or `undefined` when the header is absent or unreadable.\n */\nexport function parseRetryAfterInMilliseconds(headerValue: null | string, nowInMilliseconds: number): number | undefined {\n  const trimmed = headerValue?.trim() ?? '';\n  if (trimmed === '') {\n    return undefined;\n  }\n\n  if (/^\\d+$/u.test(trimmed)) {\n    return Number(trimmed) * MILLISECONDS_PER_SECOND;\n  }\n\n  const dateInMilliseconds = Date.parse(trimmed);\n  return Number.isNaN(dateInMilliseconds) ? undefined : Math.max(0, dateInMilliseconds - nowInMilliseconds);\n}\n\n/**\n * Resolves an output-relative path to an absolute path inside the build-output root, rejecting\n * paths that escape it via `..` segments.\n *\n * @param outputRootPath - The absolute build-output root path.\n * @param outputRelativePath - The decoded output-relative path.\n * @returns The joined path when it stays within the root, otherwise `null`.\n */\nexport function resolveWithinRoot(outputRootPath: string, outputRelativePath: string): null | string {\n  const root = normalize(outputRootPath.replaceAll('\\\\', '/')).replace(/\\/$/u, '');\n  let joined = normalize(`${root}/${outputRelativePath.replaceAll('\\\\', '/')}`);\n  if (joined.length > 1) {\n    joined = joined.replace(/\\/$/u, '');\n  }\n\n  return joined !== root && !joined.startsWith(`${root}/`) ? null : joined;\n}\n\nfunction describeHttpStatus(httpStatus: number | undefined): string {\n  return httpStatus === undefined || httpStatus === NETWORK_FAILURE_STATUS ? 'a network failure' : `HTTP ${String(httpStatus)}`;\n}\n\nfunction isTransientStatus(status: number): boolean {\n  return status === NETWORK_FAILURE_STATUS || status === HTTP_TOO_MANY_REQUESTS_STATUS || status >= HTTP_SERVER_ERROR_MIN_STATUS;\n}\n\n/*\n * A site linking its sibling sites probes thousands of URLs on one host, and in CI GitHub Pages answers a few of them\n * with a 503, or drops the connection, while the page serves 200 a moment later. Three attempts a second apart gave up\n * too soon for that (2026-10-16), so the wait grows until the budget is spent.\n */\nasync function probeWithRetry(\n  url: string,\n  fetchUrlStatus: (url: string) => Promise<ExternalLinkProbeResult | number>,\n  retry: ExternalLinkRetryOptions\n): Promise<number> {\n  const initialDelayInMilliseconds = retry.initialDelayInMilliseconds ?? DEFAULT_EXTERNAL_LINK_RETRY_INITIAL_DELAY_IN_MILLISECONDS;\n  const maxDelayInMilliseconds = retry.maxDelayInMilliseconds ?? DEFAULT_EXTERNAL_LINK_RETRY_MAX_DELAY_IN_MILLISECONDS;\n  const totalBudgetInMilliseconds = retry.totalBudgetInMilliseconds ?? DEFAULT_EXTERNAL_LINK_RETRY_TOTAL_BUDGET_IN_MILLISECONDS;\n  const random = retry.random ?? Math.random;\n  const sleep = retry.sleep ?? sleepWithTimeout;\n\n  let waitedInMilliseconds = 0;\n  for (let attempt = 0;; attempt++) {\n    const probeResult = await fetchUrlStatus(url);\n    const { retryAfterInMilliseconds, status } = typeof probeResult === 'number' ? { retryAfterInMilliseconds: undefined, status: probeResult } : probeResult;\n    const remainingInMilliseconds = totalBudgetInMilliseconds - waitedInMilliseconds;\n    if (!isTransientStatus(status) || remainingInMilliseconds <= 0) {\n      return status;\n    }\n\n    const backoffInMilliseconds = Math.min(maxDelayInMilliseconds, initialDelayInMilliseconds * BACKOFF_FACTOR ** attempt);\n    const jitteredInMilliseconds = backoffInMilliseconds * (JITTER_FLOOR + (1 - JITTER_FLOOR) * random());\n    const delayInMilliseconds = Math.min(remainingInMilliseconds, Math.max(jitteredInMilliseconds, retryAfterInMilliseconds ?? 0));\n    await sleep(delayInMilliseconds);\n    waitedInMilliseconds += delayInMilliseconds;\n  }\n}\n\nfunction sleepWithTimeout(milliseconds: number): Promise<void> {\n  return new Promise((resolvePromise) => {\n    globalThis.setTimeout(resolvePromise, milliseconds);\n  });\n}\n"],"mappings":"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","names":["probe"]}

package/dist/lib/esm/docs-site/repo-homepage.d.mts

@@ -0,0 +1,50 @@
+/// <reference path="../library-references.d.mts" />
+/**
+ * @file
+ *
+ * Keeps a repository's GitHub homepage pointing at its documentation site.
+ *
+ * The URL is the site's own (`site` + `base` of its Astro configuration), so nothing here knows which origin or
+ * account a site belongs to. It reads and writes through the `gh` CLI with whatever credentials it already has.
+ *
+ * A workflow's `GITHUB_TOKEN` cannot change a repository's settings, so in CI a mismatch is reported, never fixed:
+ * the report prints the `gh repo edit` line that fixes it. Nothing here ever fails a build.
+ */
+/**
+ * What a site build does about its repository's GitHub homepage.
+ *
+ * - `off`: nothing.
+ * - `check`: report a homepage that is not the site's URL, with the command that sets it.
+ * - `set`: set a homepage that is not the site's URL, and report it when the credentials cannot.
+ */
+export type RepoHomepageMode = 'check' | 'off' | 'set';
+/**
+ * Params for {@link syncRepoHomepage}.
+ */
+export interface SyncRepoHomepageParams {
+    /**
+     * The URL the homepage should be: the site's base URL.
+     */
+    readonly homepageUrl: string;
+    /**
+     * Whether to set a mismatched homepage or only report it.
+     */
+    readonly mode: Exclude<RepoHomepageMode, 'off'>;
+    /**
+     * The GitHub account the repository belongs to.
+     */
+    readonly owner: string;
+    /**
+     * The repository's name.
+     */
+    readonly repo: string;
+}
+/**
+ * Compares a repository's GitHub homepage with its site's URL, and sets it or reports the mismatch.
+ *
+ * It only warns: an unreadable repository, a mismatch it may not fix and a failed update each print the reason and
+ * the `gh repo edit` line, and inside GitHub Actions also a `::warning::` annotation.
+ *
+ * @param params - The repository, the site's URL and the mode.
+ */
+export declare function syncRepoHomepage(params: SyncRepoHomepageParams): Promise<void>;

package/dist/lib/esm/docs-site/repo-homepage.mjs

@@ -0,0 +1,84 @@
+/*
+THIS IS A GENERATED/BUNDLED FILE BY ESBUILD
+if you want to view the source, please visit the github repository of this plugin
+*/
+(function () {
+function ensureBrowserProcess() {
+  const browserProcess = {
+    browser: true,
+    cwd() {
+      return '/';
+    },
+    env: {},
+    platform: 'android'
+  };
+
+  const existingProcess = globalThis.process;
+
+  if (!existingProcess) {
+    globalThis.process = browserProcess;
+    return;
+  }
+
+  if (existingProcess.versions?.node) {
+    return;
+  }
+
+  const existingProcessRecord = existingProcess;
+
+  for (const [key, value] of Object.entries(browserProcess)) {
+    existingProcessRecord[key] ??= value;
+  }
+
+  existingProcessRecord['browser'] = true;
+}
+
+ensureBrowserProcess();
+})();
+
+import { execFromRoot } from "../root.mjs";
+async function syncRepoHomepage(params) {
+  const { homepageUrl, mode, owner, repo } = params;
+  const repoSlug = `${owner}/${repo}`;
+  const fixCommand = `gh repo edit ${repoSlug} --homepage ${homepageUrl}`;
+  let currentHomepage;
+  try {
+    const output = await execFromRoot(["gh", "api", `repos/${repoSlug}`, "--jq", '.homepage // ""'], { isQuiet: true });
+    currentHomepage = output.trim();
+  } catch (error) {
+    warn(`Could not read the GitHub homepage of ${repoSlug} (${describeError(error)}). To set it: ${fixCommand}`);
+    return;
+  }
+  if (currentHomepage === homepageUrl) {
+    return;
+  }
+  const shownHomepage = currentHomepage === "" ? "empty" : `'${currentHomepage}'`;
+  if (mode === "check") {
+    warn(`The GitHub homepage of ${repoSlug} is ${shownHomepage}, not the site ${homepageUrl}. To set it: ${fixCommand}`);
+    return;
+  }
+  try {
+    await execFromRoot(["gh", "api", "--method", "PATCH", `repos/${repoSlug}`, "-f", `homepage=${homepageUrl}`], { isQuiet: true });
+  } catch (error) {
+    warn(
+      `The GitHub homepage of ${repoSlug} is ${shownHomepage}, not the site ${homepageUrl}, and setting it failed: ${describeError(error)}. A workflow token cannot change repository settings; with an account that can: ${fixCommand}`
+    );
+    return;
+  }
+  console.warn(`Set the GitHub homepage of ${repoSlug} to ${homepageUrl} (was ${shownHomepage}).`);
+}
+function describeError(error) {
+  const message = error instanceof Error ? error.message : String(error);
+  const newlineIndex = message.indexOf("\n");
+  return newlineIndex === -1 ? message : message.slice(0, newlineIndex);
+}
+function warn(message) {
+  console.warn(message);
+  if (process.env["GITHUB_ACTIONS"] === "true") {
+    console.warn(`::warning title=Repository homepage::${message}`);
+  }
+}
+export {
+  syncRepoHomepage
+};
+//# sourceMappingURL=data:application/json;base64,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

package/dist/lib/esm/formatters/auto.d.mts

@@ -0,0 +1,51 @@
+/// <reference path="../library-references.d.mts" />
+/**
+ * @file
+ *
+ * Formats the source code with whichever formatter the project configures: dprint, Prettier or Biome.
+ */
+/**
+ * A formatter the toolkit runs.
+ */
+export type Formatter = 'biome' | 'dprint' | 'prettier';
+/**
+ * Parameters for the {@link format} function.
+ */
+export interface FormatOptions {
+    /**
+     * The configuration file used when the project has none of its own, as the chosen formatter's own `format` takes
+     * it.
+     */
+    readonly defaultConfigFilePath?: string | undefined;
+    /**
+     * The formatter to run. Omitted, {@link detectFormatter} chooses it.
+     */
+    readonly formatter?: Formatter | undefined;
+    /**
+     * Optional file paths to format. If omitted, formats the entire project.
+     */
+    readonly paths?: string[] | undefined;
+    /**
+     * Whether to rewrite the source code.
+     *
+     * @default `true`
+     */
+    readonly rewrite?: boolean | undefined;
+}
+/**
+ * Chooses the formatter from the configuration files at the project root.
+ *
+ * The order is `dprint.json`, then a Prettier configuration, then `biome.json` / `biome.jsonc`, so a project that
+ * lints with Biome and lays out with Prettier gets Prettier. A project with none of them gets dprint, as before
+ * Prettier and Biome were supported.
+ *
+ * @returns The formatter to run.
+ */
+export declare function detectFormatter(): Promise<Formatter>;
+/**
+ * Formats the source code with the project's formatter.
+ *
+ * @param options - The {@link FormatOptions}.
+ * @returns A {@link Promise} that resolves when the source code has been formatted.
+ */
+export declare function format(options?: FormatOptions): Promise<void>;

package/dist/lib/esm/formatters/auto.mjs

@@ -0,0 +1,40 @@
+/*
+THIS IS A GENERATED/BUNDLED FILE BY ESBUILD
+if you want to view the source, please visit the github repository of this plugin
+*/
+
+import { existsSync } from "node:fs";
+import { RepoPaths } from "../repo-paths.mjs";
+import { resolvePathFromRootSafe } from "../root.mjs";
+import {
+  format as formatWithBiome,
+  hasBiomeConfig
+} from "./biome.mjs";
+import { format as formatWithDprint } from "./dprint.mjs";
+import {
+  format as formatWithPrettier,
+  hasPrettierConfig
+} from "./prettier.mjs";
+const FORMATTERS = {
+  biome: formatWithBiome,
+  dprint: formatWithDprint,
+  prettier: formatWithPrettier
+};
+async function detectFormatter() {
+  if (existsSync(resolvePathFromRootSafe({ path: RepoPaths.DprintJson }))) {
+    return "dprint";
+  }
+  if (await hasPrettierConfig()) {
+    return "prettier";
+  }
+  return hasBiomeConfig() ? "biome" : "dprint";
+}
+async function format(options) {
+  const { formatter = await detectFormatter(), ...formatOptions } = options ?? {};
+  await FORMATTERS[formatter](formatOptions);
+}
+export {
+  detectFormatter,
+  format
+};
+//# sourceMappingURL=data:application/json;base64,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

package/dist/lib/esm/formatters/biome.d.mts

@@ -0,0 +1,69 @@
+/// <reference path="../library-references.d.mts" />
+/**
+ * @file
+ *
+ * Format the source code with Biome.
+ */
+/**
+ * The files Biome reads its configuration from.
+ */
+export declare const BIOME_CONFIG_FILE_NAMES: readonly string[];
+/**
+ * The flags that make Biome skip, rather than fail on, a path it is handed but does not handle: a pre-commit hook
+ * hands every tool explicit file lists, which can name a file Biome does not know or a file the project ignores.
+ */
+export declare const BIOME_EXPLICIT_PATHS_ARGUMENTS: readonly string[];
+/**
+ * Parameters for the {@link ensureBiomeConfig} function.
+ */
+export interface EnsureBiomeConfigOptions {
+    /**
+     * The configuration file copied to the project root when the project has none.
+     */
+    readonly defaultConfigFilePath?: string | undefined;
+}
+/**
+ * Parameters for the {@link format} function.
+ */
+export interface FormatOptions {
+    /**
+     * The configuration file copied to the project root when the project has none. Omitted, a `biome.json` extending
+     * the shared one this package ships (`assets/biome.json`) is written instead.
+     */
+    readonly defaultConfigFilePath?: string | undefined;
+    /**
+     * Optional file paths to format. If omitted, formats the entire project.
+     */
+    readonly paths?: string[] | undefined;
+    /**
+     * Whether to rewrite the source code.
+     *
+     * @default `true`
+     */
+    readonly rewrite?: boolean | undefined;
+}
+/**
+ * Makes sure the project has a Biome configuration of its own.
+ *
+ * Biome resolves a configuration's VCS root and globs against the configuration file's own folder, so a shared
+ * configuration cannot be passed with `--config-path` from inside `node_modules`: it looks for `.gitignore` there.
+ * The project's own `biome.json` extends it instead. When there is none, the default one is copied in, or a
+ * `biome.json` extending the shared configuration is written.
+ *
+ * @param options - The {@link EnsureBiomeConfigOptions}.
+ * @returns A {@link Promise} that resolves when the project has a Biome configuration.
+ */
+export declare function ensureBiomeConfig(options?: EnsureBiomeConfigOptions): Promise<void>;
+/**
+ * Format the source code with Biome.
+ *
+ * @param options - The {@link FormatOptions}.
+ * @returns A {@link Promise} that resolves when the source code has been formatted.
+ */
+export declare function format(options?: FormatOptions): Promise<void>;
+/**
+ * Says whether the project configures Biome itself.
+ *
+ * @returns Whether a `biome.json` or `biome.jsonc` exists at the project root.
+ */
+export declare function hasBiomeConfig(): boolean;