@cavuno/board 1.25.0 → 1.27.0

package/dist/sitemap.mjs

@@ -0,0 +1,330 @@
+// src/sitemap/xml.ts
+var SITEMAP_BUCKETS = [
+  "marketing",
+  "jobs-categories",
+  "jobs-skills",
+  "jobs-locations",
+  "jobs-details",
+  "companies",
+  "salaries",
+  "blog"
+];
+var SITEMAP_CHUNK_SIZE = 45e3;
+function xmlEscape(value) {
+  return value.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;").replaceAll('"', "&quot;").replaceAll("'", "&apos;");
+}
+function bucketFilename(bucket, chunkIndex = 0) {
+  const suffix = chunkIndex > 0 ? `-${chunkIndex + 1}` : "";
+  return `${bucket}${suffix}.xml`;
+}
+function parseBucketFilename(filename) {
+  if (!filename.endsWith(".xml")) return null;
+  const stem = filename.slice(0, -".xml".length);
+  const chunkMatch = stem.match(/^(.+?)-(\d+)$/);
+  if (chunkMatch) {
+    const candidate = chunkMatch[1];
+    const chunkNumber = Number.parseInt(chunkMatch[2] ?? "", 10);
+    if (SITEMAP_BUCKETS.includes(candidate) && Number.isFinite(chunkNumber) && chunkNumber >= 2) {
+      return { bucket: candidate, chunkIndex: chunkNumber - 1 };
+    }
+  }
+  if (SITEMAP_BUCKETS.includes(stem)) {
+    return { bucket: stem, chunkIndex: 0 };
+  }
+  return null;
+}
+function chunk(items, size) {
+  if (items.length === 0) return [];
+  if (items.length <= size) return [[...items]];
+  const out = [];
+  for (let i = 0; i < items.length; i += size) {
+    out.push(items.slice(i, i + size));
+  }
+  return out;
+}
+var XML_DECLARATION = '<?xml version="1.0" encoding="UTF-8"?>\n';
+var SITEMAP_NS = "http://www.sitemaps.org/schemas/sitemap/0.9";
+var IMAGE_NS = "http://www.google.com/schemas/sitemap-image/1.1";
+function lastmod(value) {
+  const serialized = value instanceof Date ? value.toISOString() : value;
+  return `<lastmod>${xmlEscape(serialized)}</lastmod>
+`;
+}
+function renderUrlset(entries) {
+  const normalized = entries.map(
+    (entry) => typeof entry === "string" ? { url: entry } : entry
+  );
+  const hasImages = normalized.some((entry) => (entry.images?.length ?? 0) > 0);
+  const namespaces = [`xmlns="${SITEMAP_NS}"`];
+  if (hasImages) {
+    namespaces.push(`xmlns:image="${IMAGE_NS}"`);
+  }
+  let xml = XML_DECLARATION + `<urlset ${namespaces.join(" ")}>
+`;
+  for (const entry of normalized) {
+    xml += "<url>\n";
+    xml += `<loc>${xmlEscape(entry.url)}</loc>
+`;
+    if (entry.images?.length) {
+      for (const image of entry.images) {
+        xml += `<image:image>
+<image:loc>${xmlEscape(image)}</image:loc>
+</image:image>
+`;
+      }
+    }
+    if (entry.lastModified) {
+      xml += lastmod(entry.lastModified);
+    }
+    xml += "</url>\n";
+  }
+  xml += "</urlset>\n";
+  return xml;
+}
+function renderSitemapIndex(entries) {
+  let xml = XML_DECLARATION + `<sitemapindex xmlns="${SITEMAP_NS}">
+`;
+  for (const raw of entries) {
+    const entry = typeof raw === "string" ? { url: raw } : raw;
+    xml += "<sitemap>\n";
+    xml += `<loc>${xmlEscape(entry.url)}</loc>
+`;
+    if (entry.lastModified) {
+      xml += lastmod(entry.lastModified);
+    }
+    xml += "</sitemap>\n";
+  }
+  xml += "</sitemapindex>\n";
+  return xml;
+}
+
+// src/pagination.ts
+function paginate(listFn, query, options) {
+  async function* pages() {
+    let current = query;
+    for (; ; ) {
+      const page = await listFn(current, options);
+      yield page;
+      if (!page.hasMore || page.nextCursor === null) return;
+      const { offset: _offset, ...rest } = current ?? {};
+      current = { ...rest, cursor: page.nextCursor };
+    }
+  }
+  return {
+    pages,
+    async *[Symbol.asyncIterator]() {
+      for await (const page of pages()) {
+        yield* page.data;
+      }
+    },
+    async toArray({ limit }) {
+      const items = [];
+      for await (const page of pages()) {
+        items.push(...page.data);
+        if (items.length >= limit) break;
+      }
+      return items.slice(0, limit);
+    }
+  };
+}
+
+// src/sitemap/walker.ts
+var MIN_JOBS_PER_INDEXED_PAGE = 5;
+var MAX_PAGES = 200;
+async function drainPages(pages) {
+  const acc = [];
+  let pageCount = 0;
+  for await (const page of pages) {
+    acc.push(...page.data);
+    pageCount += 1;
+    if (pageCount >= MAX_PAGES) {
+      if (page.hasMore) {
+        console.warn(
+          `[sitemap] hit the ${MAX_PAGES}-page pagination cap \u2014 output may be truncated`
+        );
+      }
+      break;
+    }
+  }
+  return acc;
+}
+var PAGE = 100;
+var OFFSET_CONCURRENCY = 8;
+var OFFSET_CEILING = 1e4;
+async function enumerateByOffset(fetchAt, fallback) {
+  const first = await fetchAt(0);
+  if (first.count === void 0) return fallback();
+  const all = [...first.data];
+  const ceiling = Math.min(first.count, OFFSET_CEILING);
+  const offsets = [];
+  for (let o = PAGE; o < ceiling; o += PAGE) offsets.push(o);
+  for (let i = 0; i < offsets.length; i += OFFSET_CONCURRENCY) {
+    const pages = await Promise.all(
+      offsets.slice(i, i + OFFSET_CONCURRENCY).map(fetchAt)
+    );
+    for (const page of pages) all.push(...page.data);
+  }
+  if (first.count > OFFSET_CEILING) {
+    console.warn(
+      `[sitemap] count ${first.count} exceeds the ${OFFSET_CEILING} offset ceiling \u2014 tail not enumerated (needs cursor/bulk support).`
+    );
+  }
+  return all;
+}
+function enumerateJobs(board) {
+  return enumerateByOffset(
+    (offset) => board.jobs.list({ limit: PAGE, offset }),
+    () => drainPages(paginate(board.jobs.list, { limit: PAGE }).pages())
+  );
+}
+function enumerateCompanies(board) {
+  return enumerateByOffset(
+    (offset) => board.companies.list({ limit: PAGE, offset }),
+    () => drainPages(paginate(board.companies.list, { limit: PAGE }).pages())
+  );
+}
+async function listedBuckets(board) {
+  const { features } = await board.context();
+  return SITEMAP_BUCKETS.filter((b) => b !== "blog" || features.blog);
+}
+async function buildBucketUrls(board, origin, bucket) {
+  switch (bucket) {
+    case "marketing":
+      return marketing(board, origin);
+    case "jobs-categories":
+      return jobsTaxonomy(board, origin, "categories");
+    case "jobs-skills":
+      return jobsTaxonomy(board, origin, "skills");
+    case "jobs-locations":
+      return jobsLocations(board, origin);
+    case "jobs-details":
+      return jobDetails(board, origin);
+    case "companies":
+      return companies(board, origin);
+    case "salaries":
+      return salaries(board, origin);
+    case "blog":
+      return blog(board, origin);
+  }
+}
+async function marketing(board, origin) {
+  const { features } = await board.context();
+  const urls = [
+    `${origin}/`,
+    `${origin}/jobs`,
+    `${origin}/about`,
+    `${origin}/privacy-policy`,
+    `${origin}/terms-of-service`,
+    `${origin}/cookie-policy`
+  ];
+  if (features.impressum) urls.push(`${origin}/impressum`);
+  if (features.talentDirectory) urls.push(`${origin}/talent`);
+  if (features.employers) urls.push(`${origin}/employers`);
+  return urls;
+}
+async function jobsTaxonomy(board, origin, kind) {
+  const jobs = await enumerateJobs(board);
+  const counts = /* @__PURE__ */ new Map();
+  for (const job of jobs) {
+    const slugs = new Set(
+      (kind === "categories" ? job.categories : job.skills).map((t) => t.slug)
+    );
+    for (const slug of slugs) counts.set(slug, (counts.get(slug) ?? 0) + 1);
+  }
+  const prefix = kind === "categories" ? `${origin}/jobs` : `${origin}/jobs/skills`;
+  return [...counts.entries()].filter(([, n]) => n >= MIN_JOBS_PER_INDEXED_PAGE).map(([slug]) => slug).sort().map((slug) => `${prefix}/${slug}`);
+}
+async function jobsLocations(board, origin) {
+  const { language } = await board.context();
+  const { data } = await board.salaries.locations.list({ locale: language });
+  return data.filter((l) => l.jobCount >= MIN_JOBS_PER_INDEXED_PAGE).map((l) => l.placeSlug).sort().map((slug) => `${origin}/jobs/locations/${slug}`);
+}
+async function jobDetails(board, origin) {
+  const jobs = await enumerateJobs(board);
+  const seen = /* @__PURE__ */ new Set();
+  for (const job of jobs) {
+    if (!job.company?.slug || !job.slug) continue;
+    seen.add(`${origin}/companies/${job.company.slug}/jobs/${job.slug}`);
+  }
+  return [...seen].sort();
+}
+async function companies(board, origin) {
+  const [list, markets] = await Promise.all([
+    enumerateCompanies(board),
+    board.companies.markets()
+  ]);
+  const urls = [`${origin}/companies`];
+  for (const company of list) urls.push(`${origin}/companies/${company.slug}`);
+  for (const market of markets.data) {
+    urls.push(`${origin}/companies/markets/${market.slug}`);
+  }
+  return urls;
+}
+async function salaries(board, origin) {
+  const { language } = await board.context();
+  const [salaryCompanies, titles, skills, locations] = await Promise.all([
+    board.salaries.companies.list(),
+    board.salaries.titles.list({ locale: language }),
+    board.salaries.skills.list({ locale: language }),
+    board.salaries.locations.list({ locale: language })
+  ]);
+  if (!salaryCompanies.data.length && !titles.data.length && !skills.data.length && !locations.data.length) {
+    return [];
+  }
+  const urls = [`${origin}/salaries`];
+  if (salaryCompanies.data.length) {
+    urls.push(`${origin}/salaries/companies`);
+    for (const c of salaryCompanies.data) {
+      urls.push(`${origin}/companies/${c.companySlug}/salaries`);
+    }
+  }
+  if (titles.data.length) {
+    urls.push(`${origin}/salaries/titles`);
+    for (const t of titles.data)
+      urls.push(`${origin}/salaries/titles/${t.slug}`);
+  }
+  if (skills.data.length) {
+    urls.push(`${origin}/salaries/skills`);
+    for (const s of skills.data)
+      urls.push(`${origin}/salaries/skills/${s.slug}`);
+  }
+  if (locations.data.length) {
+    urls.push(`${origin}/salaries/locations`);
+    for (const l of locations.data) {
+      urls.push(`${origin}/salaries/locations/${l.placeSlug}`);
+    }
+  }
+  return urls;
+}
+async function blog(board, origin) {
+  const posts = await drainPages(
+    paginate(board.blog.posts.list, { limit: 100 }).pages()
+  );
+  const urls = [`${origin}/blog`];
+  const tagSlugs = /* @__PURE__ */ new Set();
+  const authorSlugs = /* @__PURE__ */ new Set();
+  for (const post of posts) {
+    urls.push(`${origin}/blog/${post.slug}`);
+    for (const tag of post.tags) tagSlugs.add(tag.slug);
+    for (const author of post.authors) authorSlugs.add(author.slug);
+  }
+  for (const slug of [...tagSlugs].sort())
+    urls.push(`${origin}/blog/tag/${slug}`);
+  for (const slug of [...authorSlugs].sort()) {
+    urls.push(`${origin}/blog/author/${slug}`);
+  }
+  return urls;
+}
+export {
+  MIN_JOBS_PER_INDEXED_PAGE,
+  SITEMAP_BUCKETS,
+  SITEMAP_CHUNK_SIZE,
+  bucketFilename,
+  buildBucketUrls,
+  chunk,
+  listedBuckets,
+  parseBucketFilename,
+  renderSitemapIndex,
+  renderUrlset,
+  xmlEscape
+};

