nuxt-og-image 6.7.6 → 6.7.7

package/dist/shared/{nuxt-og-image.BIbfn5xQ.mjs → nuxt-og-image.BMHzg1Vz.mjs}

@@ -2,7 +2,7 @@ import { createHash, randomBytes } from 'node:crypto';
 import * as fs from 'node:fs';
 import { existsSync, mkdirSync, readdirSync, readFileSync, statSync, rmSync } from 'node:fs';
 import { readdir, readFile, writeFile, mkdir } from 'node:fs/promises';
-import { pathToFileURL } from 'node:url';
+import { fileURLToPath, pathToFileURL } from 'node:url';
 import { resolvePath, useNuxt, addTemplate, updateTemplates, directoryToURL, tryResolveModule, addTypeTemplate, defineNuxtModule, createResolver, addImports, hasNuxtModule, hasNuxtModuleCompatibility, getNuxtModuleVersion, addVitePlugin, addBuildPlugin, addServerHandler, addPlugin, addComponentsDir, getNuxtVersion, addServerPlugin } from '@nuxt/kit';
 import { defu } from 'defu';
 import { fnv1a64Base36 } from 'fnv1a-64';
@@ -868,18 +868,18 @@ ${content}`, "utf-8");
       if (isCssChange || normalizedPath.includes("uno.config")) {
         clearTimeout(cssRefreshTimer);
         cssRefreshTimer = setTimeout(() => {
-          safeBroadcast(() => rpc.broadcast.refresh());
+          safeBroadcast(() => rpc.broadcast.refresh.asEvent());
         }, 200);
         return;
       }
       if ((e === "change" || e.includes("link")) && (normalizedPath.startsWith("pages") || normalizedPath.startsWith("content"))) {
-        safeBroadcast(() => rpc.broadcast.refreshRouteData(normalizedPath));
+        safeBroadcast(() => rpc.broadcast.refreshRouteData.asEvent(normalizedPath));
       }
       if (options.componentDirs.some((dir) => normalizedPath.includes(dir))) {
         if (e === "change")
-          safeBroadcast(() => rpc.broadcast.refresh());
+          safeBroadcast(() => rpc.broadcast.refresh.asEvent());
         else
-          safeBroadcast(() => rpc.broadcast.refreshGlobalData());
+          safeBroadcast(() => rpc.broadcast.refreshGlobalData.asEvent());
       }
     });
   });
@@ -1700,6 +1700,9 @@ const RE_FONT_EXT = /\.(?:woff2?|ttf|otf)$/i;
 const RE_NON_WORD = /\W+/g;
 const FONTS_URL_PREFIX = "/_fonts";
 const STATIC_FONTS_PREFIX = "/_og-static-fonts";
+function getStaticFontCacheDir(buildDir) {
+  return join(buildDir, "cache", "og-image", "static-fonts");
+}
 function fontKey(f) {
   return `${f.family}-${f.weight}-${f.style}-${f.unicodeRange || "default"}`;
 }
@@ -1883,7 +1886,9 @@ function parseConfiguredLocalFonts(nuxt) {
 }
 async function parseFontsFromTemplate(nuxt, options) {
   const weightsKey = options.requiredWeights?.toSorted((a, b) => a - b).join(",") || "";
-  const cacheKey = `${options.convertedWoff2Files.size}:${[...options.convertedWoff2Files.keys()].toSorted().join(",")}:${weightsKey}`;
+  const sourceKey = [...options.fontState.sourceMap.entries()].toSorted(([a], [b]) => a.localeCompare(b)).flat().join(",");
+  const fallbackKey = [...options.fontState.fallbackMap.entries()].toSorted(([a], [b]) => a.localeCompare(b)).flat().join(",");
+  const cacheKey = `${sourceKey}:${fallbackKey}:${weightsKey}`;
   const cache = nuxt._ogImageParsedFontsCache ||= /* @__PURE__ */ new Map();
   const cached = cache.get(cacheKey);
   if (cached)
@@ -1904,11 +1909,11 @@ async function parseFontsFromTemplate(nuxt, options) {
     }
   }
   const fontlessFamilies = new Set(
-    [...fontMap.values()].filter((f) => options.convertedWoff2Files.has(`${f.family}-${f.weight}-${f.style}`)).map((f) => f.family)
+    [...fontMap.values()].filter((f) => options.fontState.fallbackMap.has(`${f.family}-${f.weight}-${f.style}`)).map((f) => f.family)
   );
   const expandedFonts = [...fontMap.values()];
   const existingKeys = new Set(expandedFonts.map((f) => `${f.family}-${f.weight}-${f.style}`));
-  for (const [key] of options.convertedWoff2Files) {
+  for (const [key] of options.fontState.fallbackMap) {
     if (existingKeys.has(key))
       continue;
     const match = key.match(RE_FONT_KEY);
@@ -1942,18 +1947,18 @@ async function parseFontsFromTemplate(nuxt, options) {
       }
     }
   }
-  const defaultUnicodeRange = "U+0-FF, U+131, U+152-153, U+2BB-2BC, U+2C6, U+2DA, U+2DC, U+304, U+308, U+329, U+2000-206F, U+20AC, U+2122, U+2191, U+2193, U+2212, U+2215, U+FEFF, U+FFFD";
   const result = expandedFonts.map((font) => {
     const fKey = `${font.family}-${font.weight}-${font.style}`;
-    const fontlessPath = options.convertedWoff2Files.get(fKey);
-    const satoriSrc = fontlessPath || (font.isWoff2 ? void 0 : fontlessFamilies.has(font.family) ? void 0 : font.src);
+    const convertedSource = options.fontState.sourceMap.get(font.src);
+    const fontlessPath = options.fontState.fallbackMap.get(fKey);
+    const satoriSrc = convertedSource || fontlessPath || (font.isWoff2 ? void 0 : fontlessFamilies.has(font.family) ? void 0 : font.src);
     return {
       family: font.family,
       src: font.src,
       weight: font.weight,
       style: font.style,
       satoriSrc,
-      unicodeRange: font.unicodeRange || defaultUnicodeRange,
+      unicodeRange: font.unicodeRange,
       subset: font.subset,
       weightRange: font.weightRange
     };
@@ -2005,10 +2010,10 @@ function copyStaticFontsToOutput(options) {
       count++;
     }
   }
-  const ttfSourceDir = join(buildDir, "cache", "og-image", "fonts-ttf");
-  if (existsSync(ttfSourceDir)) {
-    for (const file of fs.readdirSync(ttfSourceDir).filter((f) => f.endsWith(".ttf") || f.endsWith(".woff"))) {
-      fs.copyFileSync(join(ttfSourceDir, file), join(outputDir, file));
+  const staticFontDir = getStaticFontCacheDir(buildDir);
+  if (existsSync(staticFontDir)) {
+    for (const file of fs.readdirSync(staticFontDir).filter((f) => f.endsWith(".ttf") || f.endsWith(".woff"))) {
+      fs.copyFileSync(join(staticFontDir, file), join(outputDir, file));
       count++;
     }
   }
@@ -2028,6 +2033,20 @@ function isConfiguredLocalFontFamily(nuxt, family) {
   const config = getNuxtFontsFamilyConfig(nuxt, family);
   return !!config && config.global === true && (config.provider === "local" || typeof config.src === "string");
 }
+function getFamilyRequirements(fontRequirements, family) {
+  const familyName = family.toLowerCase();
+  const matchingComponents = Object.values(fontRequirements.componentMap).filter((component) => component.families.some((candidate) => candidate.toLowerCase() === familyName));
+  if (matchingComponents.length === 0 || matchingComponents.some((component) => component.hasDynamicBindings)) {
+    return {
+      weights: fontRequirements.weights,
+      styles: fontRequirements.styles
+    };
+  }
+  return {
+    weights: [...new Set(matchingComponents.flatMap((component) => component.weights))],
+    styles: [...new Set(matchingComponents.flatMap((component) => component.styles))]
+  };
+}
 async function initFontless(options) {
   if (getFontlessContext(options.nuxt))
     return;
@@ -2085,7 +2104,7 @@ async function initFontless(options) {
         weights: [400, 700],
         styles: ["normal", "italic"],
         subsets: options.fontSubsets || ["latin"],
-        // Satori/Takumi can't reliably use WOFF2 subsets — request static formats
+        // Static fallbacks must use formats supported by both renderers.
         formats: ["woff", "ttf"]
       }
     },
@@ -2127,8 +2146,8 @@ function resolveWeightsFromFontEntry(fontWeight, requestedWeights) {
 async function downloadStaticFonts(options) {
   if (options.families.length === 0)
     return [];
-  const ttfDir = join(options.nuxt.options.buildDir, "cache", "og-image", "fonts-ttf");
-  fs.mkdirSync(ttfDir, { recursive: true });
+  const staticFontDir = getStaticFontCacheDir(options.nuxt.options.buildDir);
+  fs.mkdirSync(staticFontDir, { recursive: true });
   await initFontless({ nuxt: options.nuxt, logger: options.logger, fontSubsets: options.fontSubsets });
   const fontlessCtx = getFontlessContext(options.nuxt);
   if (!fontlessCtx) {
@@ -2143,7 +2162,7 @@ async function downloadStaticFonts(options) {
       family,
       weights,
       styles,
-      ttfDir,
+      staticFontDir,
       resolver: fontlessCtx.resolver,
       logger: options.logger
     });
@@ -2155,7 +2174,7 @@ async function downloadStaticFonts(options) {
     if (hasVariableBinary && weights.length > 1) {
       options.logger.debug(`${family}: provider returned variable font binary, retrying with alternative providers`);
       for (const r of familyResults) {
-        const filePath = join(ttfDir, r.filename);
+        const filePath = join(staticFontDir, r.filename);
         if (fs.existsSync(filePath))
           fs.unlinkSync(filePath);
       }
@@ -2165,7 +2184,7 @@ async function downloadStaticFonts(options) {
           family,
           weights,
           styles,
-          ttfDir,
+          staticFontDir,
           logger: options.logger,
           resolver: fontlessCtx.resolver,
           provider
@@ -2176,7 +2195,7 @@ async function downloadStaticFonts(options) {
         for (const r of altResults) altUrls.set(r.url, [...altUrls.get(r.url) || [], r.weight]);
         if ([...altUrls.values()].some((ws) => ws.length > 1)) {
           for (const r of altResults) {
-            const filePath = join(ttfDir, r.filename);
+            const filePath = join(staticFontDir, r.filename);
             if (fs.existsSync(filePath))
               fs.unlinkSync(filePath);
           }
@@ -2255,7 +2274,7 @@ async function listLocalPublicFontFiles(nuxt) {
   return out;
 }
 async function resolveAndDownloadFamily(options) {
-  const { family, weights, styles, ttfDir, logger } = options;
+  const { family, weights, styles, staticFontDir, logger } = options;
   const results = [];
   try {
     const override = options.provider ? { name: family, weights, styles, provider: options.provider } : { name: family, weights, styles };
@@ -2281,7 +2300,7 @@ async function resolveAndDownloadFamily(options) {
         const ext = isTtf ? "ttf" : "woff";
         for (const weight of resolvedWeights) {
           const filename = `${family.replace(RE_NON_ALPHANUMERIC, "_")}-${weight}-${style}.${ext}`;
-          const destPath = join(ttfDir, filename);
+          const destPath = join(staticFontDir, filename);
           if (!await downloadFontFile(url, destPath))
             continue;
           results.push({ family, weight, style, format, filename, url });
@@ -2294,51 +2313,175 @@ async function resolveAndDownloadFamily(options) {
   }
   return results;
 }
-async function convertWoff2ToTtf(options) {
-  const { nuxt, logger, fontRequirements, convertedWoff2Files, fontSubsets, warnOnMissingStaticFonts = true } = options;
-  const parsedFonts = await parseFontsFromTemplate(nuxt, { convertedWoff2Files });
+function hasOpenTypeTable(data, expectedTag) {
+  if (data.byteLength < 12)
+    return false;
+  const view = new DataView(data.buffer, data.byteOffset, data.byteLength);
+  const tableCount = view.getUint16(4);
+  for (let index = 0; index < tableCount; index++) {
+    const offset = 12 + index * 16;
+    if (offset + 4 > data.byteLength)
+      return false;
+    const tag = String.fromCharCode(
+      view.getUint8(offset),
+      view.getUint8(offset + 1),
+      view.getUint8(offset + 2),
+      view.getUint8(offset + 3)
+    );
+    if (tag === expectedTag)
+      return true;
+  }
+  return false;
+}
+function getNuxtFontOriginalSource(fontSrc, context) {
+  if (!context)
+    return;
+  const prefix = `${context.assetsBaseURL.replace(/\/$/, "")}/`;
+  if (!fontSrc.startsWith(prefix))
+    return;
+  return context.renderedFontURLs.get(fontSrc.slice(prefix.length));
+}
+async function readNuxtFontAsset(nuxt, source) {
+  if (source.startsWith("/")) {
+    const configuredPublicDir = nuxt.options.dir.public || "public";
+    const publicDir = isAbsolute(configuredPublicDir) ? configuredPublicDir : join(nuxt.options.srcDir, configuredPublicDir);
+    const path = join(publicDir, source.slice(1).split(/[?#]/, 1)[0]);
+    return fs.promises.readFile(path).then((data) => ({ _tag: "Ok", data })).catch((error) => ({
+      _tag: "Err",
+      reason: error.code === "ENOENT" ? `local source not found: ${path}` : error.message
+    }));
+  }
+  if (source.startsWith("file:")) {
+    const path = fileURLToPath(source);
+    return fs.promises.readFile(path).then((data) => ({ _tag: "Ok", data })).catch((error) => ({ _tag: "Err", reason: error.message }));
+  }
+  return fetch(source).then(async (response) => response.ok ? { _tag: "Ok", data: new Uint8Array(await response.arrayBuffer()) } : { _tag: "Err", reason: `source returned HTTP ${response.status}` }).catch((error) => ({ _tag: "Err", reason: error.message }));
+}
+async function convertNuxtWoff2Sources(options) {
+  const staticFontDir = getStaticFontCacheDir(options.nuxt.options.buildDir);
+  fs.mkdirSync(staticFontDir, { recursive: true });
+  const fontsBySource = /* @__PURE__ */ new Map();
+  for (const font of options.fonts) {
+    if (!font.weightRange && !fontsBySource.has(font.src))
+      fontsBySource.set(font.src, font);
+  }
+  const mappedSources = [];
+  for (const [fontSrc, font] of fontsBySource) {
+    const originalSource = getNuxtFontOriginalSource(fontSrc, options.context) || (isConfiguredLocalFontFamily(options.nuxt, font.family) ? fontSrc : void 0);
+    if (originalSource)
+      mappedSources.push({ font, fontSrc, originalSource });
+    else
+      options.logger.debug(`Could not map Nuxt Fonts asset to its original source: ${fontSrc}`);
+  }
+  if (mappedSources.length === 0)
+    return;
+  const { woff2Decode } = await import('../chunks/decode.mjs');
+  for (const { fontSrc, font, originalSource } of mappedSources) {
+    const asset = await readNuxtFontAsset(options.nuxt, originalSource);
+    if (asset._tag === "Err") {
+      options.logger.debug(`Could not read Nuxt Fonts asset ${fontSrc}: ${asset.reason}`);
+      continue;
+    }
+    const decoded = await Promise.resolve().then(() => woff2Decode(asset.data)).catch((error) => {
+      options.logger.warn(`Failed to decode Nuxt Fonts asset ${fontSrc}: ${error.message}`);
+      return null;
+    });
+    if (!decoded)
+      continue;
+    if (hasOpenTypeTable(decoded, "fvar")) {
+      options.logger.debug(`${font.family}: ${fontSrc} is variable; a static Satori fallback is required`);
+      continue;
+    }
+    const sourceFilename = fontSrc.split("/").pop();
+    const filename = sourceFilename.replace(/\.woff2$/i, ".ttf");
+    await fs.promises.writeFile(join(staticFontDir, filename), decoded);
+    options.fontState.sourceMap.set(fontSrc, `${STATIC_FONTS_PREFIX}/${filename}`);
+  }
+  if (options.fontState.sourceMap.size > 0)
+    options.logger.debug(`Converted ${options.fontState.sourceMap.size} Nuxt Fonts WOFF2 assets to TTF`);
+}
+async function prepareWoff2Fonts(options) {
+  const { nuxt, logger, fontRequirements, fontState, nuxtFontsContext, fontSubsets, warnOnMissingStaticFonts = true } = options;
+  const parsedFonts = await parseFontsFromTemplate(nuxt, { fontState });
+  const requirementsByFamily = /* @__PURE__ */ new Map();
+  for (const font of parsedFonts) {
+    if (!requirementsByFamily.has(font.family))
+      requirementsByFamily.set(font.family, getFamilyRequirements(fontRequirements, font.family));
+  }
   const hasNonWoff2 = new Set(
     parsedFonts.filter((f) => !f.src.endsWith(".woff2")).map((f) => fontKey(f))
   );
-  const woff2Fonts = parsedFonts.filter(
-    (f) => f.src.endsWith(".woff2") && !hasNonWoff2.has(fontKey(f)) && !isConfiguredLocalFontFamily(nuxt, f.family) && fontRequirements.weights.includes(f.weight) && fontRequirements.styles.includes(f.style)
-  );
+  const woff2Fonts = parsedFonts.filter((font) => {
+    const requirements = requirementsByFamily.get(font.family);
+    return font.src.endsWith(".woff2") && !hasNonWoff2.has(fontKey(font)) && requirements.weights.includes(font.weight) && requirements.styles.includes(font.style);
+  });
   if (woff2Fonts.length === 0) {
     logger.debug("No WOFF2 fonts to process");
     return;
   }
-  const familyMap = /* @__PURE__ */ new Map();
+  await convertNuxtWoff2Sources({
+    fonts: woff2Fonts,
+    nuxt,
+    context: nuxtFontsContext,
+    fontState,
+    logger
+  });
+  const configuredLocalFamilies = new Set(
+    woff2Fonts.filter((font) => isConfiguredLocalFontFamily(nuxt, font.family)).map((font) => font.family)
+  );
+  const unresolvedLocalFamilies = new Set(
+    woff2Fonts.filter((font) => configuredLocalFamilies.has(font.family) && !fontState.sourceMap.has(font.src)).map((font) => font.family)
+  );
+  if (warnOnMissingStaticFonts) {
+    for (const family of unresolvedLocalFamilies)
+      logger.warn(`Configured Nuxt Fonts assets for "${family}" could not be converted for Satori. Satori does not support WOFF2 or variable fonts; use static WOFF/TTF sources or the Takumi renderer.`);
+  }
+  const unavailableStaticFonts = new Set(
+    woff2Fonts.filter((font) => !fontState.sourceMap.has(font.src)).map((font) => `${font.family}-${font.weight}-${font.style}`)
+  );
+  const availableStaticFonts = new Set(
+    parsedFonts.filter((font) => !unavailableStaticFonts.has(`${font.family}-${font.weight}-${font.style}`)).filter((font) => !font.src.endsWith(".woff2") || fontState.sourceMap.has(font.src)).map((font) => `${font.family}-${font.weight}-${font.style}`)
+  );
+  const fallbackRequests = /* @__PURE__ */ new Map();
   for (const font of woff2Fonts) {
-    const existing = familyMap.get(font.family) || { weights: new Set(fontRequirements.weights), styles: /* @__PURE__ */ new Set() };
-    existing.styles.add(font.style);
-    familyMap.set(font.family, existing);
+    if (configuredLocalFamilies.has(font.family))
+      continue;
+    const style = font.style;
+    const requirements = requirementsByFamily.get(font.family);
+    const key = `${font.family}\0${style}`;
+    const request = fallbackRequests.get(key) || { family: font.family, weights: /* @__PURE__ */ new Set(), style };
+    for (const weight of requirements.weights) {
+      if (!availableStaticFonts.has(`${font.family}-${weight}-${style}`))
+        request.weights.add(weight);
+    }
+    fallbackRequests.set(key, request);
   }
-  const families = Array.from(familyMap.entries(), ([family, { weights, styles }]) => ({
+  const families = Array.from(fallbackRequests.values(), ({ family, weights, style }) => ({
     family,
     weights: [...weights],
-    styles: [...styles]
-  }));
-  logger.debug(`Resolving static fonts for: ${families.map((f) => f.family).join(", ")}`);
-  try {
-    const downloaded = await downloadStaticFonts({
-      families,
-      nuxt,
-      logger,
-      fontSubsets,
-      warnOnMissingStaticFonts
-    });
-    for (const font of downloaded) {
-      const key = `${font.family}-${font.weight}-${font.style}`;
-      convertedWoff2Files.set(key, `${STATIC_FONTS_PREFIX}/${font.filename}`);
-    }
-    if (convertedWoff2Files.size > 0) {
-      logger.debug(`Resolved ${convertedWoff2Files.size} static font files via fontless`);
-    } else if (warnOnMissingStaticFonts) {
-      logger.warn(`No static fonts available for Satori. Falling back to bundled Inter font. Consider using 'takumi' renderer for variable font support.`);
-    }
-  } catch (err) {
-    logger.debug("fontless resolution failed:", err);
+    styles: [style]
+  })).filter((family) => family.weights.length > 0);
+  if (families.length === 0)
+    return;
+  logger.debug(`Resolving static font fallbacks for: ${families.map((f) => f.family).join(", ")}`);
+  const downloaded = await downloadStaticFonts({
+    families,
+    nuxt,
+    logger,
+    fontSubsets,
+    warnOnMissingStaticFonts
+  }).catch((error) => {
+    logger.debug("fontless resolution failed:", error);
+    return [];
+  });
+  for (const font of downloaded) {
+    const key = `${font.family}-${font.weight}-${font.style}`;
+    fontState.fallbackMap.set(key, `${STATIC_FONTS_PREFIX}/${font.filename}`);
   }
+  if (fontState.fallbackMap.size > 0)
+    logger.debug(`Resolved ${fontState.fallbackMap.size} static font fallbacks via fontless`);
+  else if (warnOnMissingStaticFonts && fontState.sourceMap.size === 0)
+    logger.warn(`No static fonts available for Satori. Falling back to bundled Inter font. Consider using the Takumi renderer for variable font support.`);
 }
 async function resolveMissingFontFamilies(options) {
   const { missingFamilies, weights, styles, nuxt, logger, fontSubsets } = options;
@@ -2356,9 +2499,9 @@ async function resolveMissingFontFamilies(options) {
   return results;
 }
 async function resolveOgImageFonts(options) {
-  const { nuxt, hasNuxtFonts, hasSatoriRenderer, hasTakumiRenderer, convertedWoff2Files, fontSubsets, fontRequirements, tw4FontVars, logger, ogFontsDir } = options;
+  const { nuxt, hasNuxtFonts, hasSatoriRenderer, hasTakumiRenderer, fontState, fontSubsets, fontRequirements, tw4FontVars, logger, ogFontsDir } = options;
   const staticInterFonts = getStaticInterFonts(ogFontsDir);
-  const allFonts = hasNuxtFonts ? await parseFontsFromTemplate(nuxt, { convertedWoff2Files, requiredWeights: fontRequirements.weights }) : [];
+  const allFonts = hasNuxtFonts ? await parseFontsFromTemplate(nuxt, { fontState, requiredWeights: fontRequirements.weights }) : [];
   if (hasNuxtFonts) {
     const configuredLocalFonts = parseConfiguredLocalFonts(nuxt);
     if (configuredLocalFonts.length > 0) {
@@ -2413,7 +2556,7 @@ async function resolveOgImageFonts(options) {
     }
   }
   const nuxtFontFamilies = new Set(
-    hasNuxtFonts ? (await parseFontsFromTemplate(nuxt, { convertedWoff2Files, requiredWeights: fontRequirements.weights })).map((f) => f.family) : []
+    hasNuxtFonts ? (await parseFontsFromTemplate(nuxt, { fontState, requiredWeights: fontRequirements.weights })).map((f) => f.family) : []
   );
   const fonts = !fontRequirements.hasDynamicBindings ? allFonts.filter(
     (f) => nuxtFontFamilies.has(f.family) ? fontRequirements.styles.includes(f.style) : matchesFontRequirements(f, fontRequirements)
@@ -4581,6 +4724,7 @@ declare module '#og-image-virtual/component-names.mjs' {
 declare module '#og-image-virtual/build-dir.mjs' {
   export const buildDir: string
   export const rootDir: string
+  export const staticFontCacheDir: string
 }
 
 declare module '#og-image/compatibility' {
@@ -4666,8 +4810,8 @@ declare module '#og-image-cache' {
           NitroApp: `_ogImageCacheBackendWarned?: boolean
 _ogImageIconsData?: OgImageIconsData`,
           NitroRuntimeConfig: `'nuxt-og-image': OgImageRuntimeConfig
