@mnaoumov/typescript-dev-toolkit 1.3.1 → 2.0.0

package/dist/lib/esm/docs-site/og-image.mjs

@@ -0,0 +1,292 @@
+/*
+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 { Resvg } from "@resvg/resvg-js";
+import { createHash } from "node:crypto";
+import { existsSync } from "node:fs";
+import {
+  readdir,
+  readFile
+} from "node:fs/promises";
+import satori from "satori";
+const OG_WIDTH = 1200;
+const OG_HEIGHT = 630;
+const BACKGROUND_COLOR = "#111213";
+const ACCENT_COLOR = "#8b6ff5";
+const ACCENT_BG = "rgba(103, 172, 172, 0.18)";
+const TITLE_COLOR = "#ffffff";
+const DESCRIPTION_COLOR = "#9CA3AF";
+const BRAND_COLOR = "#8b6ff5";
+const BORDER_WIDTH = 8;
+const PADDING_X = 80;
+const PADDING_TOP = 70;
+const PADDING_BOTTOM = 60;
+const TITLE_FONT_SIZE = 56;
+const DESCRIPTION_FONT_SIZE = 26;
+const BADGE_FONT_SIZE = 18;
+const BADGE_FONT_WEIGHT = 600;
+const BRAND_FONT_SIZE = 28;
+const FONT_WEIGHT_REGULAR = 400;
+const FONT_WEIGHT_BOLD = 700;
+const TITLE_LINE_HEIGHT = 1.2;
+const DESCRIPTION_LINE_HEIGHT = 1.5;
+const SIGNATURE_FONT_SIZE = 24;
+const SIGNATURE_LINE_HEIGHT = 1.4;
+const SIGNATURE_BG = "rgba(0, 0, 0, 0.35)";
+const SIGNATURE_MAX_LINES = 2;
+const LOGO_DISPLAY_SIZE = 76;
+const LOGO_RASTER_SIZE = 152;
+function computeOgHash(params) {
+  const input = JSON.stringify({
+    badge: params.badge ?? "",
+    description: params.description ?? "",
+    signature: params.signature ?? "",
+    title: params.title
+  });
+  const HASH_LENGTH = 16;
+  return createHash("sha256").update(input).digest("hex").slice(0, HASH_LENGTH);
+}
+async function loadFonts(fontsDirectory) {
+  const regularPath = `${fontsDirectory}/inter-latin-400-normal.ttf`;
+  const boldPath = `${fontsDirectory}/inter-latin-700-normal.ttf`;
+  if (existsSync(regularPath) && existsSync(boldPath)) {
+    const [regularData, boldData] = await Promise.all([
+      readFile(regularPath),
+      readFile(boldPath)
+    ]);
+    return [
+      { data: regularData, name: "Inter", style: "normal", weight: FONT_WEIGHT_REGULAR },
+      { data: boldData, name: "Inter", style: "normal", weight: FONT_WEIGHT_BOLD }
+    ];
+  }
+  if (existsSync(fontsDirectory)) {
+    const entries = await readdir(fontsDirectory);
+    const fontFile = entries.find((name) => name.endsWith(".ttf") || name.endsWith(".otf"));
+    if (fontFile) {
+      const data = await readFile(`${fontsDirectory}/${fontFile}`);
+      return [
+        { data, name: "Inter", style: "normal", weight: FONT_WEIGHT_REGULAR },
+        { data, name: "Inter", style: "normal", weight: FONT_WEIGHT_BOLD }
+      ];
+    }
+  }
+  return null;
+}
+async function loadLogoDataUri(faviconPath) {
+  if (!existsSync(faviconPath)) {
+    return null;
+  }
+  const svg = await readFile(faviconPath, "utf-8");
+  const resvg = new Resvg(svg, { fitTo: { mode: "width", value: LOGO_RASTER_SIZE } });
+  const png = resvg.render().asPng();
+  return `data:image/png;base64,${png.toString("base64")}`;
+}
+async function renderOgImage(params, options) {
+  const markup = buildOgImageMarkup(params, options);
+  const svg = await satori(markup, {
+    fonts: options.fonts,
+    height: OG_HEIGHT,
+    width: OG_WIDTH
+  });
+  const resvg = new Resvg(svg, {
+    fitTo: { mode: "width", value: OG_WIDTH }
+  });
+  return resvg.render().asPng();
+}
+function buildBadgeMarkup(badge) {
+  return {
+    props: {
+      children: badge,
+      style: {
+        alignItems: "center",
+        background: ACCENT_BG,
+        borderRadius: "20px",
+        color: ACCENT_COLOR,
+        display: "flex",
+        fontSize: `${String(BADGE_FONT_SIZE)}px`,
+        fontWeight: BADGE_FONT_WEIGHT,
+        padding: "6px 14px"
+      }
+    },
+    type: "div"
+  };
+}
+function buildLogoMarkup(logoDataUri) {
+  return {
+    props: {
+      height: LOGO_DISPLAY_SIZE,
+      src: logoDataUri,
+      style: {
+        height: `${String(LOGO_DISPLAY_SIZE)}px`,
+        width: `${String(LOGO_DISPLAY_SIZE)}px`
+      },
+      width: LOGO_DISPLAY_SIZE
+    },
+    type: "img"
+  };
+}
+function buildOgImageMarkup(params, options) {
+  const badgeNode = params.badge ? buildBadgeMarkup(params.badge) : null;
+  const logoNode = options.logoDataUri ? buildLogoMarkup(options.logoDataUri) : null;
+  const topRowChildren = [
+    ...logoNode ? [logoNode] : [],
+    { props: { style: { flex: 1 } }, type: "div" },
+    ...badgeNode ? [badgeNode] : []
+  ];
+  const topRow = {
+    props: {
+      children: topRowChildren,
+      style: {
+        alignItems: "center",
+        display: "flex",
+        marginBottom: "24px"
+      }
+    },
+    type: "div"
+  };
+  const title = {
+    props: {
+      children: params.title,
+      style: {
+        color: TITLE_COLOR,
+        fontSize: `${String(TITLE_FONT_SIZE)}px`,
+        fontWeight: FONT_WEIGHT_BOLD,
+        lineHeight: TITLE_LINE_HEIGHT,
+        marginBottom: "20px",
+        overflow: "hidden",
+        textOverflow: "ellipsis"
+      }
+    },
+    type: "div"
+  };
+  const signatureNode = params.signature ? buildSignatureMarkup(params.signature) : null;
+  const description = {
+    props: {
+      children: params.description ?? "",
+      style: {
+        color: DESCRIPTION_COLOR,
+        flex: 1,
+        fontSize: `${String(DESCRIPTION_FONT_SIZE)}px`,
+        lineHeight: DESCRIPTION_LINE_HEIGHT,
+        overflow: "hidden",
+        textOverflow: "ellipsis"
+      }
+    },
+    type: "div"
+  };
+  const footer = {
+    props: {
+      children: [
+        { props: { style: { flex: 1 } }, type: "div" },
+        {
+          props: {
+            children: options.brandText,
+            style: {
+              color: BRAND_COLOR,
+              fontSize: `${String(BRAND_FONT_SIZE)}px`,
+              fontWeight: FONT_WEIGHT_BOLD
+            }
+          },
+          type: "div"
+        }
+      ],
+      style: {
+        alignItems: "flex-end",
+        display: "flex"
+      }
+    },
+    type: "div"
+  };
+  return {
+    props: {
+      children: [
+        {
+          props: {
+            children: signatureNode ? [topRow, title, signatureNode, description] : [topRow, title, description],
+            style: {
+              display: "flex",
+              flex: 1,
+              flexDirection: "column"
+            }
+          },
+          type: "div"
+        },
+        footer
+      ],
+      style: {
+        background: BACKGROUND_COLOR,
+        borderLeft: `${String(BORDER_WIDTH)}px solid ${ACCENT_COLOR}`,
+        display: "flex",
+        flexDirection: "column",
+        height: "100%",
+        justifyContent: "space-between",
+        padding: `${String(PADDING_TOP)}px ${String(PADDING_X)}px ${String(PADDING_BOTTOM)}px ${String(PADDING_X)}px`,
+        width: "100%"
+      }
+    },
+    type: "div"
+  };
+}
+function buildSignatureMarkup(signature) {
+  return {
+    props: {
+      children: signature,
+      style: {
+        background: SIGNATURE_BG,
+        borderRadius: "12px",
+        color: ACCENT_COLOR,
+        display: "-webkit-box",
+        fontFamily: "monospace",
+        fontSize: `${String(SIGNATURE_FONT_SIZE)}px`,
+        lineClamp: SIGNATURE_MAX_LINES,
+        lineHeight: SIGNATURE_LINE_HEIGHT,
+        marginBottom: "28px",
+        overflow: "hidden",
+        padding: "16px 24px"
+      }
+    },
+    type: "div"
+  };
+}
+export {
+  computeOgHash,
+  loadFonts,
+  loadLogoDataUri,
+  renderOgImage
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../../../src/docs-site/og-image.ts"],"sourcesContent":["/**\n * @file\n *\n * Renders a page's Open Graph card: satori lays it out as SVG, resvg rasterizes it to PNG.\n */\n\nimport type { Font } from 'satori';\n\nimport { Resvg } from '@resvg/resvg-js';\nimport { createHash } from 'node:crypto';\nimport { existsSync } from 'node:fs';\nimport {\n  readdir,\n  readFile\n} from 'node:fs/promises';\nimport satori from 'satori';\n\nconst OG_WIDTH = 1200;\nconst OG_HEIGHT = 630;\nconst BACKGROUND_COLOR = '#111213';\n// The violet accent, matching the docs theme (`--sl-color-accent`).\nconst ACCENT_COLOR = '#8b6ff5';\nconst ACCENT_BG = 'rgba(103, 172, 172, 0.18)';\nconst TITLE_COLOR = '#ffffff';\nconst DESCRIPTION_COLOR = '#9CA3AF';\nconst BRAND_COLOR = '#8b6ff5';\nconst BORDER_WIDTH = 8;\nconst PADDING_X = 80;\nconst PADDING_TOP = 70;\nconst PADDING_BOTTOM = 60;\nconst TITLE_FONT_SIZE = 56;\nconst DESCRIPTION_FONT_SIZE = 26;\nconst BADGE_FONT_SIZE = 18;\nconst BADGE_FONT_WEIGHT = 600;\nconst BRAND_FONT_SIZE = 28;\nconst FONT_WEIGHT_REGULAR = 400;\nconst FONT_WEIGHT_BOLD = 700;\nconst TITLE_LINE_HEIGHT = 1.2;\nconst DESCRIPTION_LINE_HEIGHT = 1.5;\n// Signature code block (violet accent on a subtle darker rounded panel).\nconst SIGNATURE_FONT_SIZE = 24;\nconst SIGNATURE_LINE_HEIGHT = 1.4;\nconst SIGNATURE_BG = 'rgba(0, 0, 0, 0.35)';\nconst SIGNATURE_MAX_LINES = 2;\n// Site logo (favicon), rasterized once and embedded as a data URI.\nconst LOGO_DISPLAY_SIZE = 76;\nconst LOGO_RASTER_SIZE = 152;\n\n/**\n * What one Open Graph card shows: a title, and optionally a description, a code signature and a badge.\n */\nexport interface OgCardContent {\n  readonly badge?: string | undefined;\n  readonly description?: string | undefined;\n  readonly signature?: string | undefined;\n  readonly title: string;\n}\n\n/**\n * The per-site part of every card: the fonts, the logo and the brand text in the footer.\n */\nexport interface RenderOgImageOptions {\n  /**\n   * The text the footer carries, normally the package's name.\n   */\n  readonly brandText: string;\n\n  /**\n   * The fonts satori renders the text with.\n   */\n  readonly fonts: Font[];\n\n  /**\n   * The site logo as a PNG data URI, or `null` to render the card without one.\n   */\n  readonly logoDataUri: null | string;\n}\n\n/**\n * Hashes a card's content, so an unchanged card is not rendered again.\n *\n * @param params - The card's content.\n * @returns A 16-character hex digest.\n */\nexport function computeOgHash(params: OgCardContent): string {\n  const input = JSON.stringify({\n    badge: params.badge ?? '',\n    description: params.description ?? '',\n    signature: params.signature ?? '',\n    title: params.title\n  });\n  const HASH_LENGTH = 16;\n  return createHash('sha256').update(input).digest('hex').slice(0, HASH_LENGTH);\n}\n\n/**\n * Loads the fonts satori needs to render text.\n *\n * This package ships `inter-latin-400-normal.ttf` / `inter-latin-700-normal.ttf` under\n * `assets/docs-site/fonts`; this falls back to any other `.ttf`/`.otf` in `fontsDirectory` and\n * returns `null` when the directory holds none, so the caller can skip OG generation instead of\n * crashing the build.\n *\n * @param fontsDirectory - The folder holding the fonts.\n * @returns The fonts, or `null` when the folder holds none.\n */\nexport async function loadFonts(fontsDirectory: string): Promise<Font[] | null> {\n  const regularPath = `${fontsDirectory}/inter-latin-400-normal.ttf`;\n  const boldPath = `${fontsDirectory}/inter-latin-700-normal.ttf`;\n\n  if (existsSync(regularPath) && existsSync(boldPath)) {\n    const [regularData, boldData] = await Promise.all([\n      readFile(regularPath),\n      readFile(boldPath)\n    ]);\n    return [\n      { data: regularData, name: 'Inter', style: 'normal' as const, weight: FONT_WEIGHT_REGULAR },\n      { data: boldData, name: 'Inter', style: 'normal' as const, weight: FONT_WEIGHT_BOLD }\n    ];\n  }\n\n  // Fallback: reuse any single font file in the directory for both weights.\n  if (existsSync(fontsDirectory)) {\n    const entries = await readdir(fontsDirectory);\n    const fontFile = entries.find((name) => name.endsWith('.ttf') || name.endsWith('.otf'));\n    if (fontFile) {\n      const data = await readFile(`${fontsDirectory}/${fontFile}`);\n      return [\n        { data, name: 'Inter', style: 'normal' as const, weight: FONT_WEIGHT_REGULAR },\n        { data, name: 'Inter', style: 'normal' as const, weight: FONT_WEIGHT_BOLD }\n      ];\n    }\n  }\n\n  return null;\n}\n\n/**\n * Rasterize an SVG favicon to a PNG data URI via resvg for embedding in the satori layout (satori's\n * `<img>` needs a raster/data-URI source). Returns `null` when the file is missing so the caller can\n * render the card without a logo. Call this ONCE and reuse the result across all cards.\n *\n * @param faviconPath - The SVG favicon's path.\n * @returns The PNG data URI, or `null` when the favicon is missing.\n */\nexport async function loadLogoDataUri(faviconPath: string): Promise<null | string> {\n  if (!existsSync(faviconPath)) {\n    return null;\n  }\n  const svg = await readFile(faviconPath, 'utf-8');\n  const resvg = new Resvg(svg, { fitTo: { mode: 'width', value: LOGO_RASTER_SIZE } });\n  const png = resvg.render().asPng();\n  return `data:image/png;base64,${png.toString('base64')}`;\n}\n\n/**\n * Renders a page's card to a PNG.\n *\n * @param params - The card's content.\n * @param options - The fonts, logo and brand text every card shares.\n * @returns The PNG.\n */\nexport async function renderOgImage(params: OgCardContent, options: RenderOgImageOptions): Promise<Buffer> {\n  const markup = buildOgImageMarkup(params, options);\n  const svg = await satori(markup, {\n    fonts: options.fonts,\n    height: OG_HEIGHT,\n    width: OG_WIDTH\n  });\n\n  const resvg = new Resvg(svg, {\n    fitTo: { mode: 'width', value: OG_WIDTH }\n  });\n  return resvg.render().asPng();\n}\n\nfunction buildBadgeMarkup(badge: string): Record<string, unknown> {\n  return {\n    props: {\n      children: badge,\n      style: {\n        alignItems: 'center',\n        background: ACCENT_BG,\n        borderRadius: '20px',\n        color: ACCENT_COLOR,\n        display: 'flex',\n        fontSize: `${String(BADGE_FONT_SIZE)}px`,\n        fontWeight: BADGE_FONT_WEIGHT,\n        padding: '6px 14px'\n      }\n    },\n    type: 'div'\n  };\n}\n\nfunction buildLogoMarkup(logoDataUri: string): Record<string, unknown> {\n  return {\n    props: {\n      height: LOGO_DISPLAY_SIZE,\n      src: logoDataUri,\n      style: {\n        height: `${String(LOGO_DISPLAY_SIZE)}px`,\n        width: `${String(LOGO_DISPLAY_SIZE)}px`\n      },\n      width: LOGO_DISPLAY_SIZE\n    },\n    type: 'img'\n  };\n}\n\nfunction buildOgImageMarkup(params: OgCardContent, options: RenderOgImageOptions): Record<string, unknown> {\n  const badgeNode = params.badge ? buildBadgeMarkup(params.badge) : null;\n  const logoNode = options.logoDataUri ? buildLogoMarkup(options.logoDataUri) : null;\n\n  // Top row: logo on the left, badge on the right.\n  const topRowChildren: Record<string, unknown>[] = [\n    ...(logoNode ? [logoNode] : []),\n    { props: { style: { flex: 1 } }, type: 'div' },\n    ...(badgeNode ? [badgeNode] : [])\n  ];\n  const topRow = {\n    props: {\n      children: topRowChildren,\n      style: {\n        alignItems: 'center',\n        display: 'flex',\n        marginBottom: '24px'\n      }\n    },\n    type: 'div'\n  };\n\n  // Title\n  const title = {\n    props: {\n      children: params.title,\n      style: {\n        color: TITLE_COLOR,\n        fontSize: `${String(TITLE_FONT_SIZE)}px`,\n        fontWeight: FONT_WEIGHT_BOLD,\n        lineHeight: TITLE_LINE_HEIGHT,\n        marginBottom: '20px',\n        overflow: 'hidden',\n        textOverflow: 'ellipsis'\n      }\n    },\n    type: 'div'\n  };\n\n  // Signature code block (between title and description) — omitted for pages with no signature.\n  const signatureNode = params.signature ? buildSignatureMarkup(params.signature) : null;\n\n  // Description\n  const description = {\n    props: {\n      children: params.description ?? '',\n      style: {\n        color: DESCRIPTION_COLOR,\n        flex: 1,\n        fontSize: `${String(DESCRIPTION_FONT_SIZE)}px`,\n        lineHeight: DESCRIPTION_LINE_HEIGHT,\n        overflow: 'hidden',\n        textOverflow: 'ellipsis'\n      }\n    },\n    type: 'div'\n  };\n\n  // Footer with the package name as text branding (the favicon is rendered separately, in the header)\n  const footer = {\n    props: {\n      children: [\n        { props: { style: { flex: 1 } }, type: 'div' },\n        {\n          props: {\n            children: options.brandText,\n            style: {\n              color: BRAND_COLOR,\n              fontSize: `${String(BRAND_FONT_SIZE)}px`,\n              fontWeight: FONT_WEIGHT_BOLD\n            }\n          },\n          type: 'div'\n        }\n      ],\n      style: {\n        alignItems: 'flex-end',\n        display: 'flex'\n      }\n    },\n    type: 'div'\n  };\n\n  // Root container\n  return {\n    props: {\n      children: [\n        {\n          props: {\n            children: signatureNode ? [topRow, title, signatureNode, description] : [topRow, title, description],\n            style: {\n              display: 'flex',\n              flex: 1,\n              flexDirection: 'column'\n            }\n          },\n          type: 'div'\n        },\n        footer\n      ],\n      style: {\n        background: BACKGROUND_COLOR,\n        borderLeft: `${String(BORDER_WIDTH)}px solid ${ACCENT_COLOR}`,\n        display: 'flex',\n        flexDirection: 'column',\n        height: '100%',\n        justifyContent: 'space-between',\n        padding: `${String(PADDING_TOP)}px ${String(PADDING_X)}px ${String(PADDING_BOTTOM)}px ${String(PADDING_X)}px`,\n        width: '100%'\n      }\n    },\n    type: 'div'\n  };\n}\n\nfunction buildSignatureMarkup(signature: string): Record<string, unknown> {\n  return {\n    props: {\n      children: signature,\n      style: {\n        background: SIGNATURE_BG,\n        borderRadius: '12px',\n        color: ACCENT_COLOR,\n        display: '-webkit-box',\n        fontFamily: 'monospace',\n        fontSize: `${String(SIGNATURE_FONT_SIZE)}px`,\n        lineClamp: SIGNATURE_MAX_LINES,\n        lineHeight: SIGNATURE_LINE_HEIGHT,\n        marginBottom: '28px',\n        overflow: 'hidden',\n        padding: '16px 24px'\n      }\n    },\n    type: 'div'\n  };\n}\n"],"mappings":"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","names":[]}

