nuxt-og-image 5.1.12 → 6.0.0-beta.1

package/dist/runtime/server/og-image/bindings/takumi/wasm.js

@@ -0,0 +1,6 @@
+import init, { Renderer } from "@takumi-rs/wasm";
+const wasmBinary = import("@takumi-rs/wasm/takumi_wasm_bg.wasm?module").then((m) => m.default || m);
+export default {
+  initWasmPromise: wasmBinary.then((wasm) => init({ module_or_path: wasm })),
+  Renderer
+};

package/dist/runtime/server/og-image/cache/buildCache.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Get the component hash for a given component name
+ */
+export declare function getComponentHash(componentName: string): string;
+/**
+ * Generate a cache key that includes options, component hash, and version
+ */
+export declare function generateBuildCacheKey(options: Record<string, any>, extension: string): string;
+/**
+ * Check if an image exists in the build cache
+ */
+export declare function getBuildCachedImage(options: Record<string, any>, extension: string): Buffer | null;
+/**
+ * Save an image to the build cache
+ */
+export declare function setBuildCachedImage(options: Record<string, any>, extension: string, data: Buffer | Uint8Array, maxAgeSeconds: number): void;

package/dist/runtime/server/og-image/cache/buildCache.js

@@ -0,0 +1,48 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { componentNames } from "#og-image-virtual/component-names.mjs";
+import { join } from "pathe";
+import { hashOgImageOptions } from "../../../shared/urlEncoding.js";
+import { useOgImageRuntimeConfig } from "../../utils.js";
+export function getComponentHash(componentName) {
+  const components = componentNames;
+  const component = components.find(
+    (c) => c.pascalName === componentName || c.kebabName === componentName
+  );
+  return component?.hash || "";
+}
+export function generateBuildCacheKey(options, extension) {
+  const { version } = useOgImageRuntimeConfig();
+  const componentHash = getComponentHash(options.component || "NuxtSeo");
+  const hash = hashOgImageOptions(options, componentHash, version);
+  return `${hash}.${extension}`;
+}
+export function getBuildCachedImage(options, extension) {
+  const { buildCacheDir } = useOgImageRuntimeConfig();
+  if (!buildCacheDir)
+    return null;
+  const cacheKey = generateBuildCacheKey(options, extension);
+  const cachePath = join(buildCacheDir, cacheKey);
+  if (!existsSync(cachePath))
+    return null;
+  const cached = JSON.parse(readFileSync(cachePath, "utf-8"));
+  if (cached.expiresAt && cached.expiresAt < Date.now()) {
+    return null;
+  }
+  return Buffer.from(cached.data, "base64");
+}
+export function setBuildCachedImage(options, extension, data, maxAgeSeconds) {
+  const { buildCacheDir } = useOgImageRuntimeConfig();
+  if (!buildCacheDir)
+    return;
+  const cacheKey = generateBuildCacheKey(options, extension);
+  const cachePath = join(buildCacheDir, cacheKey);
+  if (!existsSync(buildCacheDir)) {
+    mkdirSync(buildCacheDir, { recursive: true });
+  }
+  const cached = {
+    data: Buffer.from(data).toString("base64"),
+    expiresAt: Date.now() + maxAgeSeconds * 1e3,
+    createdAt: Date.now()
+  };
+  writeFileSync(cachePath, JSON.stringify(cached));
+}

package/dist/runtime/server/og-image/cache/lru.d.ts

@@ -4,6 +4,6 @@ export declare const htmlPayloadCache: Storage<{
     expiresAt: number;
     value: OgImageOptions;
 }>;
-export declare const prerenderOptionsCache: Storage<OgImageOptions> | undefined;
-export declare const fontCache: Storage<BufferSource>;
+export declare const prerenderOptionsCache: Storage<OgImageOptions | [string, OgImageOptions][]> | undefined;
 export declare const emojiCache: Storage<string>;
+export declare const fontCache: Storage<string>;

package/dist/runtime/server/og-image/cache/lru.js

