jamdesk 1.1.218 → 1.1.220

package/vendored/app/api/og/route.tsx

@@ -1,7 +1,10 @@
 import { ImageResponse } from '@vercel/og';
 import { NextRequest } from 'next/server';
 import { sanitizeLogoUrl } from '@/lib/sanitize-url';
-import { parseCardOptions, isRenderableImageType } from '@/lib/og-card';
+import {
+  parseCardOptions, dataUriImageType, isDeniedImageType, isLatinText, type CardOptions,
+} from '@/lib/og-card';
+import { log } from '@/lib/logger';
 
 export const runtime = 'edge';
 
@@ -10,6 +13,11 @@ const MAX_DESCRIPTION_LENGTH = 120;
 const LONG_TITLE_THRESHOLD = 40;
 const FONT_STACK =
   'system-ui, -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, sans-serif';
+const CACHE_CONTROL = 'public, s-maxage=86400, stale-while-revalidate=604800';
+// A degraded card is cached briefly so a later renderer fix replaces it within the hour.
+const FALLBACK_CACHE_CONTROL = 'public, s-maxage=3600';
+// Long enough that a crawler can't force the full render plus fallbacks on every hit.
+const ERROR_CACHE_CONTROL = 'public, s-maxage=60';
 
 function truncateText(text: string, maxLength: number): string {
   if (text.length <= maxLength) return text;
@@ -27,10 +35,13 @@ async function fetchDataUri(url: string): Promise<string> {
     // redirect: 'manual' so a sanitized public host can't 302 to an internal one (SSRF).
     const res = await fetch(url, { signal: controller.signal, redirect: 'manual' });
     if (!res.ok) return '';
-    const contentType = res.headers.get('content-type') || 'image/png';
-    // Satori throws on these and the route would answer 200 with an empty body; "no image" is the safe outcome.
-    if (!isRenderableImageType(contentType)) return '';
-    const buf = await res.arrayBuffer();
+    const declared = res.headers.get('content-type') || 'image/png';
+    // Satori throws on these and the route would answer 200 with an empty body; "no image" is
+    // the safe outcome. Decided from the label first, so a denied image is never downloaded.
+    if (isDeniedImageType(declared)) return '';
+    const buf = new Uint8Array(await res.arrayBuffer());
+    const contentType = dataUriImageType(declared, buf);
+    if (!contentType) return '';
     return `data:${contentType};base64,${Buffer.from(buf).toString('base64')}`;
   } catch {
     return ''; // Skip image on fetch failure
@@ -39,157 +50,135 @@ async function fetchDataUri(url: string): Promise<string> {
   }
 }
 
-/**
- * OG Image Generator
- *
- * Generates branded Open Graph images for documentation sites.
- *
- * Query Parameters:
- * - title: Page title (required)
- * - description: Page description (optional)
- * - section: Section/group name (optional, e.g., "Get Started")
- * - siteName: Site name (optional, defaults to "Documentation")
- * - logo: URL to the project's logo (optional)
- * - bg: URL to a custom background image rendered behind the text (optional)
- * - theme: 'light' (default, warm cream) or 'dark'
- * - accent: hex color (3 or 6 digits, '#' optional) for the badge and bottom bar; low-contrast values fall back to a readable color
- * - hideBar: '1' hides the bottom accent bar
- * - hideName: '1' hides the site name (the logo, if any, still renders)
- *
- * Example:
- * /api/og?title=Introduction&section=Get%20Started&siteName=Acme%20Docs&logo=https://...
- */
-export async function GET(request: NextRequest) {
-  const searchParams = request.nextUrl.searchParams;
-
-  const title = searchParams.get('title') || 'Documentation';
-  const description = searchParams.get('description') || '';
-  const section = searchParams.get('section') || '';
-  const siteName = searchParams.get('siteName') || 'Documentation';
-  const card = parseCardOptions(searchParams);
-  // SSRF guard: HTTPS-only, blocks private/loopback/metadata IPs (incl. encoded forms).
-  const logoUrl = sanitizeLogoUrl(searchParams.get('logo') || '');
-  const bgUrl = sanitizeLogoUrl(searchParams.get('bg') || '');
-
-  const [logo, bg] = await Promise.all([
-    logoUrl ? fetchDataUri(logoUrl) : Promise.resolve(''),
-    bgUrl ? fetchDataUri(bgUrl) : Promise.resolve(''),
-  ]);
+interface CardContent {
+  title: string;
+  description: string;
+  section: string;
+  siteName: string;
+  logo: string; // data URI or ''
+  bg: string;   // data URI or ''
+}
 
+function cardElement({ title, description, section, siteName, logo, bg }: CardContent, card: CardOptions) {
+  // title and siteName are only ever empty on the fallback card; a normal request always has both.
+  const showName = card.showSiteName && siteName !== '';
   const titleFontSize = title.length > LONG_TITLE_THRESHOLD ? '52px' : '64px';
 
-  return new ImageResponse(
-    (
+  return (
+    <div
+      style={{
+        position: 'relative',
+        height: '100%',
+        width: '100%',
+        display: 'flex',
+        background: card.palette.background,
+        fontFamily: FONT_STACK,
+      }}
+    >
+      {/* Custom background image, full-bleed behind the text */}
+      {bg && (
+        <img
+          src={bg}
+          alt=""
+          width={1200}
+          height={630}
+          style={{
+            position: 'absolute',
+            top: 0,
+            left: 0,
+            width: '1200px',
+            height: '630px',
+            objectFit: 'cover',
+          }}
+        />
+      )}
+      {/* Content (painted on top of the background) */}
       <div
         style={{
-          position: 'relative',
-          height: '100%',
-          width: '100%',
           display: 'flex',
-          background: card.palette.background,
-          fontFamily: FONT_STACK,
+          flexDirection: 'column',
+          width: '100%',
+          height: '100%',
+          padding: '60px',
         }}
       >
-        {/* Custom background image, full-bleed behind the text */}
-        {bg && (
-          <img
-            src={bg}
-            alt=""
-            width={1200}
-            height={630}
+        {/* Logo and site name. Skipped when both are hidden so its 40px margin doesn't push the title down. */}
+        {(logo || showName) && (
+          <div
             style={{
-              position: 'absolute',
-              top: 0,
-              left: 0,
-              width: '1200px',
-              height: '630px',
-              objectFit: 'cover',
+              display: 'flex',
+              flexDirection: 'column',
+              alignItems: 'flex-start',
+              marginBottom: '40px',
             }}
-          />
-        )}
-        {/* Content (painted on top of the background) */}
-        <div
-          style={{
-            display: 'flex',
-            flexDirection: 'column',
-            width: '100%',
-            height: '100%',
-            padding: '60px',
-          }}
-        >
-          {/* Logo and site name. Skipped when both are hidden so its 40px margin doesn't push the title down. */}
-          {(logo || card.showSiteName) && (
-            <div
-              style={{
-                display: 'flex',
-                flexDirection: 'column',
-                alignItems: 'flex-start',
-                marginBottom: '40px',
-              }}
-            >
-              {logo && (
-                <img
-                  src={logo}
-                  alt=""
-                  width={360}
-                  height={48}
-                  style={{
-                    height: '48px',
-                    maxWidth: '360px',
-                    objectFit: 'contain',
-                    marginBottom: card.showSiteName ? '16px' : 0,
-                    borderRadius: '8px',
-                  }}
-                />
-              )}
-              {card.showSiteName && (
-                <span
-                  style={{
-                    fontSize: '24px',
-                    fontWeight: 600,
-                    color: card.palette.muted,
-                    textTransform: 'uppercase',
-                    letterSpacing: '0.05em',
-                  }}
-                >
-                  {siteName}
-                </span>
-              )}
-            </div>
-          )}
-
-          {/* Section badge */}
-          {section && (
-            <div
-              style={{
-                display: 'flex',
-                marginBottom: '20px',
-              }}
-            >
+          >
+            {logo && (
+              <img
+                src={logo}
+                alt=""
+                width={360}
+                height={48}
+                style={{
+                  height: '48px',
+                  maxWidth: '360px',
+                  objectFit: 'contain',
+                  // contain centers an image narrower than the 360x48 box; pin it to the left edge,
+                  // in line with the site name and title. Logos 7.5:1 or wider fill the box and don't move.
+                  objectPosition: 'left',
+                  marginBottom: showName ? '16px' : 0,
+                  borderRadius: '8px',
+                }}
+              />
+            )}
+            {showName && (
               <span
                 style={{
-                  fontSize: '18px',
-                  fontWeight: 500,
-                  color: card.palette.badgeText,
-                  padding: '8px 16px',
-                  background: card.palette.badgeBg,
-                  borderRadius: '20px',
+                  fontSize: '24px',
+                  fontWeight: 600,
+                  color: card.palette.muted,
+                  textTransform: 'uppercase',
+                  letterSpacing: '0.05em',
                 }}
               >
-                {section}
+                {siteName}
               </span>
-            </div>
-          )}
+            )}
+          </div>
+        )}
 
-          {/* Title and description */}
+        {/* Section badge */}
+        {section && (
           <div
             style={{
               display: 'flex',
-              flex: 1,
-              flexDirection: 'column',
-              justifyContent: 'center',
+              marginBottom: '20px',
             }}
           >
+            <span
+              style={{
+                fontSize: '18px',
+                fontWeight: 500,
+                color: card.palette.badgeText,
+                padding: '8px 16px',
+                background: card.palette.badgeBg,
+                borderRadius: '20px',
+              }}
+            >
+              {section}
+            </span>
+          </div>
+        )}
+
+        {/* Title and description */}
+        <div
+          style={{
+            display: 'flex',
+            flex: 1,
+            flexDirection: 'column',
+            justifyContent: 'center',
+          }}
+        >
+          {title && (
             <h1
               style={{
                 fontSize: titleFontSize,
@@ -202,43 +191,167 @@ export async function GET(request: NextRequest) {
             >
               {title}
             </h1>
+          )}
 
-            {description && (
-              <p
-                style={{
-                  fontSize: '28px',
-                  color: card.palette.muted,
-                  marginTop: '24px',
-                  lineHeight: 1.4,
-                  maxWidth: '800px',
-                }}
-              >
-                {truncateText(description, MAX_DESCRIPTION_LENGTH)}
-              </p>
-            )}
-          </div>
-
-          {/* Bottom accent bar */}
-          {card.showAccentBar && (
-            <div
+          {description && (
+            <p
               style={{
-                display: 'flex',
-                height: '6px',
-                background: card.palette.bar,
-                borderRadius: '3px',
-                marginTop: '40px',
+                fontSize: '28px',
+                color: card.palette.muted,
+                marginTop: '24px',
+                lineHeight: 1.4,
+                maxWidth: '800px',
               }}
-            />
+            >
+              {truncateText(description, MAX_DESCRIPTION_LENGTH)}
+            </p>
           )}
         </div>
+
+        {/* Bottom accent bar */}
+        {card.showAccentBar && (
+          <div
+            style={{
+              display: 'flex',
+              height: '6px',
+              background: card.palette.bar,
+              borderRadius: '3px',
+              marginTop: '40px',
+            }}
+          />
+        )}
       </div>
-    ),
-    {
-      width: 1200,
-      height: 630,
-      headers: {
-        'Cache-Control': 'public, s-maxage=86400, stale-while-revalidate=604800',
-      },
-    }
+    </div>
   );
 }
+
+/**
+ * ImageResponse renders lazily inside the body stream, so a Satori throw surfaces
+ * after the 200 headers have gone out: an empty card the CDN caches for a week.
+ * Reading the body here turns that into an error we can still answer differently.
+ */
+async function renderCard(content: CardContent, card: CardOptions, cacheControl: string): Promise<Response> {
+  const res = new ImageResponse(cardElement(content, card), {
+    width: 1200,
+    height: 630,
+    headers: {
+      'Cache-Control': cacheControl,
+    },
+  });
+  const body = await res.arrayBuffer();
+  if (body.byteLength === 0) throw new Error('empty image');
+  return new Response(body, { status: res.status, headers: res.headers });
+}
+
+/**
+ * The cards to try, in order: the full card; the full text without the logo and bg;
+ * the images with only the Latin text; then neither. Images and non-Latin text are the
+ * two things that throw. Latin text draws with the bundled font, while any other script
+ * makes Satori fetch and shape a font at render time (Arabic: Noto Sans Arabic uses GSUB
+ * lookup type 5, which Satori can't apply). Dropping images first keeps a title that
+ * draws fine when only the logo is broken. A tier that would draw the same picture as an
+ * earlier one is left out, so nothing renders twice.
+ */
+function cardTiers(content: CardContent, card: CardOptions): CardContent[] {
+  const keep = (text: string) => (isLatinText(text) ? text : '');
+  const noImages: CardContent = { ...content, logo: '', bg: '' };
+  const latinOnly: CardContent = {
+    ...content,
+    title: keep(content.title),
+    // Judged by what is drawn: a non-Latin tail past the cut never reaches Satori.
+    description: isLatinText(truncateText(content.description, MAX_DESCRIPTION_LENGTH)) ? content.description : '',
+    section: keep(content.section),
+    siteName: keep(content.siteName),
+  };
+  const neither: CardContent = { ...latinOnly, logo: '', bg: '' };
+
+  // What cardElement draws: a hidden site name or the cut-off end of a description doesn't count.
+  const drawn = (c: CardContent) => JSON.stringify([
+    c.title, truncateText(c.description, MAX_DESCRIPTION_LENGTH), c.section,
+    card.showSiteName ? c.siteName : '', c.logo, c.bg,
+  ]);
+  const seen = new Set<string>();
+  return [content, noImages, latinOnly, neither].filter((tier) => {
+    const key = drawn(tier);
+    if (seen.has(key)) return false;
+    seen.add(key);
+    return true;
+  });
+}
+
+const errorMessage = (err: unknown) => (err instanceof Error ? err.message : String(err));
+
+/**
+ * OG Image Generator
+ *
+ * Generates branded Open Graph images for documentation sites.
+ *
+ * Query Parameters:
+ * - title: Page title (required)
+ * - description: Page description (optional)
+ * - section: Section/group name (optional, e.g., "Get Started")
+ * - siteName: Site name (optional, defaults to "Documentation")
+ * - logo: URL to the project's logo (optional)
+ * - bg: URL to a custom background image rendered behind the text (optional)
+ * - theme: 'light' (default, warm cream) or 'dark'
+ * - accent: hex color (3 or 6 digits, '#' optional) for the badge and bottom bar; low-contrast values fall back to a readable color
+ * - hideBar: '1' hides the bottom accent bar
+ * - hideName: '1' hides the site name (the logo, if any, still renders)
+ *
+ * If the card fails to render, fallback cards without the images, without the
+ * non-Latin text, then without both are tried and served on a short cache; if
+ * every card fails, a 500 cached for a minute.
+ *
+ * Example:
+ * /api/og?title=Introduction&section=Get%20Started&siteName=Acme%20Docs&logo=https://...
+ */
+export async function GET(request: NextRequest) {
+  const searchParams = request.nextUrl.searchParams;
+
+  const card = parseCardOptions(searchParams);
+  // SSRF guard: HTTPS-only, blocks private/loopback/metadata IPs (incl. encoded forms).
+  const logoUrl = sanitizeLogoUrl(searchParams.get('logo') || '');
+  const bgUrl = sanitizeLogoUrl(searchParams.get('bg') || '');
+
+  const [logo, bg] = await Promise.all([
+    logoUrl ? fetchDataUri(logoUrl) : Promise.resolve(''),
+    bgUrl ? fetchDataUri(bgUrl) : Promise.resolve(''),
+  ]);
+
+  const content: CardContent = {
+    title: searchParams.get('title') || 'Documentation',
+    description: searchParams.get('description') || '',
+    section: searchParams.get('section') || '',
+    siteName: searchParams.get('siteName') || 'Documentation',
+    logo,
+    bg,
+  };
+
+  // The route skips middleware, so these are the only tenant identifiers here. Behind a
+  // proxy, host can name the upstream rather than the tenant, so x-forwarded-host wins.
+  const tenant = {
+    host: request.headers.get('x-forwarded-host') || request.headers.get('host') || request.nextUrl.host,
+    siteName: content.siteName,
+  };
+  const errors: string[] = [];
+  for (const [i, tier] of cardTiers(content, card).entries()) {
+    try {
+      return await renderCard(tier, card, i === 0 ? CACHE_CONTROL : FALLBACK_CACHE_CONTROL);
+    } catch (err) {
+      errors.push(errorMessage(err));
+      if (i === 0) {
+        log('warn', 'OG card render failed, trying fallback cards', {
+          ...tenant,
+          titleLength: content.title.length,
+          error: errors[0],
+        });
+      }
+    }
+  }
+
+  log('error', 'OG card and every fallback failed', { ...tenant, errors });
+  return new Response('OG image render failed', {
+    status: 500,
+    headers: { 'Cache-Control': ERROR_CACHE_CONTROL, 'Content-Type': 'text/plain; charset=utf-8' },
+  });
+}

package/vendored/app/layout.tsx

@@ -20,7 +20,7 @@ import {
 } from '@/lib/page-isr-helpers';
 import { isRTLLanguage, resolveLanguageWithFallback, toHreflang } from '@/lib/language-utils';
 import type { DocsConfig } from '@/lib/docs-types';
-import { buildSiteTitle, getFaviconIcons, FALLBACK_METADATA } from '@/lib/seo';
+import { buildSiteTitle, getFaviconIcons, getTitleTemplate, FALLBACK_METADATA } from '@/lib/seo';
 import { withR2OpsContext, emitR2OpsSummary } from '@/lib/r2-content';
 import { DocsChrome, getLocalFileContent, loadCustomAssets } from '@/lib/layout-helpers';
 import { filterNavigationForViewer } from '@/lib/viewer-navigation';
@@ -69,7 +69,7 @@ async function generateMetadataImpl(): Promise<Metadata> {
   const isEmbed = isIsrMode() && (await headers()).get('x-jd-layout') === 'embed';
   return {
     title: {
-      template: `%s — ${config.name}`,
+      template: getTitleTemplate(config),
       default: buildSiteTitle(config.name),
     },
     description: config.description || `Documentation for ${config.name}`,

package/vendored/lib/docs-types.ts

@@ -749,6 +749,8 @@ export interface SeoConfig {
   indexHiddenPages?: boolean;
   ai?: { llmsTxt?: boolean }; // default true; false suppresses llms.txt + llms-full.txt
   socialCard?: SocialCardConfig;
+  /** Browser tab and search title format; each `%s` becomes the page title (default: '%s — <name>'). Does not change og:title. */
+  titleTemplate?: string;
 }
 
 /**

package/vendored/lib/logo-svg-text-warning.ts

@@ -0,0 +1,55 @@
+import fs from 'fs';
+import path from 'path';
+import type { BuildWarning } from '../shared/status-reporter.js'; // vendored copy — NOT '../../shared'
+import { svgHasText, SVG_TEXT_MESSAGE, SVG_TEXT_LINK, SVG_TEXT_MAX_BYTES } from './svg-text.js';
+import { normalizeAssetPath } from './isr-build-executor.js';
+
+/**
+ * Suggestion for an SVG logo whose <text> the OG card renderer paints blank.
+ * The reader is injected so the build (disk) and the CLI can each resolve the
+ * ref their own way; any read failure means "no warning", never a failed build.
+ * `file` is the real asset path the reader found, like logo_oversized reports.
+ */
+export function logoSvgTextWarning(
+  ref: string | null,
+  read: (ref: string) => { file: string; svg: string } | null,
+): BuildWarning | null {
+  if (!ref || /^(?:https?:)?\/\//i.test(ref)) return null;
+  try {
+    const found = read(ref);
+    if (!found || !svgHasText(found.svg)) return null;
+    return { type: 'logo_svg_text', file: found.file, message: SVG_TEXT_MESSAGE, link: SVG_TEXT_LINK };
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Normalize a config image ref to the same key the upload loop uses: strip
+ * query/hash, leading ./ or ../, leading /, and a public/ prefix.
+ */
+export function toAssetKey(ref: string): string {
+  return normalizeAssetPath(
+    ref.split('?')[0].split('#')[0]
+      .replace(/^(?:\.\.?\/)+/, '')
+      .replace(/^\/+/, ''),
+  );
+}
+
+/**
+ * Resolve a config logo ref to its collected asset and read the SVG text.
+ * Null when the asset is unknown or over the size cap (the scan is skipped,
+ * not the build). Extracted from build.ts so a test can exercise the real
+ * lookup instead of a fake reader.
+ */
+export function readCardSvgLogo(
+  ref: string,
+  assetByNormalizedKey: Map<string, string>,
+  docsDir: string,
+): { file: string; svg: string } | null {
+  const asset = assetByNormalizedKey.get(toAssetKey(ref));
+  if (!asset) return null;
+  const full = path.join(docsDir, asset);
+  if (fs.statSync(full).size > SVG_TEXT_MAX_BYTES) return null;
+  return { file: asset, svg: fs.readFileSync(full, 'utf8') };
+}

package/vendored/lib/og-card.ts

@@ -130,15 +130,51 @@ export function parseCardOptions(params: URLSearchParams): CardOptions {
 const UNRENDERABLE_IMAGE_TYPES = new Set([
   'image/webp', 'image/avif',
   'image/tiff', 'image/heic', 'image/heif', 'image/jxl', 'image/bmp',
-  // Non-standard spellings of JPEG that real servers send; Satori only knows image/jpeg.
-  'image/jpg', 'image/pjpeg',
 ]);
 
-export function isRenderableImageType(contentType: string): boolean {
-  const type = contentType.split(';')[0].trim().toLowerCase();
+// Non-standard spellings of JPEG that real servers send. Satori throws on the label,
+// not the bytes, so real JPEG bytes are relabelled; anything else under these labels
+// is dropped, as it was before relabelling existed.
+const JPEG_ALIASES = new Set(['image/jpg', 'image/pjpeg']);
+
+function isJpeg(bytes: Uint8Array): boolean {
+  return bytes.length >= 3 && bytes[0] === 0xff && bytes[1] === 0xd8 && bytes[2] === 0xff;
+}
+
+function baseType(contentType: string): string {
+  return contentType.split(';')[0].trim().toLowerCase();
+}
+
+/**
+ * True when the declared type alone rules the image out, so the caller can skip
+ * downloading it. The JPEG aliases are not ruled out here: they need their bytes.
+ */
+export function isDeniedImageType(contentType: string): boolean {
+  const type = baseType(contentType);
   // A 200 HTML page for a missing image (soft 404) is the realistic non-image case.
   // Only plain-letter subtypes throw (html, plain, xml, css, svg+xml); text/x-generic,
   // text/vnd.foo and text/html5 are byte-sniffed and draw today, so they must stay allowed.
-  if (/^text\/[a-z+]+$/.test(type)) return false;
-  return !UNRENDERABLE_IMAGE_TYPES.has(type);
+  return /^text\/[a-z+]+$/.test(type) || UNRENDERABLE_IMAGE_TYPES.has(type);
+}
+
+/**
+ * The type to declare in an image's data URI, or null when Satori can't draw it and
+ * the card should go without the image. Every other type is returned untouched so the
+ * data URI, and the card, stay byte-identical.
+ */
+export function dataUriImageType(contentType: string, bytes: Uint8Array): string | null {
+  if (JPEG_ALIASES.has(baseType(contentType))) return isJpeg(bytes) ? 'image/jpeg' : null;
+  return isDeniedImageType(contentType) ? null : contentType;
+}
+
+// Latin letters plus the punctuation, currency and letterlike symbols docs titles use.
+const LATIN_TEXT = /^[\u0000-\u024F\u1E00-\u1EFF\u2000-\u206F\u20A0-\u20CF\u2100-\u214F]*$/;
+
+/**
+ * True when the text needs no font beyond the one bundled with the renderer. Any
+ * other script is shaped with a font fetched at render time, and that is the step
+ * that can throw, so the route's fallback card drops text that fails this check.
+ */
+export function isLatinText(text: string): boolean {
+  return LATIN_TEXT.test(text);
 }

package/vendored/lib/seo.ts

@@ -34,6 +34,22 @@ export function buildSiteTitle(configName: string): string {
     : `${configName} Documentation`;
 }
 
+/**
+ * Root `title.template` for the site. Defaults to `%s — <name>`; sites opt in
+ * to their own via `seo.titleTemplate`.
+ *
+ * The schema already rejects a template without `%s`, but the runtime check
+ * stays: an older R2 config or a hand edit can slip past it, and a template
+ * with no `%s` would give every page the same title.
+ */
+export function getTitleTemplate(config: { name: string; seo?: { titleTemplate?: unknown } }): string {
+  const custom = config.seo?.titleTemplate;
+  if (typeof custom === 'string' && custom.includes('%s')) {
+    return custom;
+  }
+  return `%s — ${config.name}`;
+}
+
 /**
  * Icon descriptors for Next.js Metadata.icons.icon. When both light and
  * dark are configured the dark entry trails the primary with a