package/dist/lib/esm/docs-site/og-images.d.mts

@@ -0,0 +1,41 @@
+/// <reference path="../library-references.d.mts" />
+/**
+ * @file
+ *
+ * Generates an Open Graph card for every documentation page, reusing the cards whose inputs did not change.
+ */
+/**
+ * Options for {@link generateOgImages}.
+ */
+export interface GenerateOgImagesParams {
+    /**
+     * The text every card's footer carries, normally the package's name.
+     */
+    readonly brandText: string;
+    /**
+     * The documentation content root, normally `<docs>/src/content/docs`. Every `.md` / `.mdx` page under it with a
+     * `title` gets a card.
+     */
+    readonly contentDocsDirectory: string;
+    /**
+     * The SVG logo drawn on every card. A missing file renders the cards without one.
+     */
+    readonly faviconPath: string;
+    /**
+     * The folder holding the fonts the cards are rendered with.
+     */
+    readonly fontsDirectory: string;
+    /**
+     * The folder the cards are written to, normally `<docs>/public/og`, served at `<base>/og/<slug>.png`.
+     */
+    readonly outputDirectory: string;
+}
+/**
+ * Generates the Open Graph cards.
+ *
+ * A card is re-rendered only when its title, description, signature or badge changed, tracked by a hash manifest
+ * beside the cards. Missing content or fonts skip the step with a warning rather than failing the build.
+ *
+ * @param options - The options.
+ */
+export declare function generateOgImages(options: GenerateOgImagesParams): Promise<void>;