package/dist/theme.d.mts

@@ -0,0 +1,63 @@
+/**
+ * `@cavuno/board/theme` — board theme → shadcn CSS-variable overrides
+ * (ADR-0057).
+ *
+ * The board's stored theme (16 semantic colors × light/dark from
+ * `board.context().theme`) is mapped onto the canonical shadcn token
+ * vocabulary and emitted as overrides of the app's theme block. One
+ * contract, two consumers: the dashboard edits the board theme, and agents
+ * restyle through the standard shadcn theme file — both end up in the same
+ * tokens. The hosted board renders the same 16 source colors through its
+ * own token system; a coverage golden in-monorepo asserts neither side
+ * silently drops a color key.
+ *
+ * A null theme emits nothing — the app's static default theme applies
+ * untouched.
+ */
+/** The 16 board color keys (the wire ships them as an open record). */
+declare const BOARD_COLOR_KEYS: readonly ["brandColor", "buttonPrimary", "buttonPrimaryText", "buttonDanger", "background", "surfaceBackground", "mutedBackground", "highlightBackground", "text", "textSubtle", "textMuted", "textDisabled", "textError", "border", "contrastBackground", "contrastText"];
+type BoardColorKey = (typeof BOARD_COLOR_KEYS)[number];
+/**
+ * Structural input — satisfied by the SDK's `PublicBoardTheme` (whose color
+ * records are open on the wire) and any narrowed server copy.
+ */
+interface ThemeInput {
+    mode: string;
+    schemeId: string;
+    typography: {
+        fontSans: string;
+        fontHeading?: string | null;
+    };
+    colors: {
+        light?: Record<string, unknown>;
+        dark?: Record<string, unknown>;
+    };
+}
+/**
+ * Render the board theme as `:root` (+ `.dark`) CSS-variable overrides.
+ * Inject once at the app shell, after the static theme stylesheet.
+ *
+ * @example
+ * const css = boardThemeToCss((await board.context()).theme);
+ */
+declare function boardThemeToCss(theme: ThemeInput | null): string;
+/** The board's color-scheme preference; unknown/absent → `system`. */
+declare function themeMode(theme: ThemeInput | null): 'light' | 'dark' | 'system';
+/**
+ * Theme font key → Google Fonts family slug, transcribed from the hosted
+ * board's `theme-fonts-metadata.ts` (golden-tested against it). The wire's
+ * `typography.fontSans` is an internal KEY (`'source-sans-pro'`), and the
+ * Google family is not always a re-casing of it (`source-sans-pro` →
+ * `Source+Sans+3`) — never build a font request from the raw key.
+ */
+declare const THEME_FONT_GOOGLE_FAMILIES: Record<string, string>;
+/**
+ * The CSS `font-family` name the Google stylesheet registers for a font key
+ * — the name `--font-sans` must reference for the loaded font to apply
+ * (e.g. `'source-sans-pro'` → `"Source Sans 3"`).
+ */
+declare function themeFontFamily(fontKey: string): string;
+/** One Google Fonts request covering the sans + heading families. */
+declare function googleFontsUrl(theme: ThemeInput | null): string | null;
+
+export { BOARD_COLOR_KEYS, type BoardColorKey, THEME_FONT_GOOGLE_FAMILIES, type ThemeInput, boardThemeToCss, googleFontsUrl, themeFontFamily, themeMode };

