nuxt-og-image 6.4.2 → 6.4.3

package/dist/runtime/server/og-image/core/plugins/imageSrc.js

@@ -3,6 +3,8 @@ import { useStorage } from "nitropack/runtime";
 import { withBase, withoutLeadingSlash } from "ufo";
 import { toBase64Image } from "../../../../shared.js";
 import { decodeHtml } from "../../../util/encoding.js";
+import { fetchLocalAsset } from "../../../util/fetchLocalAsset.js";
+import { getFetchTimeout } from "../../../util/fetchTimeout.js";
 import { logger } from "../../../util/logger.js";
 import { getImageDimensions } from "../../utils/image-detector.js";
 import { defineTransformer } from "../plugins.js";
@@ -58,6 +60,7 @@ function isBlockedUrl(url) {
 }
 const RE_URL_LEADING = /^url\(['"]?/;
 const RE_URL_TRAILING = /['"]?\)$/;
+const SUBREQUEST_HEADERS = { "x-nuxt-og-image": "1" };
 async function resolveLocalFilePathImage(publicStoragePath, src) {
   const normalizedSrc = withoutLeadingSlash(
     src.replace("_nuxt/@fs/", "").replace("_nuxt/", "").replace("./", "")
@@ -66,125 +69,129 @@ async function resolveLocalFilePathImage(publicStoragePath, src) {
   if (await useStorage().hasItem(key))
     return await useStorage().getItemRaw(key);
 }
+function toBufferSourceAsBase64(buf) {
+  const ab = buf instanceof ArrayBuffer ? buf : ArrayBuffer.isView(buf) ? buf.buffer.slice(buf.byteOffset, buf.byteOffset + buf.byteLength) : buf;
+  return toBase64Image(ab);
+}
+const renderCaches = /* @__PURE__ */ new WeakMap();
+function getRenderCache(e) {
+  let cache = renderCaches.get(e);
+  if (!cache) {
+    cache = /* @__PURE__ */ new Map();
+    renderCaches.set(e, cache);
+  }
+  return cache;
+}
+function resolveSrcToBuffer(src, kind, ctx) {
+  const cache = getRenderCache(ctx.e);
+  const existing = cache.get(src);
+  if (existing)
+    return existing;
+  const promise = doResolveSrcToBuffer(src, kind, ctx);
+  cache.set(src, promise);
+  return promise;
+}
+async function doResolveSrcToBuffer(src, kind, { e, publicStoragePath, runtimeConfig, timings }) {
+  const fetchTimeout = getFetchTimeout(runtimeConfig);
+  const logFailure = (url, err) => {
+    logger.debug(`[og-image] ${kind} fetch failed (${url}): ${err?.message || err}`);
+  };
+  if (src.startsWith("/")) {
+    let buffer2;
+    if (import.meta.prerender || import.meta.dev) {
+      const srcWithoutBase = src.replace(runtimeConfig.app.baseURL, "/");
+      buffer2 = await resolveLocalFilePathImage(publicStoragePath, srcWithoutBase);
+    }
+    if (!buffer2 && !import.meta.prerender) {
+      const ab = await timings.measure("image-fetch", () => fetchLocalAsset(e, src, {
+        fetchTimeout,
+        headers: SUBREQUEST_HEADERS,
+        includeExternalFallback: true,
+        onStepFailure: logFailure
+      }));
+      if (ab)
+        buffer2 = new Uint8Array(ab);
+    }
+    return buffer2 ? { buffer: buffer2 } : {};
+  }
+  const decodedSrc = decodeHtml(src);
+  if (!import.meta.dev && isBlockedUrl(decodedSrc)) {
+    logger.warn(`Blocked internal ${kind} fetch: ${decodedSrc}`);
+    return { blocked: true };
+  }
+  const end = timings.start("image-fetch");
+  const buffer = await $fetch(decodedSrc, {
+    responseType: "arrayBuffer",
+    timeout: fetchTimeout
+  }).catch((err) => {
+    logFailure(decodedSrc, err);
+  }).finally(end);
+  return buffer ? { buffer } : {};
+}
+function applyImageDimensions(node, buffer) {
+  if (typeof node.props.width === "string")
+    node.props.width = Number(node.props.width) || void 0;
+  if (typeof node.props.height === "string")
+    node.props.height = Number(node.props.height) || void 0;
+  if (node.props.width && node.props.height)
+    return;
+  const view = buffer instanceof Uint8Array ? buffer : ArrayBuffer.isView(buffer) ? new Uint8Array(buffer.buffer, buffer.byteOffset, buffer.byteLength) : new Uint8Array(buffer);
+  const dimensions = getImageDimensions(view);
+  if (!dimensions?.width || !dimensions?.height)
+    return;
+  const naturalAspectRatio = dimensions.width / dimensions.height;
+  if (node.props.width && !node.props.height) {
+    node.props.height = Math.round(node.props.width / naturalAspectRatio);
+  } else if (node.props.height && !node.props.width) {
+    node.props.width = Math.round(node.props.height * naturalAspectRatio);
+  } else {
+    node.props.width = dimensions.width;
+    node.props.height = dimensions.height;
+  }
+}
 export default defineTransformer([
   // fix <img src="">
   {
     filter: (node) => node.type === "img" && node.props?.src,
-    transform: async (node, { e, publicStoragePath, runtimeConfig }) => {
+    transform: async (node, ctx) => {
       let src = node.props.src;
-      const isRelative = src.startsWith("/");
-      let dimensions;
-      let imageBuffer;
+      if (src.startsWith("data:"))
+        return;
       if (src.endsWith(".webp")) {
         logger.warn("Using WebP images with Satori is not supported. Please consider switching image format or use the chromium renderer.", src);
       }
-      if (isRelative) {
-        if (import.meta.prerender || import.meta.dev) {
-          const srcWithoutBase = src.replace(runtimeConfig.app.baseURL, "");
-          imageBuffer = await resolveLocalFilePathImage(publicStoragePath, srcWithoutBase);
-        }
-        if (!imageBuffer) {
-          imageBuffer = await e.$fetch(src, { responseType: "arrayBuffer" }).catch(() => {
-          });
-          if (!imageBuffer && !import.meta.prerender) {
-            imageBuffer = await e.$fetch(src, {
-              baseURL: getNitroOrigin(e),
-              responseType: "arrayBuffer"
-            }).catch(() => {
-            });
-          }
-        }
-        if (imageBuffer) {
-          const buffer = imageBuffer instanceof ArrayBuffer ? imageBuffer : imageBuffer.buffer;
-          node.props.src = toBase64Image(buffer);
-        }
-      } else if (!src.startsWith("data:")) {
-        src = decodeHtml(src);
-        if (!import.meta.dev && isBlockedUrl(src)) {
-          logger.warn(`Blocked internal image fetch: ${src}`);
-          delete node.props.src;
-        } else {
-          node.props.src = src;
-          imageBuffer = await $fetch(src, {
-            responseType: "arrayBuffer"
-          }).catch(() => {
-          });
-          if (imageBuffer) {
-            const buffer = imageBuffer instanceof ArrayBuffer ? imageBuffer : imageBuffer.buffer;
-            node.props.src = toBase64Image(buffer);
-          }
-        }
-      }
-      if (typeof node.props.width === "string")
-        node.props.width = Number(node.props.width) || void 0;
-      if (typeof node.props.height === "string")
-        node.props.height = Number(node.props.height) || void 0;
-      if (imageBuffer && (!node.props.width || !node.props.height)) {
-        dimensions = getImageDimensions(imageBuffer);
-        if (dimensions?.width && dimensions?.height) {
-          const naturalAspectRatio = dimensions.width / dimensions.height;
-          if (node.props.width && !node.props.height) {
-            node.props.height = Math.round(node.props.width / naturalAspectRatio);
-          } else if (node.props.height && !node.props.width) {
-            node.props.width = Math.round(node.props.height * naturalAspectRatio);
-          } else if (!node.props.width && !node.props.height) {
-            node.props.width = dimensions.width;
-            node.props.height = dimensions.height;
-          }
-        }
+      const isRelative = src.startsWith("/");
+      if (!isRelative)
+        src = node.props.src = decodeHtml(src);
+      const result = await resolveSrcToBuffer(src, "image", ctx);
+      if (result.blocked) {
+        delete node.props.src;
+        return;
       }
-      if (typeof node.props.src === "string" && node.props.src.startsWith("/")) {
-        if (imageBuffer) {
-          const buffer = imageBuffer instanceof ArrayBuffer ? imageBuffer : imageBuffer.buffer;
-          node.props.src = toBase64Image(buffer);
-        } else {
-          node.props.src = `${withBase(src, `${getNitroOrigin(e)}`)}?${Date.now()}`;
-        }
+      if (result.buffer) {
+        node.props.src = toBufferSourceAsBase64(result.buffer);
+        applyImageDimensions(node, result.buffer);
+        return;
       }
+      if (isRelative)
+        node.props.src = withBase(src, `${getNitroOrigin(ctx.e)}`);
     }
   },
   // fix style="background-image: url('')"
   {
     filter: (node) => node.props?.style?.backgroundImage?.includes("url("),
-    transform: async (node, { e, publicStoragePath, runtimeConfig }) => {
+    transform: async (node, ctx) => {
       const backgroundImage = node.props.style.backgroundImage;
       const src = backgroundImage.replace(RE_URL_LEADING, "").replace(RE_URL_TRAILING, "");
       if (src.startsWith("data:"))
         return;
-      const isRelative = src?.startsWith("/");
-      let imageBuffer;
-      if (isRelative) {
-        if (import.meta.prerender || import.meta.dev) {
-          const srcWithoutBase = src.replace(runtimeConfig.app.baseURL, "/");
-          imageBuffer = await resolveLocalFilePathImage(publicStoragePath, srcWithoutBase);
-        }
-        if (!imageBuffer) {
-          imageBuffer = await e.$fetch(src, { responseType: "arrayBuffer" }).catch(() => {
-          });
-          if (!imageBuffer && !import.meta.prerender) {
-            imageBuffer = await e.$fetch(src, {
-              baseURL: getNitroOrigin(e),
-              responseType: "arrayBuffer"
-            }).catch(() => {
-            });
-          }
-        }
-      } else {
-        const decodedSrc = decodeHtml(src);
-        if (!import.meta.dev && isBlockedUrl(decodedSrc)) {
-          logger.warn(`Blocked internal background-image fetch: ${decodedSrc}`);
-          delete node.props.style.backgroundImage;
-        } else {
-          imageBuffer = await $fetch(decodedSrc, {
-            responseType: "arrayBuffer"
-          }).catch(() => {
-          });
-        }
-      }
-      if (imageBuffer) {
-        const buffer = imageBuffer instanceof ArrayBuffer ? imageBuffer : imageBuffer.buffer;
-        node.props.style.backgroundImage = `url(${toBase64Image(buffer)})`;
+      const result = await resolveSrcToBuffer(src, "background-image", ctx);
+      if (result.blocked) {
+        delete node.props.style.backgroundImage;
+        return;
       }
+      if (result.buffer)
+        node.props.style.backgroundImage = `url(${toBufferSourceAsBase64(result.buffer)})`;
     }
   }
 ]);

package/dist/runtime/server/og-image/core/transforms/emojis/fetch.js

@@ -1,5 +1,6 @@
 import { emojiCache } from "#og-image-cache";
 import { $fetch } from "ofetch";
+import { getFetchTimeout } from "../../../../util/fetchTimeout.js";
 import { getEmojiCodePoint, getEmojiIconNames } from "./emoji-utils.js";
 export async function getEmojiSvg(ctx, emojiChar) {
   const emojiSet = ctx.options.emojis;
@@ -15,21 +16,31 @@ export async function getEmojiSvg(ctx, emojiChar) {
     }
   }
   if (!svg) {
-    for (const iconName of possibleNames) {
-      try {
-        svg = await $fetch(`https://api.iconify.design/${emojiSet}/${iconName}.svg`, {
-          responseType: "text",
-          retry: 2,
-          retryDelay: 500
-        });
-        if (svg && svg !== "404") {
-          const key = ["1", emojiSet, iconName].join("|");
-          await emojiCache.setItem(key, svg);
+    const timeout = getFetchTimeout(ctx.runtimeConfig);
+    const deadline = AbortSignal.timeout(timeout);
+    const endTiming = ctx.timings.start("emoji-fetch");
+    try {
+      for (const iconName of possibleNames) {
+        if (deadline.aborted)
           break;
+        try {
+          svg = await $fetch(`https://api.iconify.design/${emojiSet}/${iconName}.svg`, {
+            responseType: "text",
+            retry: 0,
+            signal: deadline,
+            timeout
+          });
+          if (svg && svg !== "404") {
+            const key = ["1", emojiSet, iconName].join("|");
+            await emojiCache.setItem(key, svg);
+            break;
+          }
+        } catch {
+          svg = null;
         }
-      } catch {
-        svg = null;
       }
+    } finally {
+      endTiming();
     }
   }
   if (svg) {

package/dist/runtime/server/og-image/satori/renderer.js

@@ -23,7 +23,7 @@ function withWarningCapture(fn) {
   });
 }
 export async function createSvg(event) {
-  const { options } = event;
+  const { options, timings } = event;
   const { satoriOptions: _satoriOptions } = useOgImageRuntimeConfig();
   const { fontFamilyOverride, defaultFont } = getDefaultFontFamily(options);
   const [satori, vnodes] = await Promise.all([
@@ -32,13 +32,13 @@ export async function createSvg(event) {
   ]);
   const codepoints = extractCodepoints(vnodes);
   const hasCustomFonts = Array.isArray(options.fonts) && options.fonts.length > 0;
-  const fonts = await loadFontsForRenderer(event, {
+  const fonts = await timings.measure("font-load", () => loadFontsForRenderer(event, {
     supportedFormats: /* @__PURE__ */ new Set(["ttf", "otf", "woff"]),
     component: options.component,
     fontFamilyOverride: fontFamilyOverride || defaultFont,
     codepoints,
     fontDefs: options.fonts
-  });
+  }));
   await event._nitro.hooks.callHook("nuxt-og-image:satori:vnodes", vnodes, event);
   const satoriFonts = !hasCustomFonts && _satoriFontCache.get(fonts) || fonts.map((f) => ({ ...f, name: f.family }));
   if (!hasCustomFonts)
@@ -80,9 +80,9 @@ export async function createSvg(event) {
     width: options.width,
     height: options.height
   });
-  const { result, warnings } = await withWarningCapture(
+  const { result, warnings } = await timings.measure("render-satori", () => withWarningCapture(
     () => satori(vnodes, satoriOptions)
-  );
+  ));
   return { svg: result, warnings, fonts };
 }
 async function createPng(event) {
@@ -92,14 +92,16 @@ async function createPng(event) {
     throw new Error("Failed to create SVG");
   const options = defu(event.options.resvg, resvgOptions);
   const Resvg = await getResvg();
-  const resvg = new Resvg(svg, options);
-  const pngData = resvg.render();
-  const png = pngData.asPng();
-  if (typeof pngData.free === "function")
-    pngData.free();
-  if (typeof resvg.free === "function")
-    resvg.free();
-  return png;
+  return event.timings.measure("render-resvg", () => {
+    const resvg = new Resvg(svg, options);
+    const pngData = resvg.render();
+    const png = pngData.asPng();
+    if (typeof pngData.free === "function")
+      pngData.free();
+    if (typeof resvg.free === "function")
+      resvg.free();
+    return png;
+  });
 }
 async function createJpeg(event) {
   const { sharpOptions } = useOgImageRuntimeConfig();
@@ -115,7 +117,7 @@ async function createJpeg(event) {
     throw new Error("Sharp dependency could not be loaded. Please check you have it installed and are using a compatible runtime.");
   });
   const options = defu(event.options.sharp, sharpOptions);
-  return sharp(svgBuffer, options).jpeg(options).toBuffer();
+  return event.timings.measure("render-sharp", () => sharp(svgBuffer, options).jpeg(options).toBuffer());
 }
 function rewriteVNodeFontFamilies(node, subsetChains) {
   const style = node.props?.style;

package/dist/runtime/server/og-image/takumi/renderer.js

@@ -1,7 +1,8 @@
-import { getNitroOrigin } from "#site-config/server/composables";
 import { defu } from "defu";
 import { withBase } from "ufo";
 import { logger } from "../../../logger.js";
+import { fetchLocalAsset } from "../../util/fetchLocalAsset.js";
+import { getFetchTimeout } from "../../util/fetchTimeout.js";
 import { buildSubsetFamilyChain, extractCodepoints, getDefaultFontFamily, loadFontsForRenderer, resolveSubsetChain } from "../fonts.js";
 import { getExtractResourceUrls, getTakumi } from "./instances.js";
 import { createTakumiNodes } from "./nodes.js";
@@ -77,11 +78,11 @@ function rewriteFontFamilies(node, loadedFamilies, subsetChains) {
   }
 }
 async function createImage(event, format) {
-  const { options } = event;
+  const { options, timings } = event;
   const { fontFamilyOverride, defaultFont } = getDefaultFontFamily(options);
   const nodes = await createTakumiNodes(event);
   const codepoints = extractCodepoints(nodes);
-  const fonts = await loadFontsForRenderer(event, { supportedFormats: /* @__PURE__ */ new Set(["ttf", "woff2"]), component: options.component, fontFamilyOverride: fontFamilyOverride || defaultFont, codepoints });
+  const fonts = await timings.measure("font-load", () => loadFontsForRenderer(event, { supportedFormats: /* @__PURE__ */ new Set(["ttf", "woff2"]), component: options.component, fontFamilyOverride: fontFamilyOverride || defaultFont, codepoints }));
   await event._nitro.hooks.callHook("nuxt-og-image:takumi:nodes", nodes, event);
   const subsetChains = buildSubsetFamilyChain(fonts);
   const state = await getTakumiState(event);
@@ -99,25 +100,32 @@ async function createImage(event, format) {
   rewriteFontFamilies(nodes, state.loadedFamilies, subsetChains);
   const extractResourceUrls = await getExtractResourceUrls();
   const resourceUrls = await extractResourceUrls(nodes);
-  const origin = getNitroOrigin(event.e);
   const baseURL = event.runtimeConfig.app.baseURL;
   const fetchedResources = [];
-  await Promise.all(resourceUrls.map(async (src) => {
-    const urlsToTry = [src];
-    if (src.startsWith("/")) {
-      urlsToTry.push(withBase(src, origin));
-      if (baseURL && baseURL !== "/" && !src.startsWith(baseURL)) {
-        urlsToTry.push(withBase(withBase(src, baseURL), origin));
+  if (resourceUrls.length) {
+    const fetchTimeout = getFetchTimeout(event.runtimeConfig);
+    const headers = { "x-nuxt-og-image": "1" };
+    await timings.measure("resource-fetch", () => Promise.all(resourceUrls.map(async (src) => {
+      let data;
+      if (src.startsWith("/")) {
+        const path = withBase(src, baseURL);
+        data = await fetchLocalAsset(event.e, path, {
+          fetchTimeout,
+          headers,
+          includeExternalFallback: true
+        });
+      } else {
+        data = await $fetch(src, {
+          responseType: "arrayBuffer",
+          signal: AbortSignal.timeout(fetchTimeout),
+          timeout: fetchTimeout,
+          headers
+        }).catch(() => void 0);
       }
-    }
-    for (const url of urlsToTry) {
-      const data = await $fetch(url, { responseType: "arrayBuffer" }).catch(() => null);
-      if (data) {
+      if (data)
         fetchedResources.push({ src, data: new Uint8Array(data) });
-        break;
-      }
-    }
-  }));
+    })));
+  }
   const maxDpr = event.runtimeConfig.security?.maxDpr || 2;
   const maxDim = event.runtimeConfig.security?.maxDimension || 2048;
   const dpr = Math.min(Math.max(1, options.takumi?.devicePixelRatio ?? 1), maxDpr);
@@ -128,7 +136,7 @@ async function createImage(event, format) {
     fetchedResources,
     devicePixelRatio: dpr
   });
-  return await state.renderer.render(nodes, renderOptions);
+  return await timings.measure("render-takumi", () => state.renderer.render(nodes, renderOptions));
 }
 const TakumiRenderer = {
   name: "takumi",

package/dist/runtime/server/util/cloudflareAssets.d.ts

@@ -0,0 +1,24 @@
+import type { H3Event } from 'h3';
+interface AssetsBinding {
+    fetch: (request: string | Request, init?: RequestInit) => Promise<Response>;
+}
+/**
+ * Access the Cloudflare Workers ASSETS binding if available.
+ *
+ * Requires either:
+ * - `nitro.cloudflare.deployConfig: true` (generates wrangler.json with ASSETS)
+ * - A wrangler.toml/json with `[assets]` configured
+ */
+export declare function getCloudflareAssets(event: H3Event): AssetsBinding | undefined;
+/**
+ * Fetch a path directly from the CF Workers ASSETS binding.
+ *
+ * Prefer this over same-origin subrequests on Workers: it hits the static asset
+ * handler without billing a subrequest and without re-running the Worker's
+ * middleware chain.
+ *
+ * Returns `undefined` when no ASSETS binding is available or the asset doesn't
+ * exist (letting callers fall through to other resolution strategies).
+ */
+export declare function tryCloudflareAssetsFetch(event: H3Event, path: string, signal?: AbortSignal): Promise<ArrayBuffer | undefined>;
+export {};

package/dist/runtime/server/util/cloudflareAssets.js

@@ -0,0 +1,16 @@
+import { getRequestHost } from "h3";
+export function getCloudflareAssets(event) {
+  const assets = event.context.cloudflare?.env?.ASSETS || event.context.ASSETS;
+  return assets && typeof assets.fetch === "function" ? assets : void 0;
+}
+export async function tryCloudflareAssetsFetch(event, path, signal) {
+  const assets = getCloudflareAssets(event);
+  if (!assets)
+    return;
+  const origin = event.context.cloudflare?.request?.url || `https://${getRequestHost(event) || "localhost"}`;
+  const url = new URL(path, origin).href;
+  const res = await assets.fetch(url, signal ? { signal } : void 0).catch(() => null);
+  if (!res || !res.ok)
+    return;
+  return res.arrayBuffer();
+}

package/dist/runtime/server/util/eventHandlers.js

@@ -8,12 +8,25 @@ import { html } from "../og-image/templates/html.js";
 import { useOgImageRuntimeConfig } from "../utils.js";
 import { useOgImageBufferCache } from "./cache.js";
 export async function imageEventHandler(e) {
+  const reqStart = performance.now();
   const ctx = await resolveContext(e).catch((err) => {
     logger.error(`resolveContext error for ${e.path}:`, err?.message || err);
     throw err;
   });
   if (ctx instanceof H3Error)
     return ctx;
+  const timings = ctx.timings;
+  try {
+    return await renderOgImage(e, ctx);
+  } finally {
+    timings.record("total", performance.now() - reqStart);
+    const header = timings.header();
+    if (header)
+      setHeader(e, "Server-Timing", header);
+  }
+}
+async function renderOgImage(e, ctx) {
+  const timings = ctx.timings;
   const { isDevToolsContextRequest, extension, renderer } = ctx;
   const { debug, baseCacheKey, security } = useOgImageRuntimeConfig();
   if (!import.meta.prerender && !import.meta.dev && security?.restrictRuntimeImagesToOrigin) {
@@ -99,21 +112,29 @@ export async function imageEventHandler(e) {
   }
   const buildCachedImage = import.meta.prerender ? getBuildCachedImage(ctx.options, extension) : null;
   if (buildCachedImage) {
+    timings.record("cache-hit", 0);
     return buildCachedImage;
   }
+  const endCacheLookup = timings.start("cache-lookup");
   const cacheApi = await useOgImageBufferCache(ctx, {
     cacheMaxAgeSeconds: ctx.options.cacheMaxAgeSeconds,
     baseCacheKey,
     secret: security?.secret
-  });
-  if (typeof cacheApi === "undefined")
+  }).finally(endCacheLookup);
+  if (typeof cacheApi === "undefined") {
     return;
-  if (cacheApi instanceof H3Error)
+  }
+  if (cacheApi instanceof H3Error) {
     return cacheApi;
+  }
   let image = cacheApi.cachedItem;
+  if (image) {
+    timings.record("cache-hit", 0);
+  }
   if (!image) {
-    const timeout = security?.renderTimeout || 15e3;
+    const timeout = security?.renderTimeout ?? 15e3;
     let timer;
+    const endRender = timings.start("render-total");
     image = await Promise.race([
       renderer.createImage(ctx),
       new Promise((_, reject) => {
@@ -128,9 +149,11 @@ export async function imageEventHandler(e) {
       throw err;
     }).finally(() => {
       clearTimeout(timer);
+      endRender();
     });
-    if (image instanceof H3Error)
+    if (image instanceof H3Error) {
       return image;
+    }
     if (!image) {
       return createError({
         statusCode: 500,

package/dist/runtime/server/util/fetchLocalAsset.d.ts

@@ -0,0 +1,25 @@
+import type { H3Event } from 'h3';
+export interface FetchLocalAssetOptions {
+    fetchTimeout: number;
+    headers?: Record<string, string>;
+    /**
+     * Also attempt an external HTTP fetch to `getNitroOrigin(event) + path` when
+     * ASSETS and Nitro localFetch both miss. Enable for platforms where static
+     * files are served by edge routing that never reaches the Nitro handler
+     * (Vercel, Netlify). Disable for CF Workers where no ASSETS means no assets.
+     */
+    includeExternalFallback?: boolean;
+    onStepFailure?: (url: string, err: unknown) => void;
+}
+/**
+ * Resolve a same-origin asset path to bytes, trying (in order):
+ *   1. Cloudflare Workers ASSETS binding
+ *   2. Nitro localFetch (`event.$fetch`) — resolves dynamic routes too
+ *   3. External `$fetch` to the Nitro origin (opt-in)
+ *
+ * All steps share a single `AbortSignal.timeout(fetchTimeout)` so a broken
+ * URL can't burn N× the configured budget.
+ *
+ * Returns `undefined` when every step fails or times out.
+ */
+export declare function fetchLocalAsset(event: H3Event, path: string, options: FetchLocalAssetOptions): Promise<ArrayBuffer | undefined>;

package/dist/runtime/server/util/fetchLocalAsset.js

@@ -0,0 +1,34 @@
+import { getNitroOrigin } from "#site-config/server/composables";
+import { $fetch } from "ofetch";
+import { tryCloudflareAssetsFetch } from "./cloudflareAssets.js";
+export async function fetchLocalAsset(event, path, options) {
+  const { fetchTimeout, headers, includeExternalFallback = false, onStepFailure } = options;
+  const deadline = AbortSignal.timeout(fetchTimeout);
+  let result = await tryCloudflareAssetsFetch(event, path, deadline).catch((err) => {
+    onStepFailure?.(path, err);
+    return void 0;
+  });
+  if (result || deadline.aborted)
+    return result;
+  result = await event.$fetch(path, {
+    responseType: "arrayBuffer",
+    signal: deadline,
+    timeout: fetchTimeout,
+    headers
+  }).catch((err) => {
+    onStepFailure?.(path, err);
+    return void 0;
+  });
+  if (result || deadline.aborted || !includeExternalFallback)
+    return result;
+  const absolute = `${getNitroOrigin(event)}${path}`;
+  return await $fetch(absolute, {
+    responseType: "arrayBuffer",
+    signal: deadline,
+    timeout: fetchTimeout,
+    headers
+  }).catch((err) => {
+    onStepFailure?.(absolute, err);
+    return void 0;
+  });
+}

package/dist/runtime/server/util/fetchTimeout.d.ts

@@ -0,0 +1,2 @@
+import type { OgImageRuntimeConfig } from '../../types.js';
+export declare function getFetchTimeout(runtimeConfig: OgImageRuntimeConfig): number;

package/dist/runtime/server/util/fetchTimeout.js

@@ -0,0 +1,7 @@
+const MIN_TIMEOUT_MS = 100;
+export function getFetchTimeout(runtimeConfig) {
+  const value = runtimeConfig.security?.imageFetchTimeout ?? 3e3;
+  if (!Number.isFinite(value) || value < MIN_TIMEOUT_MS)
+    return MIN_TIMEOUT_MS;
+  return value;
+}

package/dist/runtime/server/util/timings.d.ts

@@ -0,0 +1,17 @@
+export interface TimingEntry {
+    name: string;
+    dur: number;
+    count?: number;
+}
+export interface Timings {
+    start: (name: string) => () => number;
+    record: (name: string, ms: number) => void;
+    measure: <T>(name: string, fn: () => Promise<T> | T) => Promise<T>;
+    entries: () => TimingEntry[];
+    header: () => string;
+}
+export declare function createTimings(): Timings;
+export declare const TIMING_CTX_KEY = "_ogImageTimings";
+export declare function getTimingsFromEvent(e: {
+    context: Record<string, any>;
+}): Timings | undefined;