package/dist/lib/esm/docs-site/og-images.mjs

@@ -0,0 +1,156 @@
+/*
+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 { existsSync } from "node:fs";
+import {
+  mkdir,
+  readdir,
+  readFile,
+  writeFile
+} from "node:fs/promises";
+import { dirname } from "node:path/posix";
+import { parse as parseYaml } from "yaml";
+import { getOgImagePageSlug } from "./og-image-page.mjs";
+import {
+  computeOgHash,
+  loadFonts,
+  loadLogoDataUri,
+  renderOgImage
+} from "./og-image.mjs";
+const CONCURRENCY = 10;
+const PROGRESS_LOG_INTERVAL = 100;
+const MANIFEST_INDENT = 2;
+const FRONT_MATTER_REG_EXP = /^---\r?\n(?<FrontMatter>[\s\S]*?)\r?\n---(?:\r?\n|$)/;
+async function generateOgImages(options) {
+  const { brandText, contentDocsDirectory, faviconPath, fontsDirectory, outputDirectory } = options;
+  const manifestPath = `${outputDirectory}/.cache-manifest.json`;
+  if (!existsSync(contentDocsDirectory)) {
+    console.warn(`OG images: content dir not found (${contentDocsDirectory}); skipping.`);
+    return;
+  }
+  const fonts = await loadFonts(fontsDirectory);
+  if (!fonts) {
+    console.warn(`OG images: no fonts available in ${fontsDirectory}; skipping OG image generation.`);
+    return;
+  }
+  const pages = [];
+  await walkDirectory(contentDocsDirectory, contentDocsDirectory, pages);
+  console.warn(`OG images: found ${String(pages.length)} pages`);
+  const manifest = await loadCacheManifest(manifestPath);
+  const changedPages = pages.filter((page) => manifest[page.slug] !== page.hash);
+  console.warn(`OG images: ${String(changedPages.length)} changed / ${String(pages.length)} total`);
+  if (changedPages.length === 0) {
+    console.warn("All OG images up to date.");
+    return;
+  }
+  const logoDataUri = await loadLogoDataUri(faviconPath);
+  if (!logoDataUri) {
+    console.warn(`OG images: favicon not found (${faviconPath}); rendering cards without a logo.`);
+  }
+  await generateImagesWithPool({ brandText, changedPages, fonts, logoDataUri, manifest, outputDirectory });
+  await mkdir(dirname(manifestPath), { recursive: true });
+  await writeFile(manifestPath, JSON.stringify(manifest, null, MANIFEST_INDENT));
+  console.warn(`OG images: done. Generated ${String(changedPages.length)} images.`);
+}
+async function generateImagesWithPool(options) {
+  const { brandText, changedPages, fonts, logoDataUri, manifest, outputDirectory } = options;
+  let completed = 0;
+  let index = 0;
+  async function processNext() {
+    for (let page = changedPages[index++]; page !== void 0; page = changedPages[index++]) {
+      const outputPath = `${outputDirectory}/${page.slug}.png`;
+      await mkdir(dirname(outputPath), { recursive: true });
+      await writeFile(outputPath, await renderOgImage(page.params, { brandText, fonts, logoDataUri }));
+      manifest[page.slug] = page.hash;
+      completed++;
+      if (completed % PROGRESS_LOG_INTERVAL === 0) {
+        console.warn(`  ${String(completed)}/${String(changedPages.length)} images generated...`);
+      }
+    }
+  }
+  await Promise.all(Array.from({ length: CONCURRENCY }, async () => {
+    await processNext();
+  }));
+}
+async function loadCacheManifest(manifestPath) {
+  return existsSync(manifestPath) ? JSON.parse(await readFile(manifestPath, "utf-8")) : {};
+}
+function parseFrontMatter(content) {
+  const frontMatter = FRONT_MATTER_REG_EXP.exec(content)?.groups?.["FrontMatter"];
+  return frontMatter === void 0 ? {} : parseYaml(frontMatter) ?? {};
+}
+async function parsePage(filePath, contentDocsDirectory) {
+  const data = parseFrontMatter(await readFile(filePath, "utf-8"));
+  const title = toOptionalString(data["title"]);
+  if (!title) {
+    return null;
+  }
+  const badge = data["sidebar"];
+  const params = {
+    badge: toOptionalString(badge?.["badge"]?.["text"]),
+    description: toOptionalString(data["description"]) ?? "",
+    signature: toOptionalString(data["signature"]) ?? "",
+    title
+  };
+  return {
+    hash: computeOgHash(params),
+    params,
+    slug: getOgImagePageSlug(data, filePath, contentDocsDirectory)
+  };
+}
+function toOptionalString(value) {
+  return typeof value === "string" ? value : void 0;
+}
+async function walkDirectory(directory, contentDocsDirectory, pages) {
+  const entries = await readdir(directory, { withFileTypes: true });
+  for (const entry of entries) {
+    const fullPath = `${directory}/${entry.name}`;
+    if (entry.isDirectory()) {
+      await walkDirectory(fullPath, contentDocsDirectory, pages);
+    } else if (entry.name.endsWith(".md") || entry.name.endsWith(".mdx")) {
+      const page = await parsePage(fullPath, contentDocsDirectory);
+      if (page) {
+        pages.push(page);
+      }
+    }
+  }
+}
+export {
+  generateOgImages
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../../../src/docs-site/og-images.ts"],"sourcesContent":["/**\n * @file\n *\n * Generates an Open Graph card for every documentation page, reusing the cards whose inputs did not change.\n */\n\nimport type { Font } from 'satori';\n\nimport { existsSync } from 'node:fs';\nimport {\n  mkdir,\n  readdir,\n  readFile,\n  writeFile\n} from 'node:fs/promises';\nimport { dirname } from 'node:path/posix';\nimport { parse as parseYaml } from 'yaml';\n\nimport type { OgCardContent } from './og-image.ts';\n\nimport { getOgImagePageSlug } from './og-image-page.ts';\nimport {\n  computeOgHash,\n  loadFonts,\n  loadLogoDataUri,\n  renderOgImage\n} from './og-image.ts';\n\n/**\n * Options for {@link generateOgImages}.\n */\nexport interface GenerateOgImagesParams {\n  /**\n   * The text every card's footer carries, normally the package's name.\n   */\n  readonly brandText: string;\n\n  /**\n   * The documentation content root, normally `<docs>/src/content/docs`. Every `.md` / `.mdx` page under it with a\n   * `title` gets a card.\n   */\n  readonly contentDocsDirectory: string;\n\n  /**\n   * The SVG logo drawn on every card. A missing file renders the cards without one.\n   */\n  readonly faviconPath: string;\n\n  /**\n   * The folder holding the fonts the cards are rendered with.\n   */\n  readonly fontsDirectory: string;\n\n  /**\n   * The folder the cards are written to, normally `<docs>/public/og`, served at `<base>/og/<slug>.png`.\n   */\n  readonly outputDirectory: string;\n}\n\ntype CacheManifest = Partial<Record<string, string>>;\n\ninterface GenerateImagesWithPoolOptions {\n  readonly brandText: string;\n  readonly changedPages: PageEntry[];\n  readonly fonts: Font[];\n  readonly logoDataUri: null | string;\n  readonly manifest: CacheManifest;\n  readonly outputDirectory: string;\n}\n\ninterface PageEntry {\n  hash: string;\n  params: OgCardContent;\n  slug: string;\n}\n\nconst CONCURRENCY = 10;\nconst PROGRESS_LOG_INTERVAL = 100;\nconst MANIFEST_INDENT = 2;\n\n// Frontmatter is parsed here rather than with `gray-matter`. Its `lib/engines.js` binds js-yaml's\n// `safeLoad`/`safeDump` at MODULE-LOAD time, and both were removed in js-yaml v4 — so merely\n// IMPORTING `gray-matter` throws `Cannot read properties of undefined (reading 'bind')`, before an\n// `engines` option could override the default. Only the frontmatter object is needed here.\nconst FRONT_MATTER_REG_EXP = /^---\\r?\\n(?<FrontMatter>[\\s\\S]*?)\\r?\\n---(?:\\r?\\n|$)/;\n\n/**\n * Generates the Open Graph cards.\n *\n * A card is re-rendered only when its title, description, signature or badge changed, tracked by a hash manifest\n * beside the cards. Missing content or fonts skip the step with a warning rather than failing the build.\n *\n * @param options - The options.\n */\nexport async function generateOgImages(options: GenerateOgImagesParams): Promise<void> {\n  const { brandText, contentDocsDirectory, faviconPath, fontsDirectory, outputDirectory } = options;\n  const manifestPath = `${outputDirectory}/.cache-manifest.json`;\n\n  if (!existsSync(contentDocsDirectory)) {\n    console.warn(`OG images: content dir not found (${contentDocsDirectory}); skipping.`);\n    return;\n  }\n\n  // Load fonts first — satori cannot render without them.\n  const fonts = await loadFonts(fontsDirectory);\n  if (!fonts) {\n    console.warn(`OG images: no fonts available in ${fontsDirectory}; skipping OG image generation.`);\n    return;\n  }\n\n  const pages: PageEntry[] = [];\n  await walkDirectory(contentDocsDirectory, contentDocsDirectory, pages);\n  console.warn(`OG images: found ${String(pages.length)} pages`);\n\n  const manifest = await loadCacheManifest(manifestPath);\n  const changedPages = pages.filter((page) => manifest[page.slug] !== page.hash);\n  console.warn(`OG images: ${String(changedPages.length)} changed / ${String(pages.length)} total`);\n\n  if (changedPages.length === 0) {\n    console.warn('All OG images up to date.');\n    return;\n  }\n\n  // Rasterize the site logo once (shared across every card); degrade gracefully if absent.\n  const logoDataUri = await loadLogoDataUri(faviconPath);\n  if (!logoDataUri) {\n    console.warn(`OG images: favicon not found (${faviconPath}); rendering cards without a logo.`);\n  }\n\n  await generateImagesWithPool({ brandText, changedPages, fonts, logoDataUri, manifest, outputDirectory });\n\n  await mkdir(dirname(manifestPath), { recursive: true });\n  await writeFile(manifestPath, JSON.stringify(manifest, null, MANIFEST_INDENT));\n  console.warn(`OG images: done. Generated ${String(changedPages.length)} images.`);\n}\n\nasync function generateImagesWithPool(options: GenerateImagesWithPoolOptions): Promise<void> {\n  const { brandText, changedPages, fonts, logoDataUri, manifest, outputDirectory } = options;\n  let completed = 0;\n  let index = 0;\n\n  async function processNext(): Promise<void> {\n    for (let page = changedPages[index++]; page !== undefined; page = changedPages[index++]) {\n      const outputPath = `${outputDirectory}/${page.slug}.png`;\n      await mkdir(dirname(outputPath), { recursive: true });\n      await writeFile(outputPath, await renderOgImage(page.params, { brandText, fonts, logoDataUri }));\n      manifest[page.slug] = page.hash;\n      completed++;\n      if (completed % PROGRESS_LOG_INTERVAL === 0) {\n        console.warn(`  ${String(completed)}/${String(changedPages.length)} images generated...`);\n      }\n    }\n  }\n\n  await Promise.all(Array.from({ length: CONCURRENCY }, async () => {\n    await processNext();\n  }));\n}\n\nasync function loadCacheManifest(manifestPath: string): Promise<CacheManifest> {\n  return existsSync(manifestPath) ? (JSON.parse(await readFile(manifestPath, 'utf-8')) as CacheManifest) : {};\n}\n\nfunction parseFrontMatter(content: string): Partial<Record<string, unknown>> {\n  const frontMatter = FRONT_MATTER_REG_EXP.exec(content)?.groups?.['FrontMatter'];\n  return frontMatter === undefined ? {} : (parseYaml(frontMatter) as null | Partial<Record<string, unknown>>) ?? {};\n}\n\nasync function parsePage(filePath: string, contentDocsDirectory: string): Promise<null | PageEntry> {\n  const data = parseFrontMatter(await readFile(filePath, 'utf-8'));\n\n  const title = toOptionalString(data['title']);\n  if (!title) {\n    return null;\n  }\n\n  const badge = data['sidebar'] as Partial<Record<string, Partial<Record<string, unknown>>>> | undefined;\n  const params: OgCardContent = {\n    badge: toOptionalString(badge?.['badge']?.['text']),\n    description: toOptionalString(data['description']) ?? '',\n    signature: toOptionalString(data['signature']) ?? '',\n    title\n  };\n\n  return {\n    hash: computeOgHash(params),\n    params,\n    slug: getOgImagePageSlug(data, filePath, contentDocsDirectory)\n  };\n}\n\nfunction toOptionalString(value: unknown): string | undefined {\n  return typeof value === 'string' ? value : undefined;\n}\n\nasync function walkDirectory(directory: string, contentDocsDirectory: string, pages: PageEntry[]): Promise<void> {\n  const entries = await readdir(directory, { withFileTypes: true });\n  for (const entry of entries) {\n    const fullPath = `${directory}/${entry.name}`;\n    if (entry.isDirectory()) {\n      await walkDirectory(fullPath, contentDocsDirectory, pages);\n    } else if (entry.name.endsWith('.md') || entry.name.endsWith('.mdx')) {\n      const page = await parsePage(fullPath, contentDocsDirectory);\n      if (page) {\n        pages.push(page);\n      }\n    }\n  }\n}\n"],"mappings":"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","names":[]}

