hyperframes 0.8.127 → 0.8.128

package/dist/{chunk-32MY4AZN.js → chunk-WPHMNO44.js}

@@ -4,6 +4,20 @@ import { dirname as __hf_dirname } from "node:path";
 var require = __hf_createRequire(import.meta.url);
 var __filename = __hf_fileURLToPath(import.meta.url);
 var __dirname = __hf_dirname(__filename);
+import {
+  SYSTEM_FONT_SIZE_LIMIT,
+  locateSystemFontVariants
+} from "./chunk-TJSTGSAW.js";
+import {
+  EMBEDDED_FONT_DATA
+} from "./chunk-FI4I7CME.js";
+import {
+  FONT_ALIAS_MAP,
+  resolveAliasDisplayName
+} from "./chunk-AVUUN2XD.js";
+import {
+  parseHTML
+} from "./chunk-GK4AIFIH.js";
 import {
   __commonJS,
   __require,
@@ -3116,18 +3130,17 @@ var require_wawoff2 = __commonJS({
   }
 });
 
-// ../producer/src/services/fontCompression.ts
+// ../core/dist/fonts/deterministicFonts.js
+import { createHash as createHash2 } from "crypto";
+import { existsSync as existsSync2, mkdirSync as mkdirSync2, mkdtempSync as mkdtempSync2, readFileSync as readFileSync2, writeFileSync as writeFileSync2 } from "fs";
+import { homedir as homedir2, tmpdir as tmpdir2 } from "os";
+import { join as join2 } from "path";
+import postcss2 from "postcss";
+
+// ../core/dist/fonts/fontCompression.js
 var import_wawoff2 = __toESM(require_wawoff2(), 1);
 import { createHash } from "crypto";
-import {
-  existsSync,
-  mkdirSync,
-  mkdtempSync,
-  readFileSync,
-  renameSync,
-  rmSync,
-  writeFileSync
-} from "fs";
+import { existsSync, mkdirSync, mkdtempSync, readFileSync, renameSync, rmSync, writeFileSync } from "fs";
 import { homedir, tmpdir } from "os";
 import { dirname, join } from "path";
 var { compress } = import_wawoff2.default;