package/dist/theme.d.ts

@@ -0,0 +1,63 @@
+/**
+ * `@cavuno/board/theme` — board theme → shadcn CSS-variable overrides
+ * (ADR-0057).
+ *
+ * The board's stored theme (16 semantic colors × light/dark from
+ * `board.context().theme`) is mapped onto the canonical shadcn token
+ * vocabulary and emitted as overrides of the app's theme block. One
+ * contract, two consumers: the dashboard edits the board theme, and agents
+ * restyle through the standard shadcn theme file — both end up in the same
+ * tokens. The hosted board renders the same 16 source colors through its
+ * own token system; a coverage golden in-monorepo asserts neither side
+ * silently drops a color key.
+ *
+ * A null theme emits nothing — the app's static default theme applies
+ * untouched.
+ */
+/** The 16 board color keys (the wire ships them as an open record). */
+declare const BOARD_COLOR_KEYS: readonly ["brandColor", "buttonPrimary", "buttonPrimaryText", "buttonDanger", "background", "surfaceBackground", "mutedBackground", "highlightBackground", "text", "textSubtle", "textMuted", "textDisabled", "textError", "border", "contrastBackground", "contrastText"];
+type BoardColorKey = (typeof BOARD_COLOR_KEYS)[number];
+/**
+ * Structural input — satisfied by the SDK's `PublicBoardTheme` (whose color
+ * records are open on the wire) and any narrowed server copy.
+ */
+interface ThemeInput {
+    mode: string;
+    schemeId: string;
+    typography: {
+        fontSans: string;
+        fontHeading?: string | null;
+    };
+    colors: {
+        light?: Record<string, unknown>;
+        dark?: Record<string, unknown>;
+    };
+}
+/**
+ * Render the board theme as `:root` (+ `.dark`) CSS-variable overrides.
+ * Inject once at the app shell, after the static theme stylesheet.
+ *
+ * @example
+ * const css = boardThemeToCss((await board.context()).theme);
+ */
+declare function boardThemeToCss(theme: ThemeInput | null): string;
+/** The board's color-scheme preference; unknown/absent → `system`. */
+declare function themeMode(theme: ThemeInput | null): 'light' | 'dark' | 'system';
+/**
+ * Theme font key → Google Fonts family slug, transcribed from the hosted
+ * board's `theme-fonts-metadata.ts` (golden-tested against it). The wire's
+ * `typography.fontSans` is an internal KEY (`'source-sans-pro'`), and the
+ * Google family is not always a re-casing of it (`source-sans-pro` →
+ * `Source+Sans+3`) — never build a font request from the raw key.
+ */
+declare const THEME_FONT_GOOGLE_FAMILIES: Record<string, string>;
+/**
+ * The CSS `font-family` name the Google stylesheet registers for a font key
+ * — the name `--font-sans` must reference for the loaded font to apply
+ * (e.g. `'source-sans-pro'` → `"Source Sans 3"`).
+ */
+declare function themeFontFamily(fontKey: string): string;
+/** One Google Fonts request covering the sans + heading families. */
+declare function googleFontsUrl(theme: ThemeInput | null): string | null;
+
+export { BOARD_COLOR_KEYS, type BoardColorKey, THEME_FONT_GOOGLE_FAMILIES, type ThemeInput, boardThemeToCss, googleFontsUrl, themeFontFamily, themeMode };