package/dist/lib/esm/docs-site/route-data.d.mts

@@ -0,0 +1,14 @@
+/// <reference path="../library-references.d.mts" />
+/**
+ * @file
+ *
+ * Adds per-page Open Graph and Twitter image metadata. `defineDocsSiteConfig` registers it as Starlight route
+ * middleware; the cards it points at are the ones `generateOgImages` writes.
+ */
+import type { APIContext } from 'astro';
+/**
+ * Adds Open Graph and Twitter image metadata to a Starlight documentation response.
+ *
+ * @param context - Astro's request context.
+ */
+export declare function onRequest(context: APIContext): void;

package/dist/lib/esm/docs-site/route-data.mjs

@@ -0,0 +1,23 @@
+/*
+THIS IS A GENERATED/BUNDLED FILE BY ESBUILD
+if you want to view the source, please visit the github repository of this plugin
+*/
+
+function onRequest(context) {
+  const { starlightRoute } = context.locals;
+  const { id } = starlightRoute;
+  const slug = id.replace(/\/index$/, "").replace(/\.\w+$/, "");
+  const base = starlightRoute.siteTitleHref.replace(/\/$/, "");
+  const origin = context.url.origin;
+  const ogImageUrl = `${origin}${base}/og/${slug || "index"}.png`;
+  starlightRoute.head.push(
+    { attrs: { content: ogImageUrl, property: "og:image" }, tag: "meta" },
+    { attrs: { content: "1200", property: "og:image:width" }, tag: "meta" },
+    { attrs: { content: "630", property: "og:image:height" }, tag: "meta" },
+    { attrs: { content: ogImageUrl, name: "twitter:image" }, tag: "meta" }
+  );
+}
+export {
+  onRequest
+};
+//# sourceMappingURL=data:application/json;base64,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