-ogImage?: {
-  secret?: string
+ogImage: {
+  secret: string
 }`
         },
         routeRules: "ogImage?: false | OgImageOptions & Record<string, any>",
@@ -5074,7 +5218,10 @@ Or pin to a specific version in package.json:
     const resolvedOgComponentPaths = [];
     let allNuxtComponents = [];
     const ogImageTransformedFiles = /* @__PURE__ */ new Set();
-    const convertedWoff2Files = /* @__PURE__ */ new Map();
+    const fontState = {
+      sourceMap: /* @__PURE__ */ new Map(),
+      fallbackMap: /* @__PURE__ */ new Map()
+    };
     const ogImageComponentCtx = { components: [], detectedRenderers: /* @__PURE__ */ new Set() };
     nuxt.hook("modules:done", () => {
       addVitePlugin(ComponentImportRewritePlugin.vite({
@@ -5101,7 +5248,7 @@ Or pin to a specific version in package.json:
           const p = loadCssMetadata().then(async () => {
             let knownFamilies;
             if (hasNuxtFonts) {
-              const resolvedFonts = await parseFontsFromTemplate(nuxt, { convertedWoff2Files });
+              const resolvedFonts = await parseFontsFromTemplate(nuxt, { fontState });
               knownFamilies = buildFontFamilyCanonicalMap(resolvedFonts.map((f) => f.family));
             }
             const families = resolveFontFamilies([...reqs.familyClasses], [...reqs.familyNames], cssMetadata.fontVars, knownFamilies);
@@ -5567,9 +5714,9 @@ export function getIslandHash({ name, props, context, source }) {
 }`;
     };
     nuxt.options.nitro.publicAssets ||= [];