@@ -3151,7 +3164,8 @@ function cachedCompressionPath(input, originalFormat, cacheDir) {
 }
 function readCachedCompression(path) {
   try {
-    if (!existsSync(path)) return null;
+    if (!existsSync(path))
+      return null;
     const cached = readFileSync(path);
     return cached.length > 0 ? cached : null;
   } catch {
@@ -3169,7 +3183,8 @@ function cacheCompression(path, compressed) {
   } catch {
   } finally {
     try {
-      if (tempDir) rmSync(tempDir, { recursive: true, force: true });
+      if (tempDir)
+        rmSync(tempDir, { recursive: true, force: true });
     } catch {
     }
   }
@@ -3182,25 +3197,1332 @@ async function fontToDataUri(input, originalFormat, options = {}) {
     return `data:font/collection;base64,${input.toString("base64")}`;
   }
   try {
-    const cachePath = cachedCompressionPath(
-      input,
-      originalFormat,
-      options.cacheDir ?? defaultCacheDir()
-    );
+    const cachePath = cachedCompressionPath(input, originalFormat, options.cacheDir ?? defaultCacheDir());
     const cached = readCachedCompression(cachePath);
-    if (cached) return `data:font/woff2;base64,${cached.toString("base64")}`;
+    if (cached)
+      return `data:font/woff2;base64,${cached.toString("base64")}`;
     const compressed = await (options.compressImpl ?? compressToWoff2)(input);
     cacheCompression(cachePath, compressed);
     return `data:font/woff2;base64,${compressed.toString("base64")}`;
   } catch {
-    console.warn(
-      `[fontCompression] woff2 compression failed for ${originalFormat} font, embedding raw format`
-    );
+    console.warn(`[fontCompression] woff2 compression failed for ${originalFormat} font, embedding raw format`);
     return `data:${rawMimeType(originalFormat)};base64,${input.toString("base64")}`;
   }
 }
 
+// ../core/dist/fonts/authoredGoogleFonts.js
+import postcss from "postcss";
+function screenStylesheet(media) {
+  return !media?.trim() || media.split(",").some((query) => /^(all|screen)$/i.test(query.trim()));
+}
+function googleStylesheetFamilies(urlText) {
+  let parsed;
+  try {
+    parsed = new URL(urlText);
+  } catch {
+    return [];
+  }
+  if (parsed.protocol !== "https:" || parsed.hostname !== "fonts.googleapis.com")
+    return [];
+  return parsed.searchParams.getAll("family").flatMap((family) => family.split("|")).map((family) => family.split(":")[0]?.trim().toLowerCase() ?? "").filter(Boolean);
+}
+function importUrls(css) {
+  let root;
+  try {
+    root = postcss.parse(css);
+  } catch {
+    return [];
+  }
+  const urls = [];
+  for (const node of root.nodes) {
+    if (node.type !== "atrule" || node.name.toLowerCase() !== "import")
+      continue;
+    const url = unconditionalImportUrl(node.params);
+    if (url)
+      urls.push(url);
+  }
+  return urls;
+}
+function unconditionalImportUrl(params) {
+  const match = /^(?:url\(\s*['"]?([^'")\s]+)['"]?\s*\)|['"]([^'"]+)['"])\s*(.*)$/i.exec(params);
+  if (!match || !screenStylesheet(match[3] ?? null))
+    return void 0;
+  return match[1] ?? match[2];
+}
+function activeStylesheet(element) {
+  if (element.hasAttribute("disabled") || !screenStylesheet(element.getAttribute("media")))
+    return false;
+  const type = element.getAttribute("type")?.trim().toLowerCase();
+  return !type || type === "text/css";
+}
+function stylesheetUrls(element) {
+  if (!activeStylesheet(element))
+    return [];
+  if (element.localName !== "link")
+    return importUrls(element.textContent ?? "");
+  const rel = (element.getAttribute("rel") ?? "").toLowerCase().split(/\s+/);
+  if (!rel.includes("stylesheet") || rel.includes("alternate"))
+    return [];
+  const href = element.getAttribute("href");
+  return href ? [href] : [];
+}
+function authoredGoogleFontStylesheets(html) {
+  const byFamily = /* @__PURE__ */ new Map();
+  const { document: document2 } = parseHTML(html);
+  for (const element of document2.querySelectorAll("link, style")) {
+    for (const url of stylesheetUrls(element)) {
+      for (const family of googleStylesheetFamilies(url)) {
+        const previous = byFamily.get(family) ?? [];
+        byFamily.set(family, [...previous.filter((existing) => existing !== url), url]);
+      }
+    }
+  }
+  return byFamily;
+}
+function withPageText(url, fontText) {
+  const parsed = new URL(url);
+  if (!fontText || parsed.searchParams.has("text"))
+    return url;
+  const withoutFragment = url.split("#")[0] ?? url;
+  const joiner = parsed.search ? "&" : "?";
+  return `${withoutFragment}${joiner}text=${encodeURIComponent(fontText)}${parsed.hash}`;
+}
+
+// ../core/dist/fonts/deterministicFonts.js
+var GENERIC_FAMILIES = /* @__PURE__ */ new Set([
+  "sans-serif",
+  "serif",
+  "monospace",
+  "cursive",
+  "fantasy",
+  "system-ui",
+  "ui-sans-serif",
+  "ui-serif",
+  "ui-monospace",
+  "emoji",
+  "math",
+  "fangsong",
+  "-apple-system",
+  "blinkmacsystemfont"
+]);
+var CSS_WIDE_KEYWORDS = /* @__PURE__ */ new Set([
+  "inherit",
+  "initial",
+  "unset",
+  "revert",
+  "revert-layer"
+]);
+function parseFontFamilyValue(value) {
+  const pieces = [];
+  let start = 0;
+  let depth = 0;
+  let quote = null;
+  for (let index = 0; index < value.length; index += 1) {
+    const char = value[index];
+    if (char === "\\") {
+      index += 1;
+      continue;
+    }
+    if (quote) {
+      if (char === quote)
+        quote = null;
+      continue;
+    }
+    if (char === "'" || char === '"') {
+      quote = char;
+      continue;
+    }
+    if (char === "(") {
+      depth += 1;
+      continue;
+    }
+    if (char === ")") {
+      depth = Math.max(0, depth - 1);
+      continue;
+    }
+    if (char !== "," || depth !== 0)
+      continue;
+    pieces.push(value.slice(start, index));
+    start = index + 1;
+  }
+  pieces.push(value.slice(start));
+  return pieces.map((piece) => piece.trim().replace(/^['"]/, "").replace(/['"]$/, "").trim()).filter((piece) => piece.length > 0);
+}
+function systemPrimaryReplacement(value, deterministicPrimary, customProperties) {
+  const variable = primaryCssVariable(value);
+  if (variable) {
+    if (customProperties.get(variable.name) || variable.fallback === null)
+      return null;
+    const fallback = systemPrimaryReplacement(variable.fallback, deterministicPrimary, customProperties);
+    return fallback ? `var(${variable.name}, ${fallback})${variable.rest}` : null;
+  }
+  const families = parseFontFamilyValue(value);
+  if (families.length === 0)
+    return null;
+  if (!GENERIC_FAMILIES.has(normalizeFamilyName(families[0])))
+    return null;
+  return `${deterministicPrimary}, ${value.trim()}`;
+}
+function parseCssRoot(css) {
+  try {
+    return postcss2.parse(css);
+  } catch {
+    return null;
+  }
+}
+function isFontFaceDeclaration(decl) {
+  const parent = decl.parent;
+  return parent?.type === "atrule" && parent.name.toLowerCase() === "font-face";
+}
+function normalizeCssDeclarations(root, replacePrimary) {
+  let changed = false;
+  root.walkDecls((decl) => {
+    if (decl.prop.startsWith("--")) {
+      const replacement2 = replacePrimary(decl.value);
+      if (!replacement2)
+        return;
+      decl.value = replacement2;
+      changed = true;
+      return;
+    }
+    if (decl.prop.toLowerCase() !== "font-family")
+      return;
+    if (isFontFaceDeclaration(decl)) {
+      return;
+    }
+    const replacement = replacePrimary(decl.value);
+    if (!replacement)
+      return;
+    decl.value = replacement;
+    changed = true;
+  });
+  return changed;
+}
+function normalizeCssFontFamilyDeclarations(css, replacePrimary) {
+  const root = parseCssRoot(css);
+  if (!root)
+    return css;
+  const changed = normalizeCssDeclarations(root, replacePrimary);
+  return changed ? root.toString() : css;
+}
+function normalizeInlineStyleAttribute(style, replacePrimary) {
+  const root = parseCssRoot(`*{${style}}`);
+  if (!root)
+    return style;
+  const rule = root.first;
+  if (rule?.type !== "rule")
+    return style;
+  const before = rule.toString();
+  normalizeCssDeclarations(root, replacePrimary);
+  if (rule.toString() === before)
+    return style;
+  const serialized = (rule.nodes ?? []).map((node) => node.toString()).join("; ");
+  return serialized.endsWith(";") ? serialized : `${serialized};`;
+}
+function normalizeSystemFontPrimaryFamilies(html, deterministicPrimary = "Inter") {
+  const { document: document2 } = parseHTML(html);
+  const customProperties = collectFontFamilyCustomProperties(html);
+  const replacePrimary = (value) => systemPrimaryReplacement(value, deterministicPrimary, customProperties);
+  let changed = false;
+  for (const styleEl of Array.from(document2.querySelectorAll("style"))) {
+    const current = styleEl.textContent ?? "";
+    const next = normalizeCssFontFamilyDeclarations(current, replacePrimary);
+    if (next === current)
+      continue;
+    styleEl.textContent = next;
+    changed = true;
+  }
+  for (const el of Array.from(document2.querySelectorAll("[style]"))) {
+    const current = el.getAttribute("style") ?? "";
+    const next = normalizeInlineStyleAttribute(current, replacePrimary);
+    if (next === current)
+      continue;
+    el.setAttribute("style", next);
+    changed = true;
+  }
+  for (const el of Array.from(document2.querySelectorAll("[data-font-family]"))) {
+    const current = el.getAttribute("data-font-family") ?? "";
+    const next = replacePrimary(current);
+    if (!next)
+      continue;
+    el.setAttribute("data-font-family", next);
+    changed = true;
+  }
+  return changed ? document2.toString() : html;
+}
+function collectCssCustomProperties(css, customProperties) {
+  const root = parseCssRoot(css);
+  if (!root)
+    return;
+  root.walkDecls((decl) => {
+    if (!decl.prop.startsWith("--"))
+      return;
+    customProperties.set(decl.prop, decl.value);
+  });
+}
+function* iterateCssRootFontFamilyDeclarations(root) {
+  const declarations = [];
+  root.walkDecls((decl) => {
+    if (decl.prop.toLowerCase() !== "font-family")
+      return;
+    if (isFontFaceDeclaration(decl))
+      return;
+    const declaration = decl.value;
+    declarations.push({
+      surface: "font-family",
+      declaration,
+      families: parseFontFamilyValue(declaration)
+    });
+  });
+  yield* declarations;
+}
+function* iterateCssFontFamilyDeclarations(css) {
+  const root = parseCssRoot(css);
+  if (!root)
+    return;
+  yield* iterateCssRootFontFamilyDeclarations(root);
+}
+function* iterateInlineStyleFontFamilyDeclarations(style) {
+  const root = parseCssRoot(`*{${style}}`);
+  if (!root)
+    return;
+  yield* iterateCssRootFontFamilyDeclarations(root);
+}
+function collectFontFamilyCustomProperties(html) {
+  const { document: document2 } = parseHTML(html);
+  const customProperties = /* @__PURE__ */ new Map();
+  for (const styleEl of Array.from(document2.querySelectorAll("style"))) {
+    collectCssCustomProperties(styleEl.textContent ?? "", customProperties);
+  }
+  for (const el of Array.from(document2.querySelectorAll("[style]"))) {
+    collectCssCustomProperties(`*{${el.getAttribute("style") ?? ""}}`, customProperties);
+  }
+  return customProperties;
+}
+function primaryCssVariable(value) {
+  const trimmed = value.trim();
+  if (!trimmed.toLowerCase().startsWith("var("))
+    return null;
+  let depth = 0;
+  for (let index = 0; index < trimmed.length; index += 1) {
+    const char = trimmed[index];
+    if (char === "(") {
+      depth += 1;
+      continue;
+    }
+    if (char !== ")")
+      continue;
+    depth -= 1;
+    if (depth !== 0)
+      continue;
+    const inner = trimmed.slice(4, index).trim();
+    const commaIndex = inner.indexOf(",");
+    const name = (commaIndex === -1 ? inner : inner.slice(0, commaIndex)).trim();
+    if (!/^--[A-Za-z0-9_-]+$/.test(name))
+      return null;
+    return {
+      name,
+      fallback: commaIndex === -1 ? null : inner.slice(commaIndex + 1),
+      rest: trimmed.slice(index + 1)
+    };
+  }
+  return null;
+}
+var MAX_CSS_VARIABLE_DEPTH = 8;
+function resolveDeclaredFamilies(declaration, customProperties, optional = false, depth = 0) {
+  const tag = (families2) => families2.map((family) => ({ family, optional }));
+  const families = parseFontFamilyValue(declaration);
+  const variable = depth < MAX_CSS_VARIABLE_DEPTH ? primaryCssVariable(declaration) : null;
+  if (!variable)
+    return tag(families);
+  const resolved = customProperties.get(variable.name);
+  const source = resolved || variable.fallback;
+  if (source === null)
+    return tag(families);
+  const primary = resolveDeclaredFamilies(source, customProperties, !resolved || depth > 0, depth + 1);
+  if (primary.length === 0)
+    return [];
+  return [...primary, ...tag(families.slice(1))];
+}
+function resolveFontFamilyDeclarationFamilies(declaration, customProperties) {
+  return resolveDeclaredFamilies(declaration, customProperties).map(({ family }) => family);
+}
+function* iterateFontFamilyDeclarations(html) {
+  const { document: document2 } = parseHTML(html);
+  for (const styleEl of Array.from(document2.querySelectorAll("style"))) {
+    yield* iterateCssFontFamilyDeclarations(styleEl.textContent ?? "");
+  }
+  for (const el of Array.from(document2.querySelectorAll("[style]"))) {
+    yield* iterateInlineStyleFontFamilyDeclarations(el.getAttribute("style") ?? "");
+  }
+  for (const el of Array.from(document2.querySelectorAll("[data-font-family]"))) {
+    const declaration = el.getAttribute("data-font-family") ?? "";
+    yield { surface: "data-font-family", declaration, families: parseFontFamilyValue(declaration) };
+  }
+}
+var CANONICAL_FONTS = {
+  inter: {
+    packageName: "@fontsource/inter",
+    faces: [{ weight: "400" }, { weight: "700" }, { weight: "900" }]
+  },
+  montserrat: {
+    packageName: "@fontsource/montserrat",
+    faces: [{ weight: "400" }, { weight: "700" }, { weight: "900" }]
+  },
+  outfit: {
+    packageName: "@fontsource/outfit",
+    faces: [{ weight: "400" }, { weight: "700" }, { weight: "900" }]
+  },
+  nunito: {
+    packageName: "@fontsource/nunito",
+    faces: [{ weight: "400" }, { weight: "700" }, { weight: "900" }]
+  },
+  oswald: {
+    packageName: "@fontsource/oswald",
+    faces: [{ weight: "400" }, { weight: "700" }]
+  },
+  "league-gothic": {
+    packageName: "@fontsource/league-gothic",
+    faces: [{ weight: "400" }]
+  },
+  "archivo-black": {
+    packageName: "@fontsource/archivo-black",
+    faces: [{ weight: "400" }]
+  },
+  "space-mono": {
+    packageName: "@fontsource/space-mono",
+    faces: [{ weight: "400" }, { weight: "700" }]
+  },
+  "ibm-plex-mono": {
+    packageName: "@fontsource/ibm-plex-mono",
+    faces: [{ weight: "400" }, { weight: "700" }]
+  },
+  "jetbrains-mono": {
+    packageName: "@fontsource/jetbrains-mono",
+    faces: [{ weight: "400" }, { weight: "700" }]
+  },
+  "eb-garamond": {
+    packageName: "@fontsource/eb-garamond",
+    faces: [{ weight: "400" }, { weight: "700" }]
+  },
+  "playfair-display": {
+    packageName: "@fontsource/playfair-display",
+    faces: [{ weight: "400" }, { weight: "700" }, { weight: "900" }]
+  },
+  "source-code-pro": {
+    packageName: "@fontsource/source-code-pro",
+    faces: [{ weight: "400" }, { weight: "700" }]
+  },
+  "noto-sans-jp": {
+    packageName: "@fontsource/noto-sans-jp",
+    faces: [{ weight: "400" }, { weight: "700" }]
+  },
+  roboto: {
+    packageName: "@fontsource/roboto",
+    faces: [{ weight: "400" }, { weight: "700" }, { weight: "900" }]
+  },
+  "open-sans": {
+    packageName: "@fontsource/open-sans",
+    faces: [{ weight: "400" }, { weight: "700" }]
+  },
+  lato: {
+    packageName: "@fontsource/lato",
+    faces: [{ weight: "400" }, { weight: "700" }, { weight: "900" }]
+  },
+  poppins: {
+    packageName: "@fontsource/poppins",
+    faces: [{ weight: "400" }, { weight: "700" }, { weight: "900" }]
+  }
+};
+var FONT_ALIASES = FONT_ALIAS_MAP;
+function normalizeFamilyName(family) {
+  return family.trim().replace(/^['"]|['"]$/g, "").trim().toLowerCase();
+}
+function fontDataUri(packageName, weight, style = "normal") {
+  const key = `${packageName}:${weight}:${style}`;
+  const uri = EMBEDDED_FONT_DATA.get(key);
+  if (!uri) {
+    throw new Error(`No embedded font data for ${key}. Regenerate with: tsx scripts/generate-font-data.ts`);
+  }
+  return uri;
+}
+function extractExistingFontFaces(html) {
+  const families = /* @__PURE__ */ new Set();
+  const opening = /@font-face\s*\{/gi;
+  const family = /font-family\s*:/gi;
+  while (opening.exec(html)) {
+    family.lastIndex = opening.lastIndex;
+    let declaration = family.exec(html);
+    while (declaration && html[family.lastIndex] === ";") {
+      declaration = family.exec(html);
+    }
+    if (!declaration)
+      break;
+    const valueStart = family.lastIndex;
+    const semicolon = html.indexOf(";", valueStart);
+    if (semicolon < 0)
+      break;
+    const end = html.indexOf("}", semicolon + 1);
+    if (end < 0)
+      break;
+    const normalized = normalizeFamilyName(html.slice(valueStart, semicolon));
+    if (normalized)
+      families.add(normalized);
+    opening.lastIndex = end + 1;
+  }
+  return families;
+}
+function isFetchableFamilyName(normalized) {
+  if (!normalized || normalized.startsWith("var("))
+    return false;
+  return !GENERIC_FAMILIES.has(normalized) && !CSS_WIDE_KEYWORDS.has(normalized);
+}
+function extractRequestedFontFamilies(html) {
+  const requested = /* @__PURE__ */ new Map();
+  const customProperties = collectFontFamilyCustomProperties(html);
+  for (const { declaration } of iterateFontFamilyDeclarations(html)) {
+    for (const { family, optional } of resolveDeclaredFamilies(declaration, customProperties)) {
+      const normalized = family.toLowerCase();
+      if (!isFetchableFamilyName(normalized))
+        continue;
+      const seen = requested.get(normalized);
+      requested.set(normalized, {
+        family: seen?.family ?? family,
+        optional: (seen?.optional ?? true) && optional
+      });
+    }
+  }
+  return requested;
+}
+function fontFormatHint(src) {
+  return src.startsWith("data:font/collection;") ? "collection" : "woff2";
+}
+var BUNDLED_SUBSET_UNICODE_RANGE = "U+0000-00FF, U+0131, U+0152-0153, U+02BB-02BC, U+02C6, U+02DA, U+02DC, U+0304, U+0308, U+0329, U+2000-206F, U+2074, U+20AC, U+2122, U+2191, U+2193, U+2212, U+2215, U+FEFF, U+FFFD";
+function isBundledSubsetRange(unicodeRange) {
+  const normalize = (range) => range.toLowerCase().replace(/\s+/g, "");
+  return unicodeRange !== void 0 && normalize(unicodeRange) === normalize(BUNDLED_SUBSET_UNICODE_RANGE);
+}
+function buildFontFaceRule(familyName, src, weight, style, unicodeRange) {
+  return [
+    "@font-face {",
+    `  font-family: "${familyName}";`,
+    `  src: url("${src}") format("${fontFormatHint(src)}");`,
+    `  font-style: ${style};`,
+    `  font-weight: ${weight};`,
+    "  font-display: block;",
+    // Preserve the subset's unicode-range so the browser selects the right
+    // per-codepoint subset (matching Google Fonts' own CSS semantics).
+    ...unicodeRange ? [`  unicode-range: ${unicodeRange};`] : [],
+    "}"
+  ].join("\n");
+}
+function normalizeWeightKey(weight) {
+  const numeric = Number(weight);
+  return Number.isFinite(numeric) ? String(numeric) : weight.trim().toLowerCase();
+}
+function coverageKey(weight, style) {
+  return `${normalizeWeightKey(weight)}:${style}`;
+}
+function groupFacesBySource(faces) {
+  const groups = /* @__PURE__ */ new Map();
+  for (const face of faces) {
+    const key = [face.dataUri, face.style, face.unicodeRange ?? ""].join("\0");
+    const existing = groups.get(key);
+    if (existing)
+      existing.push(face);
+    else
+      groups.set(key, [face]);
+  }
+  return [...groups.values()];
+}
+function spansCoveredWeight(from, to, coveredWeights) {
+  const start = Number(from.weight);
+  const end = Number(to.weight);
+  if (!Number.isFinite(start) || !Number.isFinite(end))
+    return true;
+  const low = Math.min(start, end);
+  const high = Math.max(start, end);
+  for (const covered of coveredWeights) {
+    const [weight, style] = covered.split(":");
+    if (style !== from.style)
+      continue;
+    const value = Number(weight);
+    if (Number.isFinite(value) && value > low && value < high)
+      return true;
+  }
+  return false;
+}
+function partitionWeightRuns(faces, coveredWeights) {
+  const runs = [];
+  const sortable = faces.filter((face) => Number.isFinite(Number(face.weight)));
+  const unsortable = faces.filter((face) => !Number.isFinite(Number(face.weight)));
+  let current = [];
+  for (const face of [...sortable].sort((a, b) => Number(a.weight) - Number(b.weight))) {
+    const previous = current[current.length - 1];
+    if (previous && spansCoveredWeight(previous, face, coveredWeights)) {
+      runs.push(current);
+      current = [];
+    }
+    current.push(face);
+  }
+  if (current.length > 0)
+    runs.push(current);
+  for (const face of unsortable)
+    runs.push([face]);
+  return runs;
+}
+async function bundledFamilyFaceRules(canonical, normalizedFamily, emitFamily, optional, options, fontText) {
+  const rules = [];
+  const coveredWeights = /* @__PURE__ */ new Set();
+  const bundledRules = [];
+  for (const face of canonical.faces) {
+    const style = face.style || "normal";
+    const src = fontDataUri(canonical.packageName, face.weight, style);
+    bundledRules.push(buildFontFaceRule(emitFamily, src, face.weight, style, BUNDLED_SUBSET_UNICODE_RANGE));
+    coveredWeights.add(coverageKey(face.weight, style));
+  }
+  const canonicalFamily = resolveAliasDisplayName(normalizedFamily);
+  const googleFaces = canonicalFamily ? await fetchFamilyFaces(canonicalFamily, optional, options, fontText) : [];
+  const supplementary = googleFaces.filter((face) => !coveredWeights.has(coverageKey(face.weight, face.style)) || !isBundledSubsetRange(face.unicodeRange));
+  const runs = groupFacesBySource(supplementary).flatMap((group) => partitionWeightRuns(group, coveredWeights));
+  const firstAppearance = (run) => Math.min(...run.map((face) => supplementary.indexOf(face)));
+  for (const run of [...runs].sort((a, b) => firstAppearance(a) - firstAppearance(b))) {
+    const first = run[0];
+    const last = run[run.length - 1];
+    if (!first || !last)
+      continue;
+    const weight = run.length > 1 ? `${first.weight} ${last.weight}` : first.weight;
+    rules.push(buildFontFaceRule(emitFamily, first.dataUri, weight, first.style, first.unicodeRange));
+  }
+  rules.push(...bundledRules);
+  return rules;
+}
+async function googleFamilyFaceRules(lookupFamily, emitFamily, optional, options, fontText) {
+  const googleFaces = await fetchFamilyFaces(lookupFamily, optional, options, fontText);
+  if (googleFaces.length === 0)
+    return null;
+  return googleFaces.map((face) => buildFontFaceRule(emitFamily, face.dataUri, face.weight, face.style, face.unicodeRange));
+}
+async function systemFamilyFaceRules(lookupFamily, emitFamily, log) {
+  const variants = locateSystemFontVariants(lookupFamily);
+  if (variants.length === 0)
+    return null;
+  const rules = [];
+  let totalBytes = 0;
+  for (const variant of variants) {
+    const fontBuffer = readFileSync2(variant.path);
+    totalBytes += fontBuffer.length;
+    const dataUri = await fontToDataUri(fontBuffer, variant.format);
+    rules.push(buildFontFaceRule(emitFamily, dataUri, variant.weight, variant.style));
+  }
+  if (totalBytes > SYSTEM_FONT_SIZE_LIMIT) {
+    log.warn(`[Compiler] System font "${lookupFamily}" is large (${(totalBytes / 1024 / 1024).toFixed(1)} MB total across ${variants.length} variant(s)) \u2014 embedding anyway. Consider font subsetting for production.`);
+  }
+  log.info(`[Compiler] Embedded system font "${lookupFamily}" \u2014 ${variants.length} variant(s), ${(totalBytes / 1024).toFixed(0)} KB total`);
+  return rules;
+}
+async function resolveFamilyFaceRules(normalizedFamily, lookupFamily, emitFamily, optional, options, fontText) {
+  const canonicalKey = FONT_ALIASES[normalizedFamily];
+  if (canonicalKey) {
+    const canonical = CANONICAL_FONTS[canonicalKey];
+    if (!canonical)
+      return [];
+    return bundledFamilyFaceRules(canonical, normalizedFamily, emitFamily, optional, options, fontText);
+  }
+  return await googleFamilyFaceRules(lookupFamily, emitFamily, optional, options, fontText) ?? (options.allowSystemFontCapture && !pageNamedThisFile(lookupFamily, options) ? await systemFamilyFaceRules(lookupFamily, emitFamily, options.log) : null);
+}
+function googleFontsUrlFamilies(rawUrl) {
+  let url;
+  try {
+    url = new URL(rawUrl.trim(), "https://document.invalid/");
+  } catch {
+    return [];
+  }
+  if (url.hostname !== "fonts.googleapis.com")
+    return [];
+  if (url.pathname !== "/css" && url.pathname !== "/css2")
+    return [];
+  return url.searchParams.getAll("family").flatMap((value) => value.split("|")).map((entry) => (entry.split(":", 1)[0] ?? "").trim()).filter((family) => family.length > 0);
+}
+function importRuleUrl(params) {
+  const trimmed = params.trim();
+  if (trimmed.toLowerCase().startsWith("url(")) {
+    const close = trimmed.indexOf(")");
+    if (close < 0 || !isUnconditionalMedia(trimmed.slice(close + 1)))
+      return null;
+    return trimmed.slice(4, close).trim().replace(/^['"]/, "").replace(/['"]$/, "");
+  }
+  const quote = trimmed[0];
+  if (quote !== '"' && quote !== "'")
+    return null;
+  const end = trimmed.indexOf(quote, 1);
+  return end > 0 && isUnconditionalMedia(trimmed.slice(end + 1)) ? trimmed.slice(1, end) : null;
+}
+function fontFaceRuleFamily(rule) {
+  let family;
+  rule.walkDecls((decl) => {
+    if (decl.prop.toLowerCase() === "font-family")
+      family = parseFontFamilyValue(decl.value)[0];
+  });
+  return family;
+}
+function isUnconditionalMedia(media) {
+  const normalized = (media ?? "").trim().toLowerCase();
+  return normalized === "" || normalized === "all";
+}
+function isUnconditionalStylesheet(element) {
+  const type = (element.getAttribute("type") ?? "").trim().toLowerCase();
+  return isUnconditionalMedia(element.getAttribute("media")) && (type === "" || type === "text/css") && !(element.getAttribute("title") ?? "").trim() && !element.hasAttribute("disabled");
+}
+function declareStyleFontFamilies(styleEl, register) {
+  if (!isUnconditionalStylesheet(styleEl))
+    return;
+  const root = parseCssRoot(styleEl.textContent ?? "");
+  if (!root)
+    return;
+  root.walkAtRules((atRule) => {
+    if (atRule.parent?.type !== "root")
+      return;
+    const name = atRule.name.toLowerCase();
+    if (name === "import") {
+      const url = importRuleUrl(atRule.params);
+      if (url)
+        for (const family2 of googleFontsUrlFamilies(url))
+          register(family2);
+      return;
+    }
+    if (name !== "font-face")
+      return;
+    const family = fontFaceRuleFamily(atRule);
+    if (family)
+      register(family, atRule);
+  });
+}
+function declareLinkedFontFamilies(link, register) {
+  const rel = (link.getAttribute("rel") ?? "").toLowerCase().split(/\s+/);
+  if (!rel.includes("stylesheet") || rel.includes("alternate") || !isUnconditionalStylesheet(link))
+    return;
+  for (const family of googleFontsUrlFamilies(link.getAttribute("href") ?? ""))
+    register(family);
+}
+function collectDeclaredFontFamilies(html) {
+  const { document: document2 } = parseHTML(html);
+  const declared = /* @__PURE__ */ new Map();
+  const register = (family, fontFaceRule) => {
+    const key = normalizeFamilyName(family);
+    if (!key || GENERIC_FAMILIES.has(key))
+      return;
+    let entry = declared.get(key);
+    if (!entry) {
+      entry = { family, fontFaceRules: [] };
+      declared.set(key, entry);
+    }
+    if (fontFaceRule)
+      entry.fontFaceRules.push(fontFaceRule);
+  };
+  for (const styleEl of Array.from(document2.querySelectorAll("style"))) {
+    declareStyleFontFamilies(styleEl, register);
+  }
+  for (const link of Array.from(document2.querySelectorAll("link[href]"))) {
+    declareLinkedFontFamilies(link, register);
+  }
+  return declared;
+}
+function familySpellingKey(family) {
+  return family.toLowerCase().replace(/[\s_+-]+/g, "");
+}
+function findDeclaredFamilyAlias(authoredFamily, declaredFamilies) {
+  if (declaredFamilies.has(normalizeFamilyName(authoredFamily)))
+    return null;
+  const key = familySpellingKey(authoredFamily);
+  if (!key)
+    return null;
+  let match = null;
+  for (const entry of declaredFamilies.values()) {
+    if (familySpellingKey(entry.family) !== key)
+      continue;
+    if (match)
+      return null;
+    match = entry;
+  }
+  return match;
+}
+async function resolveDeclaredFamilyAlias(authoredFamily, declaredFamilies, optional, options, fontText) {
+  const declared = findDeclaredFamilyAlias(authoredFamily, declaredFamilies);
+  if (!declared)
+    return null;
+  let rules;
+  if (declared.fontFaceRules.length > 0) {
+    rules = declared.fontFaceRules.map((rule) => {
+      const renamed = rule.clone();
+      renamed.walkDecls((decl) => {
+        if (decl.prop.toLowerCase() === "font-family")
+          decl.value = `"${authoredFamily}"`;
+      });
+      return renamed.toString();
+    });
+  } else {
+    rules = await resolveFamilyFaceRules(normalizeFamilyName(declared.family), declared.family, authoredFamily, optional, options, fontText);
+  }
+  if (!rules)
+    return null;
+  options.log.warn(`[Compiler] font-family "${authoredFamily}" is not a known family; resolved it to "${declared.family}", which this document declares. Correct the authored font-family to "${declared.family}".`);
+  return rules;
+}
+async function buildFontFaceCss(requestedFamilies, options, declaredFamilies, fontText) {
+  const rules = [];
+  const unresolved = [];
+  const requiredFirst = [...requestedFamilies].sort(([, a], [, b]) => Number(a.optional) - Number(b.optional));
+  for (const [normalizedFamily, { family: originalCaseFamily, optional }] of requiredFirst) {
+    const familyRules = await resolveFamilyFaceRules(normalizedFamily, originalCaseFamily, originalCaseFamily, optional, options, fontText) ?? // Last, so a family that already resolves keeps exactly the faces it had.
+    await resolveDeclaredFamilyAlias(originalCaseFamily, declaredFamilies(), optional, options, fontText);
+    if (familyRules) {
+      rules.push(...familyRules);
+      continue;
+    }
+    unresolved.push(originalCaseFamily);
+  }
+  return {
+    css: rules.join("\n\n").trim(),
+    unresolved: unresolved.sort()
+  };
+}
+function warnUnresolvedFonts(unresolved, log) {
+  const mapped = Object.entries(FONT_ALIASES).reduce((acc, [alias, canonical]) => {
+    const display = alias === canonical ? alias : `${alias} \u2192 ${canonical}`;
+    if (!acc.includes(display))
+      acc.push(display);
+    return acc;
+  }, []).sort();
+  log.warn(`[Compiler] No deterministic font mapping for: ${unresolved.join(", ")}
+  Mapped fonts: ${mapped.join(", ")}
+  To fix, pick one:
+    1. Use a mapped font name instead (see list above)
+    2. Add a @font-face block in your HTML with a local or hosted font file
+    3. Install the font locally on the render machine (Docker: add to Dockerfile)
+    4. Add an alias to FONT_ALIAS_MAP in packages/core/src/fonts/aliases.ts (for contributors)
+  Docs: https://hyperframes.heygen.com/docs/fonts`);
+}
+var lambdaFontCacheRoot;
+function resolveFontCacheRoot() {
+  if (process.env.HYPERFRAMES_FONT_CACHE_DIR) {
+    return process.env.HYPERFRAMES_FONT_CACHE_DIR;
+  }
+  if (process.env.AWS_LAMBDA_FUNCTION_NAME) {
+    lambdaFontCacheRoot ??= mkdtempSync2(join2(tmpdir2(), "hyperframes-fonts-"));
+    return lambdaFontCacheRoot;
+  }
+  return join2(homedir2(), ".cache", "hyperframes", "fonts");
+}
+var WOFF2_USER_AGENT = "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/131.0.0.0 Safari/537.36";
+function fontSlug(familyName) {
+  return familyName.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "");
+}
+var ephemeralFontCacheRoot;
+function fontCacheDir(slug) {
+  const dir = join2(resolveFontCacheRoot(), slug);
+  if (!existsSync2(dir)) {
+    try {
+      mkdirSync2(dir, { recursive: true });
+    } catch {
+      const firstFallback = ephemeralFontCacheRoot === void 0;
+      ephemeralFontCacheRoot ??= mkdtempSync2(join2(tmpdir2(), "hyperframes-fonts-"));
+      const fallback = join2(ephemeralFontCacheRoot, slug);
+      mkdirSync2(fallback, { recursive: true });
+      if (firstFallback) {
+        STDERR_LOGGER.warn(`Font cache directory is unwritable (${dir}). Using temporary fallback \u2014 fonts will re-download each run. Fix with: chmod 755 ${resolveFontCacheRoot()}`);
+      }
+      return fallback;
+    }
+  }
+  return dir;
+}
+function subsetToken(woff2Url) {
+  return createHash2("sha1").update(woff2Url).digest("hex").slice(0, 12);
+}
+function cachedWoff2Path(slug, weight, style, subset) {
+  return join2(fontCacheDir(slug), `${weight}-${style}-${subset}.woff2`);
+}
+var FONT_FETCH_FAILED = "FONT_FETCH_FAILED";
+var FONT_FETCH_UNAVAILABLE = "FONT_FETCH_UNAVAILABLE";
+var FontFetchError = class extends Error {
+  code;
+  familyName;
+  url;
+  cause;
+  /** Unlike `message`, holds no URLs: safe for callers that must not echo resolver output. */
+  unresolvedFamilies;
+  constructor(familyName, url, message, cause, code = FONT_FETCH_FAILED, unresolvedFamilies = []) {
+    super(message);
+    this.name = "FontFetchError";
+    this.code = code;
+    this.familyName = familyName;
+    this.url = url;
+    this.cause = cause;
+    this.unresolvedFamilies = unresolvedFamilies;
+  }
+};
+var FontFetchUnavailableError = class extends FontFetchError {
+  constructor(familyName, url, message, cause) {
+    super(familyName, url, message, cause, FONT_FETCH_UNAVAILABLE);
+    this.name = "FontFetchUnavailableError";
+  }
+};
+var DEFAULT_FONT_FETCH_RETRY_POLICY = {
+  maxAttempts: 2,
+  attemptTimeoutMs: 8e3,
+  maxElapsedMs: 2e4,
+  baseDelayMs: 250
+};
+function fontFetchError(familyName, url, what, cause, unavailable = false) {
+  const reason = "status" in cause ? `returned HTTP ${cause.status}` : `failed: ${cause.error instanceof Error ? cause.error.message : String(cause.error)}`;
+  const message = `[deterministicFonts] ${what} fetch for ${JSON.stringify(familyName)} ${reason}. Distributed renders require deterministic fonts; system-font fallback would produce non-byte-identical output.`;
+  const errorCause = "error" in cause ? cause.error : void 0;
+  return unavailable ? new FontFetchUnavailableError(familyName, url, message, errorCause) : new FontFetchError(familyName, url, message, errorCause);
+}
+function isRetryableFontFetchStatus(status) {
+  return status === 408 || status === 425 || status === 429 || status >= 500;
+}
+function retryAfterMs(response) {
+  const value = response.headers.get("retry-after");
+  if (value === null)
+    return null;
+  const seconds = Number(value);
+  if (Number.isFinite(seconds))
+    return Math.max(0, seconds * 1e3);
+  const date = Date.parse(value);
+  return Number.isNaN(date) ? null : Math.max(0, date - Date.now());
+}
+function callerAbortReason(signal) {
+  return signal.reason ?? new DOMException("Font fetch cancelled", "AbortError");
+}
+function throwIfCallerAborted(signal) {
+  if (signal?.aborted)
+    throw callerAbortReason(signal);
+}
+async function waitForFontFetchRetry(delayMs, signal) {
+  throwIfCallerAborted(signal);
+  if (delayMs <= 0)
+    return;
+  await new Promise((resolve, reject) => {
+    const timeout = setTimeout(() => {
+      signal?.removeEventListener("abort", onAbort);
+      resolve();
+    }, delayMs);
+    const onAbort = () => {
+      clearTimeout(timeout);
+      reject(signal ? callerAbortReason(signal) : new DOMException("Cancelled", "AbortError"));
+    };
+    signal?.addEventListener("abort", onAbort, { once: true });
+    if (signal?.aborted)
+      onAbort();
+  });
+}
+function retryDelayMs(response, attempt, baseDelayMs) {
+  const requestedDelay = response ? retryAfterMs(response) : null;
+  if (requestedDelay !== null)
+    return requestedDelay;
+  const ceiling = baseDelayMs * 2 ** attempt;
+  return Math.floor(Math.random() * (ceiling + 1));
+}
+function cancelResponseBody(response) {
+  try {
+    void response.body?.cancel().catch(() => {
+    });
+  } catch {
+  }
+}
+async function runFontFetchAttempt(url, init, readBody, options, remainingMs) {
+  const timeoutSignal = AbortSignal.timeout(Math.max(1, Math.min(options.retryPolicy.attemptTimeoutMs, remainingMs)));
+  const signal = options.abortSignal ? AbortSignal.any([options.abortSignal, timeoutSignal]) : timeoutSignal;
+  let response;
+  try {
+    response = await options.fetchImpl(url, { ...init, signal });
+    if (!isRetryableFontFetchStatus(response.status)) {
+      if (!response.ok)
+        return { completed: true, result: { ok: false, response } };
+      const body = await readBody(response);
+      return { completed: true, result: { ok: true, response, body } };
+    }
+    cancelResponseBody(response);
+    return { completed: false, response, cause: { status: response.status } };
+  } catch (error) {
+    throwIfCallerAborted(options.abortSignal);
+    return { completed: false, response, cause: { error } };
+  }
+}
+async function fetchFontResource(url, init, readBody, familyName, what, options) {
+  if (!options.failClosedFontFetch) {
+    const response = await options.fetchImpl(url, { ...init, signal: options.abortSignal });
+    if (!response.ok)
+      return { ok: false, response };
+    return { ok: true, response, body: await readBody(response) };
+  }
+  let lastCause = {
+    error: new DOMException("Font fetch budget exhausted", "TimeoutError")
+  };
+  for (let attempt = 0; attempt < options.retryPolicy.maxAttempts; attempt += 1) {
+    throwIfCallerAborted(options.abortSignal);
+    const remainingMs = options.retryDeadlineMs - Date.now();
+    if (remainingMs <= 0)
+      break;
+    const attemptResult = await runFontFetchAttempt(url, init, readBody, options, remainingMs);
+    if (attemptResult.completed)
+      return attemptResult.result;
+    lastCause = attemptResult.cause;
+    if (attempt + 1 >= options.retryPolicy.maxAttempts)
+      break;
+    const delayMs = retryDelayMs(attemptResult.response, attempt, options.retryPolicy.baseDelayMs);
+    if (delayMs >= options.retryDeadlineMs - Date.now())
+      break;
+    await waitForFontFetchRetry(delayMs, options.abortSignal);
+  }
+  throw fontFetchError(familyName, url, what, lastCause, true);
+}
+async function ensureWoff2DataUri(cachePath, woff2Url, familyName, weight, style, options) {
+  try {
+    return `data:font/woff2;base64,${readFileSync2(cachePath).toString("base64")}`;
+  } catch {
+  }
+  const woff2What = `Google Fonts woff2 (${weight}/${style})`;
+  try {
+    const fontResult = await fetchFontResource(woff2Url, void 0, (response) => response.arrayBuffer(), familyName, woff2What, options);
+    if (!fontResult.ok)
+      return null;
+    writeFileSync2(cachePath, Buffer.from(fontResult.body), { flag: "wx", mode: 420 });
+  } catch (err) {
+    throwIfCallerAborted(options.abortSignal);
+    if (err instanceof FontFetchError)
+      throw err;
+    if (err.code === "EEXIST") {
+    } else if (options.failClosedFontFetch) {
+      throw fontFetchError(familyName, woff2Url, woff2What, { error: err });
+    } else {
+      return null;
+    }
+  }
+  return `data:font/woff2;base64,${readFileSync2(cachePath).toString("base64")}`;
+}
+var googleFontCssCache = /* @__PURE__ */ new Map();
+function _clearGoogleFontCssCacheForTests() {
+  googleFontCssCache.clear();
+}
+function raceAgainstAbort(promise, signal) {
+  if (!signal)
+    return promise;
+  if (signal.aborted)
+    return Promise.reject(callerAbortReason(signal));
+  return new Promise((resolve, reject) => {
+    const onAbort = () => reject(callerAbortReason(signal));
+    signal.addEventListener("abort", onAbort, { once: true });
+    promise.then(resolve, reject).finally(() => signal.removeEventListener("abort", onAbort));
+  });
+}
+function fetchGoogleFontCss(url, familyName, options) {
+  const mode = options.failClosedFontFetch ? `closed${options.retryPolicy.maxAttempts}` : "open";
+  const key = `${mode}:${url}`;
+  let shared = googleFontCssCache.get(key);
+  if (!shared) {
+    shared = fetchFontResource(url, { headers: { "User-Agent": WOFF2_USER_AGENT } }, (response) => response.text(), familyName, "Google Fonts CSS", { ...options, abortSignal: void 0 }).then((result) => {
+      if (result.ok)
+        return { ok: true, body: result.body };
+      if (isRetryableFontFetchStatus(result.response.status))
+        googleFontCssCache.delete(key);
+      return { ok: false };
+    });
+    googleFontCssCache.set(key, shared);
+    shared.catch(() => googleFontCssCache.delete(key));
+  }
+  return raceAgainstAbort(shared, options.abortSignal);
+}
+function pageNamedThisFile(familyName, options) {
+  return options.authoredStylesheets.has(normalizeFamilyName(familyName.replace(/\+/g, " ")));
+}
+function declaredFaceFamily(block) {
+  const found = /font-family:\s*['"]([^'"]+)['"]/i.exec(block);
+  return found?.[1];
+}
+async function fetchGoogleFont(familyName, options, fontText) {
+  const googleFamilyName = familyName.replace(/\+/g, " ");
+  const encodedFamily = encodeURIComponent(googleFamilyName);
+  const textParam = fontText ? `&text=${encodeURIComponent(fontText)}` : "";
+  const normalizedFamily = normalizeFamilyName(googleFamilyName);
+  const authoredStylesheet = FONT_ALIASES[normalizedFamily] ? void 0 : options.authoredStylesheets.get(normalizedFamily);
+  const urls = authoredStylesheet ? authoredStylesheet.map((url) => withPageText(url, fontText)) : [
+    `https://fonts.googleapis.com/css2?family=${encodedFamily}:ital,wght@0,100;0,200;0,300;0,400;0,500;0,600;0,700;0,800;0,900;1,400;1,700${textParam}`
+  ];
+  const faces = [];
+  for (const url of urls) {
+    faces.push(...await fetchGoogleFontStylesheet(googleFamilyName, url, options));
+  }
+  return faces;
+}
+async function readGoogleFontStylesheet(familyName, url, options) {
+  try {
+    const cssResult = await fetchGoogleFontCss(url, familyName, options);
+    if (!cssResult.ok) {
+      return null;
+    }
+    return cssResult.body;
+  } catch (err) {
+    throwIfCallerAborted(options.abortSignal);
+    if (err instanceof FontFetchError)
+      throw err;
+    if (options.failClosedFontFetch) {
+      throw fontFetchError(familyName, url, "Google Fonts CSS", { error: err });
+    }
+    return null;
+  }
+}
+function parseGoogleFontSource(match, familyName) {
+  const declared = declaredFaceFamily(match[0]);
+  if (declared && normalizeFamilyName(declared) !== normalizeFamilyName(familyName))
+    return null;
+  const url = match[3];
+  if (!url)
+    return null;
+  return {
+    style: match[1] || "normal",
+    weight: (match[2] || "400").replace(/\s+/g, " "),
+    url,
+    unicodeRange: match[4]?.trim() || void 0
+  };
+}
+async function fetchGoogleFontStylesheet(familyName, url, options) {
+  const slug = fontSlug(familyName);
+  const cssText = await readGoogleFontStylesheet(familyName, url, options);
+  if (!cssText)
+    return [];
+  const faceRegex = /@font-face\s*\{[^}]*font-style:\s*(normal|italic|oblique(?:\s+-?\d+(?:\.\d+)?deg){0,2})\s*;[^}]*font-weight:\s*(\d+(?:\s+\d+)?)[^}]*src:\s*url\(([^)]+)\)\s*format\(['"]woff2['"]\)(?:[^}]*?unicode-range:\s*([^;}]+))?[^}]*\}/gi;
+  const faces = [];
+  for (const match of cssText.matchAll(faceRegex)) {
+    const source = parseGoogleFontSource(match, familyName);
+    if (!source)
+      continue;
+    const { weight, style, unicodeRange, url: woff2Url } = source;
+    const cachePath = cachedWoff2Path(slug, weight, style, subsetToken(woff2Url));
+    const dataUri = await ensureWoff2DataUri(cachePath, woff2Url, familyName, weight, style, options);
+    if (dataUri)
+      faces.push({ weight, style, dataUri, unicodeRange });
+  }
+  if (faces.length > 0) {
+    options.log.info(`[Compiler] Fetched ${faces.length} font face(s) for "${familyName}" from Google Fonts (cached to ${fontCacheDir(slug)})`);
+  }
+  return faces;
+}
+async function fetchFamilyFaces(familyName, optional, options, fontText) {
+  if (!optional)
+    return fetchGoogleFont(familyName, options, fontText);
+  const maxAttempts = Math.min(options.retryPolicy.maxAttempts, 2);
+  try {
+    return await fetchGoogleFont(familyName, { ...options, retryPolicy: { ...options.retryPolicy, maxAttempts } }, fontText);
+  } catch (err) {
+    if (!(err instanceof FontFetchUnavailableError))
+      throw err;
+    options.log.warn(`[Compiler] Optional font "${familyName}" is unavailable, rendering its fallback: ${err.message}`);
+    return [];
+  }
+}
+var STDERR_LOGGER = {
+  warn: (message) => console.warn(`[WARN] ${message}`),
+  info: (message) => console.error(`[INFO] ${message}`)
+};
+var GOOGLE_FONTS_TEXT_MAX_ENCODED_LENGTH = 1700;
+var SMALL_TO_FULL_KANA = /* @__PURE__ */ new Map([
+  ["\u3041", "\u3042"],
+  ["\u3043", "\u3044"],
+  ["\u3045", "\u3046"],
+  ["\u3047", "\u3048"],
+  ["\u3049", "\u304A"],
+  ["\u3063", "\u3064"],
+  ["\u3083", "\u3084"],
+  ["\u3085", "\u3086"],
+  ["\u3087", "\u3088"],
+  ["\u308E", "\u308F"],
+  ["\u30A1", "\u30A2"],
+  ["\u30A3", "\u30A4"],
+  ["\u30A5", "\u30A6"],
+  ["\u30A7", "\u30A8"],
+  ["\u30A9", "\u30AA"],
+  ["\u30C3", "\u30C4"],
+  ["\u30E3", "\u30E4"],
+  ["\u30E5", "\u30E6"],
+  ["\u30E7", "\u30E8"],
+  ["\u30EE", "\u30EF"],
+  ["\u30F5", "\u30AB"],
+  ["\u30F6", "\u30B1"]
+]);
+function collectLangAttributes(document2) {
+  const locales = /* @__PURE__ */ new Set();
+  for (const element of document2.querySelectorAll("[lang]")) {
+    const lang = element.getAttribute("lang");
+    if (!lang)
+      continue;
+    const primary = lang.split("-")[0].toLowerCase();
+    try {
+      Intl.getCanonicalLocales(primary);
+      locales.add(primary);
+    } catch {
+    }
+  }
+  return locales;
+}
+function addCaseClosure(out, character, locales) {
+  out.add(character);
+  for (const variant of `${character.toUpperCase()}${character.toLowerCase()}`) {
+    out.add(variant);
+  }
+  for (const locale of locales) {
+    for (const variant of `${character.toLocaleUpperCase(locale)}${character.toLocaleLowerCase(locale)}`) {
+      out.add(variant);
+    }
+  }
+}
+function addFullwidthVariants(chars) {
+  for (const character of [...chars]) {
+    const code = character.codePointAt(0) ?? 0;
+    if (code >= 33 && code <= 126) {
+      chars.add(String.fromCodePoint(code + 65248));
+    }
+  }
+}
+function addFullSizeKanaVariants(chars) {
+  for (const character of [...chars]) {
+    const full = SMALL_TO_FULL_KANA.get(character);
+    if (full)
+      chars.add(full);
+  }
+}
+var FULL_WIDTH_KEYWORD_RE = /\bfull-width\b/;
+var FULL_SIZE_KANA_KEYWORD_RE = /\bfull-size-kana\b/;
+var DECLARATION_BOUNDARY_RE = /[;{}]/;
+function skipWhitespace(s, pos) {
+  while (pos < s.length && " 	\n\r\f\v".includes(s[pos]))
+    pos += 1;
+  return pos;
+}
+function findDeclarationEnd(s, pos) {
+  const match = DECLARATION_BOUNDARY_RE.exec(s.slice(pos));
+  return match ? pos + match.index : s.length;
+}
+function hasTextTransformKeyword(html, keyword) {
+  const haystack = html.toLowerCase();
+  const property = "text-transform";
+  let from = 0;
+  for (; ; ) {
+    const at = haystack.indexOf(property, from);
+    if (at === -1)
+      return false;
+    const afterProp = skipWhitespace(haystack, at + property.length);
+    if (haystack[afterProp] !== ":") {
+      from = at + property.length;
+      continue;
+    }
+    const end = findDeclarationEnd(haystack, afterProp + 1);
+    if (keyword.test(haystack.slice(afterProp + 1, end)))
+      return true;
+    from = end;
+  }
+}
+function extractGoogleFontsText(html) {
+  const { document: document2 } = parseHTML(html);
+  const decodedBodyText = document2.body?.textContent ?? "";
+  const locales = collectLangAttributes(document2);
+  const uniqueCharacters = /* @__PURE__ */ new Set();
+  for (const character of /* @__PURE__ */ new Set([...Array.from(html), ...Array.from(decodedBodyText)])) {
+    addCaseClosure(uniqueCharacters, character, locales);
+  }
+  if (hasTextTransformKeyword(html, FULL_WIDTH_KEYWORD_RE))
+    addFullwidthVariants(uniqueCharacters);
+  if (hasTextTransformKeyword(html, FULL_SIZE_KANA_KEYWORD_RE))
+    addFullSizeKanaVariants(uniqueCharacters);
+  const fontText = [...uniqueCharacters].join("");
+  return encodeURIComponent(fontText).length <= GOOGLE_FONTS_TEXT_MAX_ENCODED_LENGTH ? fontText : void 0;
+}
+function resolveFontFetchRetryPolicy(configured) {
+  return {
+    maxAttempts: Math.max(1, Math.floor(configured?.maxAttempts ?? DEFAULT_FONT_FETCH_RETRY_POLICY.maxAttempts)),
+    attemptTimeoutMs: Math.max(1, configured?.attemptTimeoutMs ?? DEFAULT_FONT_FETCH_RETRY_POLICY.attemptTimeoutMs),
+    maxElapsedMs: Math.max(1, configured?.maxElapsedMs ?? DEFAULT_FONT_FETCH_RETRY_POLICY.maxElapsedMs),
+    baseDelayMs: Math.max(0, configured?.baseDelayMs ?? DEFAULT_FONT_FETCH_RETRY_POLICY.baseDelayMs)
+  };
+}
+function placeAfterEveryStylesheet(document2, head, styleEl) {
+  const stylesheets = document2.querySelectorAll("style, link[rel~=stylesheet]");
+  const lastStylesheet = stylesheets[stylesheets.length - 1];
+  if (lastStylesheet)
+    lastStylesheet.after(styleEl);
+  else
+    head.appendChild(styleEl);
+}
+async function injectDeterministicFontFaces(html, options = {}) {
+  const failClosedFontFetch = options.failClosedFontFetch === true;
+  const fetchImpl = options.fetchImpl ?? fetch;
+  const allowSystemFontCapture = options.allowSystemFontCapture !== false;
+  const retryPolicy = resolveFontFetchRetryPolicy(options.fontFetchRetryPolicy);
+  const fetchOptions = {
+    log: options.logger ?? STDERR_LOGGER,
+    failClosedFontFetch,
+    fetchImpl,
+    allowSystemFontCapture,
+    abortSignal: options.abortSignal,
+    retryPolicy,
+    retryDeadlineMs: Date.now() + retryPolicy.maxElapsedMs,
+    authoredStylesheets: authoredGoogleFontStylesheets(html)
+  };
+  const existingFaces = extractExistingFontFaces(html);
+  const requestedFamilies = extractRequestedFontFamilies(html);
+  const pendingFamilies = /* @__PURE__ */ new Map();
+  for (const [normalizedFamily, requested] of requestedFamilies) {
+    if (!existingFaces.has(normalizedFamily)) {
+      pendingFamilies.set(normalizedFamily, requested);
+    }
+  }
+  if (pendingFamilies.size === 0) {
+    return html;
+  }
+  let declaredFamilies;
+  const { css, unresolved } = await buildFontFaceCss(pendingFamilies, fetchOptions, () => declaredFamilies ??= collectDeclaredFontFamilies(html), extractGoogleFontsText(html));
+  const required = unresolved.filter((family) => !pendingFamilies.get(family.toLowerCase())?.optional);
+  if (required.length > 0 && options.failClosedFontFetch) {
+    throw new FontFetchError(required.join(", "), "", `[Compiler] Unresolved fonts in fail-closed mode: ${required.join(", ")}. Distributed renders require all fonts to be resolvable.`, void 0, FONT_FETCH_FAILED, unresolved);
+  }
+  if (!css) {
+    if (unresolved.length > 0) {
+      warnUnresolvedFonts(unresolved, fetchOptions.log);
+    }
+    return html;
+  }
+  const { document: document2 } = parseHTML(html);
+  const head = document2.querySelector("head");
+  if (!head) {
+    return html;
+  }
+  const styleEl = document2.createElement("style");
+  styleEl.setAttribute("data-hyperframes-deterministic-fonts", "true");
+  styleEl.textContent = css;
+  placeAfterEveryStylesheet(document2, head, styleEl);
+  fetchOptions.log.info(`[Compiler] Injected deterministic @font-face rules for ${pendingFamilies.size - unresolved.length} requested font families`);
+  if (unresolved.length > 0) {
+    warnUnresolvedFonts(unresolved, fetchOptions.log);
+  }
+  return document2.toString();
+}
+
 export {
-  compressToWoff2,
-  fontToDataUri
+  fontToDataUri,
+  GENERIC_FAMILIES,
+  parseFontFamilyValue,
+  normalizeSystemFontPrimaryFamilies,
+  collectFontFamilyCustomProperties,
+  resolveFontFamilyDeclarationFamilies,
+  iterateFontFamilyDeclarations,
+  FONT_ALIASES,
+  fontFormatHint,
+  FONT_FETCH_FAILED,
+  FONT_FETCH_UNAVAILABLE,
+  FontFetchError,
+  FontFetchUnavailableError,
+  _clearGoogleFontCssCacheForTests,
+  injectDeterministicFontFaces
 };