package/dist/lib/esm/docs-site/satteri-github-alerts.d.mts

@@ -0,0 +1,31 @@
+/// <reference path="../library-references.d.mts" />
+/**
+ * @file
+ *
+ * Sätteri mdast plugin that turns GitHub alerts (`> [!NOTE]` ...) into Starlight asides.
+ */
+import type { MdastPluginDefinition } from 'satteri';
+/**
+ * The Starlight aside variant each GitHub alert type renders as.
+ *
+ * Starlight has four variants for GitHub's five types, so `IMPORTANT` and `WARNING` share `caution`, and
+ * `CAUTION` - GitHub's most severe - takes `danger`. This is the mapping `starlight-github-alerts` uses.
+ */
+export declare const GITHUB_ALERT_ASIDE_VARIANTS: ReadonlyMap<string, string>;
+/**
+ * Sätteri mdast plugin that turns GitHub alerts into Starlight asides.
+ *
+ * The guides keep GitHub's `> [!TYPE]` syntax because it also renders on GitHub, where most people read
+ * the repository. The site used to rely on `starlight-github-alerts` for the conversion, and on
+ * Starlight `0.42` that plugin silently does nothing: it registers itself in front of an mdast plugin
+ * NAMED `starlight-asides`, while Starlight now registers its asides as an unnamed factory, so the lookup
+ * misses and the plugin returns without a word. Every alert then rendered as a plain blockquote opening
+ * with the literal `[!WARNING]`.
+ *
+ * This plugin does the same conversion from the site's own `mdastPlugins`, which run before every plugin
+ * Starlight appends: it replaces the blockquote with a `containerDirective` named after the aside variant,
+ * exactly what `:::caution` parses to, and Starlight's own asides plugin then renders it.
+ *
+ * @returns The plugin definition.
+ */
+export declare function satteriGitHubAlerts(): MdastPluginDefinition;