-    const staticFontsTtfDir = join(nuxt.options.buildDir, "cache", "og-image", "fonts-ttf");
+    const staticFontCacheDir = getStaticFontCacheDir(nuxt.options.buildDir);
     nuxt.options.nitro.publicAssets.push({
-      dir: staticFontsTtfDir,
+      dir: staticFontCacheDir,
       baseURL: "/_og-static-fonts",
       maxAge: 60 * 60 * 24 * 365
     });
@@ -5607,24 +5754,26 @@ export const resolve = (import.meta.dev || import.meta.prerender) ? devResolve :
       if (hasNuxtFonts && fontContext) {
         persistFontUrlMapping({ fontContext, buildDir: nuxt.options.buildDir, logger });
       }
-      if (!fontProcessingDone && convertedWoff2Files.size === 0 && (hasSatoriRenderer() || hasTakumiRenderer()) && hasNuxtFonts) {
+      if (!fontProcessingDone && hasSatoriRenderer() && hasNuxtFonts) {
         if (pendingFontRequirements.length > 0)
           await Promise.all(pendingFontRequirements);
-        await convertWoff2ToTtf({
+        await prepareWoff2Fonts({
           nuxt,
           logger,
           fontRequirements: fontRequirementsState,
-          convertedWoff2Files,
+          fontState,
+          nuxtFontsContext: fontContext,
           fontSubsets: config.fontSubsets,
           warnOnMissingStaticFonts: hasSatoriRenderer()
         });
+        fontProcessingDone = true;
       }
       const fonts = await resolveOgImageFonts({
         nuxt,
         hasNuxtFonts,
         hasSatoriRenderer: hasSatoriRenderer(),
         hasTakumiRenderer: hasTakumiRenderer(),
-        convertedWoff2Files,
+        fontState,
         fontSubsets: config.fontSubsets,
         fontRequirements: fontRequirementsState,
         tw4FontVars: cssMetadata.fontVars,
@@ -5634,7 +5783,7 @@ export const resolve = (import.meta.dev || import.meta.prerender) ? devResolve :
       return `export default ${JSON.stringify(fonts)}`;
     };
     nuxt.options.nitro.virtual["#og-image/fonts-available"] = async () => {
-      const fonts = hasNuxtFonts ? await parseFontsFromTemplate(nuxt, { convertedWoff2Files, requiredWeights: fontRequirementsState.weights }) : [];
+      const fonts = hasNuxtFonts ? await parseFontsFromTemplate(nuxt, { fontState, requiredWeights: fontRequirementsState.weights }) : [];
       return `export default ${JSON.stringify(fonts)}`;
     };
     nuxt.options.nitro.virtual["#og-image/font-requirements"] = async () => {
@@ -5669,7 +5818,8 @@ export const tw4Colors = ${JSON.stringify(cssMetadata.colors)}`;
     };
     nuxt.options.nitro.virtual["#og-image-virtual/build-dir.mjs"] = () => {
       return `export const buildDir = ${JSON.stringify(nuxt.options.buildDir)}
-export const rootDir = ${JSON.stringify(nuxt.options.rootDir)}`;
+export const rootDir = ${JSON.stringify(nuxt.options.rootDir)}
+export const staticFontCacheDir = ${JSON.stringify(getStaticFontCacheDir(nuxt.options.buildDir))}`;
     };
     if (hasNuxtFonts) {
       nuxt.hook("fonts:public-asset-context", (ctx) => {
@@ -5677,16 +5827,17 @@ export const rootDir = ${JSON.stringify(nuxt.options.rootDir)}`;
       });
       nuxt.hook("vite:compiled", async () => {
         persistFontUrlMapping({ fontContext, buildDir: nuxt.options.buildDir, logger });
-        if (fontProcessingDone || !hasSatoriRenderer() && !hasTakumiRenderer())
+        if (fontProcessingDone || !hasSatoriRenderer())
           return;
         if (pendingFontRequirements.length === 0)
           return;
         await Promise.all(pendingFontRequirements);
-        await convertWoff2ToTtf({
+        await prepareWoff2Fonts({
           nuxt,
           logger,
           fontRequirements: fontRequirementsState,
-          convertedWoff2Files,
+          fontState,
+          nuxtFontsContext: fontContext,
           fontSubsets: config.fontSubsets,
           warnOnMissingStaticFonts: hasSatoriRenderer()
         });

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "nuxt-og-image",
   "type": "module",
-  "version": "6.7.6",
+  "version": "6.7.7",
   "description": "Enlightened OG Image generation for Nuxt.",
   "author": {
     "website": "https://harlanzw.com",
@@ -111,8 +111,8 @@
   },
   "dependencies": {
     "@clack/prompts": "^1.7.0",
-    "@nuxt/kit": "^4.5.1",
-    "@vue/compiler-sfc": "^3.5.40",
+    "@nuxt/kit": "^4.5.2",
+    "@vue/compiler-sfc": "^3.5.41",
     "chrome-launcher": "^1.2.1",
     "consola": "^3.4.2",
     "defu": "^6.1.7",
@@ -123,13 +123,13 @@
     "magic-string": "^1.1.0",
     "magicast": "^0.5.4",
     "mocked-exports": "^0.1.1",
-    "nuxt-site-config": "^4.1.4",
-    "nuxtseo-shared": "^5.3.8",
+    "nuxt-site-config": "^4.2.0",
+    "nuxtseo-shared": "^5.3.12",
     "nypm": "^0.6.9",
     "object-identity": "^0.2.3",
     "ofetch": "^1.5.1",
     "ohash": "^2.0.11",
-    "oxc-parser": "^0.142.0",
+    "oxc-parser": "^0.143.0",
     "oxc-walker": "^1.1.1",
     "pathe": "^2.0.3",
     "pkg-types": "^2.3.1",
@@ -142,10 +142,10 @@
     "unplugin": "^3.3.0"
   },
   "devDependencies": {
-    "@antfu/eslint-config": "^9.2.0",
+    "@antfu/eslint-config": "^9.3.0",
     "@fontsource/noto-sans-sc": "^5.3.0",
     "@iconify-json/carbon": "^1.2.25",
-    "@iconify-json/logos": "^1.2.11",
+    "@iconify-json/logos": "^1.2.12",
     "@iconify-json/noto": "^1.2.7",
     "@iconify-json/ri": "^1.2.10",
     "@iconify-json/tabler": "^1.2.38",
@@ -167,11 +167,11 @@
     "@resvg/resvg-js": "^2.6.2",
     "@resvg/resvg-wasm": "^2.6.2",
     "@tailwindcss/vite": "^4.3.3",
-    "@takumi-rs/core": "^2.5.4",
+    "@takumi-rs/core": "^2.5.11",
     "@takumi-rs/core-v1": "npm:@takumi-rs/core@1.8.7",
-    "@takumi-rs/helpers": "^2.5.4",
+    "@takumi-rs/helpers": "^2.5.11",
     "@takumi-rs/helpers-v1": "npm:@takumi-rs/helpers@1.8.7",
-    "@takumi-rs/wasm": "^2.5.4",
+    "@takumi-rs/wasm": "^2.5.11",
     "@takumi-rs/wasm-v1": "npm:@takumi-rs/wasm@1.8.7",
     "@unocss/config": "^66.7.5",
     "@unocss/core": "^66.7.5",
@@ -180,22 +180,21 @@
     "@unocss/preset-wind": "^66.7.5",
     "@unocss/preset-wind4": "^66.7.5",
     "@vitejs/plugin-vue": "^6.0.8",
-    "@vue/compiler-core": "^3.5.40",
+    "@vue/compiler-core": "^3.5.41",
     "@vueuse/nuxt": "^14.4.0",
     "birpc": "^4.0.0",
-    "bumpp": "^12.1.1",
-    "eslint": "^10.8.0",
+    "bumpp": "^12.2.0",
+    "eslint": "^10.8.1",
     "eslint-plugin-harlanzw": "^0.17.1",
     "fontless": "^0.2.1",
-    "get-image-colors": "^4.0.1",
-    "globby": "^16.2.2",
-    "happy-dom": "^20.11.1",
+    "globby": "^16.2.3",
+    "happy-dom": "^20.11.2",
     "hookable": "^6.1.1",
     "jest-image-snapshot": "^6.5.2",
     "lightningcss": "^1.33.0",
     "nitropack": "^2.13.4",
-    "nuxt": "^4.5.1",
-    "nuxtseo-layer-devtools": "^5.3.8",
+    "nuxt": "^4.5.2",
+    "nuxtseo-layer-devtools": "^5.3.12",
     "playwright": "^1.62.1",
     "playwright-core": "^1.62.1",
     "sass": "^1.102.0",
@@ -208,9 +207,9 @@
     "unifont": "^0.7.4",
     "unocss": "^66.7.5",
     "vitest": "^4.1.10",
-    "vue": "^3.5.40",
+    "vue": "^3.5.41",
     "vue-tsc": "^3.3.9",
-    "wrangler": "^4.118.0",
+    "wrangler": "^4.120.0",
     "yoga-wasm-web": "^0.3.3",
     "zod": "^4.4.3"
   },
@@ -230,7 +229,7 @@
     "typecheck": "pnpm stub && nuxt typecheck",
     "test": "pnpm run prepare:fixtures && vitest",
     "test:run": "pnpm test -- --run && pnpm test:nuxt5",
-    "test:nuxt5": "pnpm pack --out test/fixtures/nuxt5/nuxt-og-image.tgz && pnpm --dir test/fixtures/nuxt5 install --frozen-lockfile && pnpm --dir test/fixtures/nuxt5 test",
+    "test:nuxt5": "pnpm pack --out test/fixtures/nuxt5/nuxt-og-image.tgz && pnpm install --dir test/fixtures/nuxt5 --no-frozen-lockfile --force --update-checksums && pnpm --dir test/fixtures/nuxt5 test",
     "test:chrome": "HAS_CHROME=true vitest",
     "test:packed-install": "node scripts/smoke-packed-install.mjs",
     "test:takumi:e2e": "node scripts/test-takumi-e2e.mjs",