package/dist/theme.js

@@ -0,0 +1,149 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/theme/index.ts
+var theme_exports = {};
+__export(theme_exports, {
+  BOARD_COLOR_KEYS: () => BOARD_COLOR_KEYS,
+  THEME_FONT_GOOGLE_FAMILIES: () => THEME_FONT_GOOGLE_FAMILIES,
+  boardThemeToCss: () => boardThemeToCss,
+  googleFontsUrl: () => googleFontsUrl,
+  themeFontFamily: () => themeFontFamily,
+  themeMode: () => themeMode
+});
+module.exports = __toCommonJS(theme_exports);
+var BOARD_COLOR_KEYS = [
+  "brandColor",
+  "buttonPrimary",
+  "buttonPrimaryText",
+  "buttonDanger",
+  "background",
+  "surfaceBackground",
+  "mutedBackground",
+  "highlightBackground",
+  "text",
+  "textSubtle",
+  "textMuted",
+  "textDisabled",
+  "textError",
+  "border",
+  "contrastBackground",
+  "contrastText"
+];
+function color(colors, key) {
+  const value = colors[key];
+  return typeof value === "string" && value ? value : void 0;
+}
+function tokenLines(colors) {
+  const lines = [];
+  const set = (token, value) => {
+    if (value) lines.push(`  --${token}: ${value};`);
+  };
+  set("background", color(colors, "background"));
+  set("foreground", color(colors, "text"));
+  set("card", color(colors, "surfaceBackground"));
+  set("card-foreground", color(colors, "text"));
+  set("popover", color(colors, "surfaceBackground"));
+  set("popover-foreground", color(colors, "text"));
+  set("primary", color(colors, "buttonPrimary"));
+  set("primary-foreground", color(colors, "buttonPrimaryText"));
+  set("secondary", color(colors, "mutedBackground"));
+  set("secondary-foreground", color(colors, "text"));
+  set("muted", color(colors, "mutedBackground"));
+  set("muted-foreground", color(colors, "textMuted"));
+  set("accent", color(colors, "highlightBackground"));
+  set("accent-foreground", color(colors, "text"));
+  set(
+    "destructive",
+    color(colors, "buttonDanger") ?? color(colors, "textError")
+  );
+  set("border", color(colors, "border"));
+  set("input", color(colors, "border"));
+  set("ring", color(colors, "brandColor") ?? color(colors, "buttonPrimary"));
+  set("contrast-background", color(colors, "contrastBackground"));
+  set("contrast-foreground", color(colors, "contrastText"));
+  set("foreground-subtle", color(colors, "textSubtle"));
+  set("foreground-disabled", color(colors, "textDisabled"));
+  set("foreground-error", color(colors, "textError"));
+  return lines;
+}
+function boardThemeToCss(theme) {
+  if (!theme) return "";
+  const light = tokenLines(theme.colors.light ?? {});
+  const dark = tokenLines(theme.colors.dark ?? {});
+  const fontSans = theme.typography?.fontSans;
+  if (fontSans) {
+    light.push(
+      `  --font-sans: '${themeFontFamily(fontSans)}', ui-sans-serif, system-ui, sans-serif;`
+    );
+  }
+  const blocks = [];
+  if (light.length > 0) blocks.push(`:root {
+${light.join("\n")}
+}`);
+  if (dark.length > 0) blocks.push(`.dark {
+${dark.join("\n")}
+}`);
+  return blocks.join("\n\n");
+}
+function themeMode(theme) {
+  if (!theme) return "system";
+  return theme.mode === "light" || theme.mode === "dark" ? theme.mode : "system";
+}
+var THEME_FONT_GOOGLE_FAMILIES = {
+  "be-vietnam-pro": "Be+Vietnam+Pro",
+  inter: "Inter",
+  "plus-jakarta-sans": "Plus+Jakarta+Sans",
+  "dm-sans": "DM+Sans",
+  "public-sans": "Public+Sans",
+  figtree: "Figtree",
+  "work-sans": "Work+Sans",
+  "open-sans": "Open+Sans",
+  poppins: "Poppins",
+  hind: "Hind",
+  lexend: "Lexend",
+  "fira-sans": "Fira+Sans",
+  manrope: "Manrope",
+  "source-sans-pro": "Source+Sans+3",
+  outfit: "Outfit",
+  "space-grotesk": "Space+Grotesk",
+  geist: "Geist",
+  "source-serif-4": "Source+Serif+4",
+  lora: "Lora",
+  "crimson-pro": "Crimson+Pro"
+};
+function googleFamily(fontKey) {
+  return THEME_FONT_GOOGLE_FAMILIES[fontKey] ?? encodeURIComponent(fontKey).replaceAll("%20", "+");
+}
+function themeFontFamily(fontKey) {
+  return googleFamily(fontKey).replaceAll("+", " ");
+}
+function googleFontsUrl(theme) {
+  if (!theme) return null;
+  const families = /* @__PURE__ */ new Set();
+  if (theme.typography?.fontSans) {
+    families.add(googleFamily(theme.typography.fontSans));
+  }
+  if (theme.typography?.fontHeading) {
+    families.add(googleFamily(theme.typography.fontHeading));
+  }
+  if (families.size === 0) return null;
+  const params = [...families].map((f) => `family=${f}:wght@400;500;600;700`).join("&");
+  return `https://fonts.googleapis.com/css2?${params}&display=swap`;
+}