@@ -7,9 +7,9 @@ export const htmlPayloadCache = createStorage({
 export const prerenderOptionsCache = import.meta.prerender ? createStorage({
   driver: lruCacheDriver({ max: 1e4 })
 }) : void 0;
-export const fontCache = createStorage({
-  driver: lruCacheDriver({ max: 10 })
-});
 export const emojiCache = createStorage({
   driver: lruCacheDriver({ max: 1e3 })
 });
+export const fontCache = createStorage({
+  driver: lruCacheDriver({ max: 100 })
+});

package/dist/runtime/server/og-image/cache/mock.d.ts

@@ -4,6 +4,5 @@ export declare const htmlPayloadCache: Storage<{
     expiresAt: number;
     value: OgImageOptions;
 }>;
-export declare const prerenderOptionsCache: Storage<OgImageOptions> | undefined;
-export declare const fontCache: Storage<OgImageOptions<"NuxtSeo">>;
+export declare const prerenderOptionsCache: Storage<OgImageOptions | [string, OgImageOptions][]> | undefined;
 export declare const emojiCache: Storage<string>;

package/dist/runtime/server/og-image/cache/mock.js

@@ -5,5 +5,4 @@ const storage = createStorage({
 });
 export const htmlPayloadCache = storage;
 export const prerenderOptionsCache = storage;
-export const fontCache = storage;
 export const emojiCache = storage;

package/dist/runtime/server/og-image/chromium/screenshot.js

@@ -1,10 +1,11 @@
 import { useNitroOrigin } from "#site-config/server/composables";
-import { joinURL, withQuery } from "ufo";
+import { withQuery } from "ufo";
 import { toValue } from "vue";
+import { buildOgImageUrl } from "../../../shared.js";
 import { useOgImageRuntimeConfig } from "../../utils.js";
 export async function createScreenshot({ basePath, e, options, extension }, browser) {
-  const { colorPreference } = useOgImageRuntimeConfig();
-  const path = options.component === "PageScreenshot" ? basePath : joinURL("/__og-image__/image", basePath, `og.html`);
+  const { colorPreference, defaults } = useOgImageRuntimeConfig();
+  const path = options.component === "PageScreenshot" ? basePath : buildOgImageUrl(options, "html", false, defaults).url;
   const page = await browser.newPage({
     colorScheme: colorPreference || "no-preference",
     baseURL: useNitroOrigin(e)

package/dist/runtime/server/og-image/context.d.ts

@@ -1,5 +1,4 @@
 import type { H3Error, H3Event } from 'h3';
-import type { OgImageOptions, OgImageRenderEventContext } from '../../types.js';
-export declare function resolvePathCacheKey(e: H3Event, path: string): string;
+import type { OgImageRenderEventContext } from '../../types.js';
+export declare function resolvePathCacheKey(e: H3Event, path: string, includeQuery?: boolean): string;
 export declare function resolveContext(e: H3Event): Promise<H3Error | OgImageRenderEventContext>;
-export declare function extractAndNormaliseOgImageOptions(html: string): OgImageOptions | false;

package/dist/runtime/server/og-image/context.js

@@ -1,35 +1,32 @@
-import { htmlPayloadCache, prerenderOptionsCache } from "#og-image-cache";
-import { theme } from "#og-image-virtual/unocss-config.mjs";
-import { useSiteConfig } from "#site-config/server/composables/useSiteConfig";
+import { prerenderOptionsCache } from "#og-image-cache";
+import { getSiteConfig } from "#site-config/server/composables/getSiteConfig";
 import { createSitePathResolver } from "#site-config/server/composables/utils";
-import { createGenerator } from "@unocss/core";
-import presetWind from "@unocss/preset-wind3";
 import { defu } from "defu";
-import { parse } from "devalue";
 import { createError, getQuery } from "h3";
 import { useNitroApp } from "nitropack/runtime";
 import { hash } from "ohash";
 import { parseURL, withoutLeadingSlash, withoutTrailingSlash, withQuery } from "ufo";
 import { normalizeKey } from "unstorage";
-import { separateProps } from "../../shared.js";
-import { decodeObjectHtmlEntities } from "../util/encoding.js";
+import { decodeOgImageParams, separateProps } from "../../shared.js";
+import { autoEjectCommunityTemplate } from "../util/auto-eject.js";
 import { createNitroRouteRuleMatcher } from "../util/kit.js";
-import { logger } from "../util/logger.js";
 import { normaliseOptions } from "../util/options.js";
 import { useOgImageRuntimeConfig } from "../utils.js";
-import { useChromiumRenderer, useSatoriRenderer } from "./instances.js";
-export function resolvePathCacheKey(e, path) {
-  const siteConfig = useSiteConfig(e, {
+import { useChromiumRenderer, useSatoriRenderer, useTakumiRenderer } from "./instances.js";
+export function resolvePathCacheKey(e, path, includeQuery = false) {
+  const siteConfig = getSiteConfig(e, {
     resolveRefs: true
   });
   const basePath = withoutTrailingSlash(withoutLeadingSlash(normalizeKey(path)));
+  const hashParts = [
+    basePath,
+    import.meta.prerender ? "" : siteConfig.url
+  ];
+  if (includeQuery)
+    hashParts.push(hash(getQuery(e)));
   return [
     !basePath || basePath === "/" ? "index" : basePath,
-    hash([
-      basePath,
-      import.meta.prerender ? "" : siteConfig.url,
-      hash(getQuery(e))
-    ])
+    hash(hashParts)
   ].join(":");
 }
 export async function resolveContext(e) {
@@ -52,6 +49,30 @@ export async function resolveContext(e) {
       statusMessage: `[Nuxt OG Image] Unknown OG Image type ${extension}.`
     });
   }
+  const encodedSegment = path.split("/").pop().replace(`.${extension}`, "");
+  const hashMatch = encodedSegment.match(/^o_([a-z0-9]+)$/i);
+  let urlOptions = {};
+  if (hashMatch) {
+    const optionsHash = hashMatch[1];
+    if (import.meta.prerender && prerenderOptionsCache) {
+      const cached = await prerenderOptionsCache.getItem(`hash:${optionsHash}`);
+      if (cached && typeof cached === "object") {
+        urlOptions = cached;
+      } else {
+        return createError({
+          statusCode: 404,
+          statusMessage: `[Nuxt OG Image] Options not found for hash: ${optionsHash}. This can happen if the page hasn't been prerendered yet.`
+        });
+      }
+    } else {
+      return createError({
+        statusCode: 400,
+        statusMessage: `[Nuxt OG Image] Hash-based URLs (o_${optionsHash}) are only supported during prerendering. Use encoded params or query params for runtime.`
+      });
+    }
+  } else {
+    urlOptions = decodeOgImageParams(encodedSegment);
+  }
   const query = getQuery(e);
   let queryParams = {};
   for (const k in query) {
@@ -61,223 +82,63 @@ export async function resolveContext(e) {
     if (v.startsWith("{")) {
       try {
         queryParams[k] = JSON.parse(v);
-      } catch (error) {
-        if (import.meta.dev) {
-          logger.error(`[Nuxt OG Image] Invalid JSON in ${k} parameter: ${error.message}`);
-        }
+      } catch {
       }
     } else {
       queryParams[k] = v;
     }
   }
   queryParams = separateProps(queryParams);
-  let basePath = withoutTrailingSlash(
-    path.replace(`/__og-image__/image`, "").replace(`/__og-image__/static`, "").replace(`/og.${extension}`, "")
-  );
-  if (queryParams._query && typeof queryParams._query === "object")
-    basePath = withQuery(basePath, queryParams._query);
+  const basePath = withoutTrailingSlash(urlOptions._path || "/");
+  delete urlOptions._path;
+  delete urlOptions._hash;
+  const basePathWithQuery = queryParams._query && typeof queryParams._query === "object" ? withQuery(basePath, queryParams._query) : basePath;
   const isDebugJsonPayload = extension === "json" && runtimeConfig.debug;
-  const key = resolvePathCacheKey(e, basePath);
-  let options = queryParams.options;
-  if (!options) {
-    if (import.meta.prerender) {
-      options = await prerenderOptionsCache.getItem(key);
-    }
-    if (!options) {
-      const payload = await fetchPathHtmlAndExtractOptions(e, basePath, key);
-      if (payload instanceof Error)
-        return payload;
-      options = payload;
-    }
-  }
-  delete queryParams.options;
   const routeRuleMatcher = createNitroRouteRuleMatcher();
   const routeRules = routeRuleMatcher(basePath);
-  if (typeof routeRules.ogImage === "undefined" && !options) {
-    return createError({
-      statusCode: 400,
-      statusMessage: "The route is missing the Nuxt OG Image payload or route rules."
-    });
-  }
   const ogImageRouteRules = separateProps(routeRules.ogImage);
-  options = defu(queryParams, options, ogImageRouteRules, runtimeConfig.defaults);
+  const options = defu(queryParams, urlOptions, ogImageRouteRules, runtimeConfig.defaults);
   if (!options) {
     return createError({
       statusCode: 404,
       statusMessage: "[Nuxt OG Image] OG Image not found."
     });
   }
+  const normalised = normaliseOptions(options);
+  if (normalised.component?.category === "community")
+    autoEjectCommunityTemplate(normalised.component, runtimeConfig);
+  const rendererType = normalised.renderer;
+  const key = normalised.options.cacheKey || resolvePathCacheKey(e, basePathWithQuery, runtimeConfig.cacheQueryParams);
   let renderer;
-  switch (options.renderer) {
+  switch (rendererType) {
     case "satori":
       renderer = await useSatoriRenderer();
       break;
     case "chromium":
       renderer = await useChromiumRenderer();
       break;
+    case "takumi":
+      renderer = await useTakumiRenderer();
+      break;
   }
   if (!renderer || renderer.__mock__) {
     throw createError({
       statusCode: 400,
-      statusMessage: `[Nuxt OG Image] Renderer ${options.renderer} is not enabled.`
+      statusMessage: `[Nuxt OG Image] Renderer "${rendererType}" is not available. Component "${normalised.component?.pascalName}" requires the ${rendererType} renderer but it's not bundled for this preset.`
     });
   }
-  const unocss = await createGenerator({ theme }, {
-    presets: [
-      presetWind()
-    ]
-  });
   const ctx = {
-    unocss,
     e,
     key,
     renderer,
-    isDebugJsonPayload,
+    isDevToolsContextRequest: isDebugJsonPayload,
     runtimeConfig,
     publicStoragePath: runtimeConfig.publicStoragePath,
     extension,
     basePath,
-    options: normaliseOptions(options),
+    options: normalised.options,
     _nitro: useNitroApp()
   };
   await ctx._nitro.hooks.callHook("nuxt-og-image:context", ctx);
   return ctx;
 }
-const PAYLOAD_REGEX = /<script.+id="nuxt-og-image-options"[^>]*>(.+?)<\/script>/;
-function getPayloadFromHtml(html) {
-  const match = String(html).match(PAYLOAD_REGEX);
-  return match ? String(match[1]) : null;
-}
-export function extractAndNormaliseOgImageOptions(html) {
-  const _payload = getPayloadFromHtml(html);
-  let options = false;
-  try {
-    const payload2 = parse(_payload || "{}");
-    Object.entries(payload2).forEach(([key, value]) => {
-      if (!value && value !== 0)
-        delete payload2[key];
-    });
-    options = payload2;
-  } catch (e) {
-    if (import.meta.dev)
-      console.warn("Failed to parse #nuxt-og-image-options", e, options);
-  }
-  if (options && typeof options?.props?.description === "undefined") {
-    const description = html.match(/<meta[^>]+name="description"[^>]*>/)?.[0];
-    if (description) {
-      const [, content] = description.match(/content="([^"]+)"/) || [];
-      if (content && !options.props.description)
-        options.props.description = content;
-    }
-  }
-  const payload = decodeObjectHtmlEntities(options || {});
-  if (import.meta.dev) {
-    const socialPreview = {};
-    const socialMetaTags = html.match(/<meta[^>]+(property|name)="(twitter|og):([^"]+)"[^>]*>/g);
-    if (socialMetaTags) {
-      socialMetaTags.forEach((tag) => {
-        const [, , type, key] = tag.match(/(property|name)="(twitter|og):([^"]+)"/);
-        const value = tag.match(/content="([^"]+)"/)?.[1];
-        if (!value)
-          return;
-        if (!socialPreview[type])
-          socialPreview[type] = {};
-        socialPreview[type][key] = value;
-      });
-    }
-    payload.socialPreview = socialPreview;
-  }
-  return payload;
-}
-async function doFetchWithErrorHandling(fetch, path) {
-  const res = await fetch(path, {
-    redirect: "follow",
-    headers: {
-      accept: "text/html"
-    }
-  }).catch((err) => {
-    return err;
-  });
-  let errorDescription;
-  if (res.status >= 300 && res.status < 400) {
-    if (res.headers.has("location")) {
-      return await doFetchWithErrorHandling(fetch, res.headers.get("location") || "");
-    }
-    errorDescription = `${res.status} redirected to ${res.headers.get("location") || "unknown"}`;
-  } else if (res.status >= 500) {
-    errorDescription = `${res.status} error: ${res.statusText}`;
-  }
-  if (errorDescription) {
-    return [null, createError({
-      statusCode: 500,
-      statusMessage: `[Nuxt OG Image] Failed to parse \`${path}\` for og-image extraction. ${errorDescription}`
-    })];
-  }
-  if (res._data) {
-    return [res._data, null];
-  } else if (res.text) {
-    return [await res.text(), null];
-  }
-  return ["", null];
-}
-async function fetchPathHtmlAndExtractOptions(e, path, key) {
-  const cachedHtmlPayload = await htmlPayloadCache.getItem(key);
-  if (!import.meta.dev && cachedHtmlPayload && cachedHtmlPayload.expiresAt < Date.now())
-    return cachedHtmlPayload.value;
-  let _payload = null;
-  let [html, err] = await doFetchWithErrorHandling(e.fetch, path);
-  if (err) {
-    logger.warn(err);
-  } else {
-    _payload = getPayloadFromHtml(html);
-  }
-  if (!_payload) {
-    const [fallbackHtml, err2] = await doFetchWithErrorHandling(globalThis.$fetch.raw, path);
-    if (err2) {
-      return err2;
-    }
-    _payload = getPayloadFromHtml(fallbackHtml);
-    if (_payload) {
-      html = fallbackHtml;
-    }
-  }
-  if (!html) {
-    return createError({
-      statusCode: 500,
-      statusMessage: `[Nuxt OG Image] Failed to read the path ${path} for og-image extraction, returning no HTML.`
-    });
-  }
-  if (!_payload) {
-    const payload2 = extractAndNormaliseOgImageOptions(html);
-    if (payload2 && typeof payload2 === "object" && payload2.socialPreview?.og?.image) {
-      const image = payload2.socialPreview.og.image;
-      const p = {
-        custom: true,
-        url: typeof image === "string" ? image : image
-      };
-      if (typeof image === "object" && image["image:width"]) {
-        p.width = image["image:width"];
-      }
-      if (typeof image === "object" && image["image:height"]) {
-        p.height = image["image:height"];
-      }
-      return p;
-    }
-    return createError({
-      statusCode: 500,
-      statusMessage: `[Nuxt OG Image] HTML response from ${path} is missing the #nuxt-og-image-options script tag. Make sure you have defined an og image for this page.`
-    });
-  }
-  const payload = extractAndNormaliseOgImageOptions(html);
-  if (!import.meta.dev && payload) {
-    await htmlPayloadCache.setItem(key, {
-      // 60 minutes for prerender, 10 seconds for runtime
-      expiresAt: Date.now() + 1e3 * (import.meta.prerender ? 60 * 60 : 10),
-      value: payload
-    });
-  }
-  return typeof payload === "object" ? payload : createError({
-    statusCode: 500,
-    statusMessage: "[Nuxt OG Image] Invalid payload type."
-  });
-}

package/dist/runtime/server/og-image/devtools.d.ts

@@ -0,0 +1,10 @@
+import type { H3Error, H3Event } from 'h3';
+import type { DevToolsMetaDataExtraction, OgImageOptions } from '../../types.js';
+export interface DevToolsExtractPayload {
+    options: OgImageOptions[];
+    socialPreview: {
+        root: Record<string, string>;
+        images: DevToolsMetaDataExtraction[];
+    };
+}
+export declare function fetchPathHtmlAndExtractOptions(e: H3Event, path: string, cacheKey: string): Promise<H3Error | DevToolsExtractPayload>;

package/dist/runtime/server/og-image/devtools.js

@@ -0,0 +1,74 @@
+import { htmlPayloadCache } from "#og-image-cache";
+import { parse } from "devalue";
+import { createError } from "h3";
+import { extractSocialPreviewTags } from "../../pure.js";
+import { logger } from "../util/logger.js";
+const PAYLOAD_REGEX = /<script.+id="nuxt-og-image-options"[^>]*>(.+?)<\/script>/;
+function extractOptionsFromHtml(html) {
+  const match = String(html).match(PAYLOAD_REGEX);
+  if (!match?.[1])
+    return [];
+  return parse(match[1]);
+}
+async function doFetchWithErrorHandling(fetch, path) {
+  const res = await fetch(path, {
+    redirect: "follow",
+    headers: {
+      accept: "text/html"
+    }
+  }).catch((err) => {
+    return err;
+  });
+  let errorDescription;
+  if (res.status >= 300 && res.status < 400) {
+    if (res.headers.has("location")) {
+      return await doFetchWithErrorHandling(fetch, res.headers.get("location") || "");
+    }
+    errorDescription = `${res.status} redirected to ${res.headers.get("location") || "unknown"}`;
+  } else if (res.status >= 400) {
+    errorDescription = `${res.status} error: ${res.statusText}`;
+  }
+  if (errorDescription) {
+    return [null, createError({
+      statusCode: 500,
+      statusMessage: `[Nuxt OG Image] Failed to parse \`${path}\` for og-image extraction. ${errorDescription}`
+    })];
+  }
+  return [res._data || await res.text(), null];
+}
+export async function fetchPathHtmlAndExtractOptions(e, path, cacheKey) {
+  const cachedHtmlPayload = await htmlPayloadCache.getItem(cacheKey);
+  if (!import.meta.dev && cachedHtmlPayload && cachedHtmlPayload.expiresAt > Date.now())
+    return cachedHtmlPayload.value;
+  let [html, err] = await doFetchWithErrorHandling(e.fetch, path);
+  if (err) {
+    logger.warn(err);
+  }
+  if (!html) {
+    const [fallbackHtml, err2] = await doFetchWithErrorHandling(globalThis.$fetch.raw, path);
+    if (err2) {
+      return err2;
+    }
+    html = fallbackHtml;
+  }
+  if (!html) {
+    return createError({
+      statusCode: 500,
+      statusMessage: `[Nuxt OG Image] Failed to read the path ${path} for og-image extraction, returning no HTML.`
+    });
+  }
+  const [root, images] = extractSocialPreviewTags(html);
+  const options = extractOptionsFromHtml(html);
+  const payload = {
+    options,
+    socialPreview: { root, images }
+  };
+  if (!import.meta.dev && payload) {
+    await htmlPayloadCache.setItem(cacheKey, {
+      // 60 minutes for prerender, 10 seconds for runtime
+      expiresAt: Date.now() + 1e3 * (import.meta.prerender ? 60 * 60 : 10),
+      value: payload
+    });
+  }
+  return payload;
+}

package/dist/runtime/server/og-image/fonts.d.ts

@@ -0,0 +1,6 @@
+import type { H3Event } from 'h3';
+import type { SatoriFontConfig } from '../../types.js';
+export interface LoadFontsOptions {
+    supportsWoff2: boolean;
+}
+export declare function loadAllFonts(event: H3Event, options: LoadFontsOptions): Promise<SatoriFontConfig[]>;

package/dist/runtime/server/og-image/fonts.js

@@ -0,0 +1,41 @@
+import { resolve } from "#og-image-virtual/public-assets.mjs";
+import resolvedFonts from "#og-image/fonts";
+import { fontCache } from "./cache/lru.js";
+async function loadFont(event, font) {
+  const cacheKey = `${font.family}-${font.weight}-${font.style}`;
+  const cached = await fontCache.getItem(cacheKey);
+  if (cached) {
+    const data2 = Buffer.from(cached, "base64");
+    return data2;
+  }
+  const data = await resolve(event, font).catch((err) => {
+    console.warn(`[nuxt-og-image] Failed to load font ${font.family}: ${err.message}`);
+    return null;
+  });
+  if (!data)
+    return null;
+  const base64 = Buffer.from(data).toString("base64");
+  await fontCache.setItem(cacheKey, base64);
+  return data;
+}
+export async function loadAllFonts(event, options) {
+  const fonts = resolvedFonts.filter((f) => {
+    if (options.supportsWoff2)
+      return true;
+    return !f.src.endsWith(".woff2");
+  });
+  const results = await Promise.all(
+    fonts.map(async (f) => {
+      const data = await loadFont(event, f);
+      if (!data)
+        return null;
+      return {
+        ...f,
+        name: f.family,
+        cacheKey: `${f.family}-${f.weight}-${f.style}`,
+        data
+      };
+    })
+  );
+  return results.filter((f) => f !== null);
+}

package/dist/runtime/server/og-image/instances.d.ts

@@ -1,2 +1,3 @@
 export declare function useSatoriRenderer(): Promise<import("../../types.js").Renderer>;
 export declare function useChromiumRenderer(): Promise<import("../../types.js").Renderer>;
+export declare function useTakumiRenderer(): Promise<import("../../types.js").Renderer>;

package/dist/runtime/server/og-image/instances.js

@@ -1,5 +1,6 @@
 const satoriRendererInstance = { instance: void 0 };
 const chromiumRendererInstance = { instance: void 0 };
+const takumiRendererInstance = { instance: void 0 };
 export async function useSatoriRenderer() {
   satoriRendererInstance.instance = satoriRendererInstance.instance || await import("#og-image/renderers/satori").then((m) => m.default);
   return satoriRendererInstance.instance;
@@ -8,3 +9,7 @@ export async function useChromiumRenderer() {
   chromiumRendererInstance.instance = chromiumRendererInstance.instance || await import("#og-image/renderers/chromium").then((m) => m.default);
   return chromiumRendererInstance.instance;
 }
+export async function useTakumiRenderer() {
+  takumiRendererInstance.instance = takumiRendererInstance.instance || await import("#og-image/renderers/takumi").then((m) => m.default);
+  return takumiRendererInstance.instance;
+}

package/dist/runtime/server/og-image/satori/instances.d.ts

@@ -1,41 +1,6 @@
 import type _satori from 'satori';
 import type _sharp from 'sharp';
-export declare function useResvg(): Promise<new (svg: Uint8Array | string, options?: import("@resvg/resvg-wasm").ResvgRenderOptions) => {
-    free(): void;
-    render(): {
-        free(): void;
-        asPng(): Uint8Array;
-        readonly height: number;
-        readonly pixels: Uint8Array;
-        readonly width: number;
-    };
-    toString(): string;
-    innerBBox(): {
-        free(): void;
-        height: number;
-        width: number;
-        x: number;
-        y: number;
-    } | undefined;
-    getBBox(): {
-        free(): void;
-        height: number;
-        width: number;
-        x: number;
-        y: number;
-    } | undefined;
-    cropByBBox(bbox: {
-        free(): void;
-        height: number;
-        width: number;
-        x: number;
-        y: number;
-    }): void;
-    imagesToResolve(): any[];
-    resolveImage(href: string, buffer: Uint8Array): void;
-    readonly height: number;
-    readonly width: number;
-}>;
+export declare function useResvg(): Promise<any>;
 export declare function useSatori(): Promise<typeof _satori>;
 export declare function useSharp(): Promise<typeof _sharp>;
 export declare function useCssInline(): Promise<any>;