nuxt-og-image 6.7.4 → 6.7.6

package/dist/runtime/server/og-image/bindings/resvg/node-dev.js

@@ -1,4 +1,5 @@
 import { Worker } from "node:worker_threads";
+import { createWorkerQueue, parseWorkerTimeout } from "../worker-queue.js";
 const workerCode = `
 const { createRequire } = require('node:module')
 const _require = createRequire(process.cwd() + '/')
@@ -12,78 +13,31 @@ parentPort.on('message', ({ id, svg, options }) => {
     // Always slice to create a standard ArrayBuffer \u2014 native addon buffers
     // use external memory that can't be transferred via postMessage
     const ab = png.buffer.slice(png.byteOffset, png.byteOffset + png.byteLength)
-    parentPort.postMessage({ id, png: ab }, [ab])
+    parentPort.postMessage({ _tag: 'response', id, payload: { _tag: 'success', png: ab } }, [ab])
   } catch (err) {
-    parentPort.postMessage({ id, error: err?.message || String(err) })
+    parentPort.postMessage({ _tag: 'response', id, payload: { _tag: 'failure', error: err?.message || String(err) } })
   }
 })
+parentPort.postMessage({ _tag: 'ready' })
 `;
-let worker = null;
-let requestId = 0;
-const pending = /* @__PURE__ */ new Map();
-function killWorker() {
-  if (!worker)
-    return;
-  worker.terminate();
-  worker = null;
-  for (const [id, p] of pending) {
-    clearTimeout(p.timer);
-    pending.delete(id);
-    p.reject(new Error("Resvg worker terminated"));
-  }
+const workerTimeout = parseWorkerTimeout(process.env.NUXT_OG_IMAGE_WORKER_TIMEOUT);
+const workerQueue = createWorkerQueue({
+  createWorker: () => new Worker(workerCode, { eval: true }),
+  executionTimeout: workerTimeout,
+  startupTimeout: workerTimeout,
+  label: "resvg"
+});
+function renderPng(svg, options) {
+  return workerQueue.enqueue(({ id }) => ({ id, svg, options })).then((result) => {
+    if (result._tag === "failure")
+      throw new Error(result.error);
+    return Buffer.from(result.png);
+  });
 }
 const signalKey = Symbol.for("og-image:resvg-worker-cleanup");
 if (!globalThis[signalKey]) {
   globalThis[signalKey] = true;
-  process.on("exit", killWorker);
-}
-function createWorker() {
-  const w = new Worker(workerCode, { eval: true });
-  w.on("message", ({ id, png, error }) => {
-    const p = pending.get(id);
-    if (p) {
-      clearTimeout(p.timer);
-      pending.delete(id);
-      if (error)
-        p.reject(new Error(error));
-      else
-        p.resolve(Buffer.from(png));
-    }
-  });
-  w.on("error", (err) => {
-    for (const [id, p] of pending) {
-      clearTimeout(p.timer);
-      pending.delete(id);
-      p.reject(err);
-    }
-    worker = null;
-  });
-  w.on("exit", (code) => {
-    if (code !== 0) {
-      for (const [id, p] of pending) {
-        clearTimeout(p.timer);
-        pending.delete(id);
-        p.reject(new Error(`Resvg worker exited with code ${code}`));
-      }
-    }
-    worker = null;
-  });
-  w.unref();
-  return w;
-}
-function renderPng(svg, options) {
-  return new Promise((resolve, reject) => {
-    if (!worker)
-      worker = createWorker();
-    const id = ++requestId;
-    const timer = setTimeout(() => {
-      pending.delete(id);
-      reject(new Error("resvg worker timed out \u2014 killing worker"));
-      killWorker();
-    }, 3e4);
-    pending.set(id, { resolve, reject, timer });
-    worker.postMessage({ id, svg, options });
-  });
+  process.on("exit", workerQueue.shutdown);
 }
 class ResvgWorkerProxy {
   svg;

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

@@ -1,4 +1,5 @@
 import { Worker } from "node:worker_threads";
+import { createWorkerQueue, parseWorkerTimeout } from "../worker-queue.js";
 import { extractResourceUrls as extractTakumiResourceUrls } from "./resource-urls.js";
 const workerCode = `
 const { createRequire } = require('node:module')
@@ -30,85 +31,24 @@ parentPort.on('message', async ({ id, type, newFonts, nodes, options }) => {
     // Always slice to create a standard ArrayBuffer \u2014 native addon buffers
     // use external memory that can't be transferred via postMessage
     const ab = image.buffer.slice(image.byteOffset, image.byteOffset + image.byteLength)
-    parentPort.postMessage({ id, image: ab, fontWarnings }, [ab])
+    parentPort.postMessage({ _tag: 'response', id, payload: { _tag: 'success', image: ab, fontWarnings } }, [ab])
   } catch (err) {
-    parentPort.postMessage({ id, error: err?.message || String(err) })
+    parentPort.postMessage({ _tag: 'response', id, payload: { _tag: 'failure', error: err?.message || String(err) } })
   }
 })
+parentPort.postMessage({ _tag: 'ready' })
 `;
-let worker = null;
-let workerGeneration = 0;
-let requestId = 0;
-const pending = /* @__PURE__ */ new Map();
-function killWorker() {
-  if (!worker)
-    return;
-  worker.terminate();
-  worker = null;
-  for (const [id, p] of pending) {
-    clearTimeout(p.timer);
-    pending.delete(id);
-    p.reject(new Error("Takumi worker terminated"));
-  }
-}
+const workerTimeout = parseWorkerTimeout(process.env.NUXT_OG_IMAGE_WORKER_TIMEOUT);
+const workerQueue = createWorkerQueue({
+  createWorker: () => new Worker(workerCode, { eval: true }),
+  executionTimeout: workerTimeout,
+  startupTimeout: workerTimeout,
+  label: "takumi"
+});
 const signalKey = Symbol.for("og-image:takumi-worker-cleanup");
 if (!globalThis[signalKey]) {
   globalThis[signalKey] = true;
-  process.on("exit", killWorker);
-}
-function createWorker() {
-  workerGeneration++;
-  const w = new Worker(workerCode, { eval: true });
-  w.on("message", ({ id, image, urls, error, fontWarnings }) => {
-    const p = pending.get(id);
-    if (p) {
-      clearTimeout(p.timer);
-      pending.delete(id);
-      if (error)
-        p.reject(new Error(error));
-      else if (urls !== void 0)
-        p.resolve(urls);
-      else
-        p.resolve({ image: Buffer.from(image), fontWarnings });
-    }
-  });
-  w.on("error", (err) => {
-    for (const [id, p] of pending) {
-      clearTimeout(p.timer);
-      pending.delete(id);
-      p.reject(err);
-    }
-    worker = null;
-  });
-  w.on("exit", (code) => {
-    if (code !== 0) {
-      for (const [id, p] of pending) {
-        clearTimeout(p.timer);
-        pending.delete(id);
-        p.reject(new Error(`Takumi worker exited with code ${code}`));
-      }
-    }
-    worker = null;
-  });
-  w.unref();
-  return w;
-}
-function ensureWorker() {
-  if (!worker)
-    worker = createWorker();
-}
-function postToWorker(msg, timeoutMs = 3e4) {
-  return new Promise((resolve, reject) => {
-    ensureWorker();
-    const id = ++requestId;
-    const timer = setTimeout(() => {
-      pending.delete(id);
-      reject(new Error("takumi worker timed out \u2014 killing worker"));
-      killWorker();
-    }, timeoutMs);
-    pending.set(id, { resolve, reject, timer });
-    worker.postMessage({ id, ...msg });
-  });
+  process.on("exit", workerQueue.shutdown);
 }
 function extractResourceUrls(nodes) {
   return Promise.resolve(extractTakumiResourceUrls(nodes));
@@ -130,21 +70,24 @@ class RendererWorkerProxy {
     this.loadFont(font);
   }
   render(nodes, options) {
-    ensureWorker();
-    let fontsToSend;
-    if (this.syncedGeneration !== workerGeneration) {
-      fontsToSend = [...this.allFonts];
-      this.pendingFonts = [];
-    } else {
-      fontsToSend = this.pendingFonts.splice(0);
-    }
-    this.syncedGeneration = workerGeneration;
-    return postToWorker({ type: "render", newFonts: fontsToSend, nodes, options }).then((result) => {
+    return workerQueue.enqueue(({ id, generation }) => {
+      let fontsToSend;
+      if (this.syncedGeneration !== generation) {
+        fontsToSend = [...this.allFonts];
+        this.pendingFonts = [];
+      } else {
+        fontsToSend = this.pendingFonts.splice(0);
+      }
+      this.syncedGeneration = generation;
+      return { id, type: "render", newFonts: fontsToSend, nodes, options };
+    }).then((result) => {
+      if (result._tag === "failure")
+        throw new Error(result.error);
       if (result.fontWarnings?.length) {
         for (const w of result.fontWarnings)
           console.warn(`[nuxt-og-image] Failed to load font "${w.name}" (weight: ${w.weight}) into takumi renderer: ${w.error}`);
       }
-      return result.image;
+      return Buffer.from(result.image);
     });
   }
 }

package/dist/runtime/server/og-image/bindings/worker-queue.d.ts

@@ -0,0 +1,34 @@
+interface WorkerHandle {
+    on: {
+        (event: 'message', listener: (message: unknown) => void): WorkerHandle;
+        (event: 'error', listener: (error: Error) => void): WorkerHandle;
+        (event: 'exit', listener: (code: number) => void): WorkerHandle;
+    };
+    postMessage: (message: unknown) => void;
+    removeAllListeners: () => WorkerHandle;
+    terminate: () => Promise<number>;
+    unref: () => void;
+}
+interface QueueOptions {
+    createWorker: () => WorkerHandle;
+    executionTimeout: number;
+    startupTimeout: number;
+    label: string;
+    maxAttempts?: number;
+}
+interface Job<TMessage, TResponse> {
+    id: number;
+    buildMessage: (context: {
+        id: number;
+        generation: number;
+    }) => TMessage;
+    resolve: (response: TResponse) => void;
+    reject: (error: Error) => void;
+    attempts: number;
+}
+export declare function parseWorkerTimeout(value: string | undefined, fallback?: number): number;
+export declare function createWorkerQueue<TMessage, TResponse>(options: QueueOptions): {
+    enqueue: (buildMessage: Job<TMessage, TResponse>["buildMessage"]) => Promise<TResponse>;
+    shutdown: () => void;
+};
+export {};

package/dist/runtime/server/og-image/bindings/worker-queue.js

@@ -0,0 +1,150 @@
+function toError(reason) {
+  return reason instanceof Error ? reason : new Error(String(reason));
+}
+function parseWorkerEvent(message) {
+  if (!message || typeof message !== "object" || !("_tag" in message))
+    return;
+  if (message._tag === "ready")
+    return { _tag: "ready" };
+  if (message._tag !== "response" || !("id" in message) || typeof message.id !== "number" || !("payload" in message))
+    return;
+  return { _tag: "response", id: message.id, payload: message.payload };
+}
+export function parseWorkerTimeout(value, fallback = 3e4) {
+  const timeout = Number(value);
+  return Number.isSafeInteger(timeout) && timeout > 0 ? timeout : fallback;
+}
+export function createWorkerQueue(options) {
+  const maxAttempts = options.maxAttempts ?? 2;
+  const queue = [];
+  let active = { _tag: "idle" };
+  let workerState = { _tag: "stopped" };
+  let requestId = 0;
+  let workerGeneration = 0;
+  let stopped = false;
+  function stopWorker() {
+    if (workerState._tag === "stopped")
+      return;
+    const state = workerState;
+    workerState = { _tag: "stopped" };
+    if (state._tag === "starting")
+      clearTimeout(state.timer);
+    state.worker.removeAllListeners();
+    void state.worker.terminate().catch(() => {
+    });
+  }
+  function takeActive() {
+    if (active._tag === "idle")
+      return;
+    const state = active;
+    active = { _tag: "idle" };
+    if (state._tag === "running")
+      clearTimeout(state.timer);
+    return state.job;
+  }
+  function continueQueue() {
+    queueMicrotask(processQueue);
+  }
+  function failWorker(reason, failedWorker) {
+    if (failedWorker && (workerState._tag === "stopped" || workerState.worker !== failedWorker))
+      return;
+    stopWorker();
+    const job = takeActive();
+    if (job) {
+      if (job.attempts < maxAttempts) {
+        job.attempts++;
+        queue.unshift(job);
+      } else {
+        job.reject(toError(reason));
+      }
+    }
+    continueQueue();
+  }
+  function startWorker() {
+    let newWorker;
+    try {
+      newWorker = options.createWorker();
+    } catch (error) {
+      failWorker(error);
+      return;
+    }
+    const generation = ++workerGeneration;
+    const timer = setTimeout(() => {
+      failWorker(new Error(`${options.label} worker startup timed out after ${options.startupTimeout}ms`), newWorker);
+    }, options.startupTimeout);
+    workerState = { _tag: "starting", generation, timer, worker: newWorker };
+    newWorker.on("message", (value) => {
+      if (workerState._tag === "stopped" || workerState.worker !== newWorker)
+        return;
+      const message = parseWorkerEvent(value);
+      if (!message)
+        return;
+      if (message._tag === "ready") {
+        if (workerState._tag !== "starting")
+          return;
+        clearTimeout(workerState.timer);
+        workerState = { _tag: "ready", generation, worker: newWorker };
+        dispatchActive();
+        return;
+      }
+      if (active._tag !== "running" || active.job.id !== message.id)
+        return;
+      const job = takeActive();
+      job.resolve(message.payload);
+      processQueue();
+    });
+    newWorker.on("error", (error) => failWorker(error, newWorker));
+    newWorker.on("exit", (code) => failWorker(new Error(`${options.label} worker exited with code ${code}`), newWorker));
+    newWorker.unref();
+  }
+  function dispatchActive() {
+    if (active._tag !== "waiting" || workerState._tag !== "ready")
+      return;
+    const job = active.job;
+    const state = workerState;
+    const timer = setTimeout(() => {
+      if (active._tag !== "running" || active.job !== job)
+        return;
+      stopWorker();
+      takeActive().reject(new Error(`${options.label} render timed out after ${options.executionTimeout}ms`));
+      continueQueue();
+    }, options.executionTimeout);
+    active = { _tag: "running", job, timer };
+    try {
+      state.worker.postMessage(job.buildMessage({ id: job.id, generation: state.generation }));
+    } catch (error) {
+      stopWorker();
+      takeActive().reject(toError(error));
+      continueQueue();
+    }
+  }
+  function processQueue() {
+    if (stopped || active._tag !== "idle")
+      return;
+    const job = queue.shift();
+    if (!job)
+      return;
+    active = { _tag: "waiting", job };
+    if (workerState._tag === "stopped")
+      startWorker();
+    else if (workerState._tag === "ready")
+      dispatchActive();
+  }
+  function enqueue(buildMessage) {
+    if (stopped)
+      return Promise.reject(new Error(`${options.label} worker queue is shut down`));
+    return new Promise((resolve, reject) => {
+      queue.push({ id: ++requestId, buildMessage, resolve, reject, attempts: 1 });
+      processQueue();
+    });
+  }
+  function shutdown() {
+    stopped = true;
+    stopWorker();
+    const error = new Error(`${options.label} worker terminated`);
+    takeActive()?.reject(error);
+    for (const job of queue.splice(0))
+      job.reject(error);
+  }
+  return { enqueue, shutdown };
+}

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

@@ -1,4 +1,4 @@
-import { createError } from "h3";
+import { createError } from "#nuxtseo/h3";
 import { createBrowser } from "#og-image/bindings/browser";
 import { createScreenshot } from "./screenshot.js";
 const BrowserRenderer = {

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

@@ -1,4 +1,4 @@
-import type { H3Error, H3Event } from 'h3';
+import type { H3Error, H3Event } from '#nuxtseo/h3';
 import type { OgImageRenderEventContext } from '../../types.js';
 export declare function resolvePathCacheKey(e: H3Event, path: string, resolvedOptions?: Record<string, any>): string;
 export declare function resolveContext(e: H3Event): Promise<H3Error | OgImageRenderEventContext>;

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

@@ -1,8 +1,8 @@
 import { defu } from "defu";
-import { createError } from "h3";
-import { useNitroApp } from "nitropack/runtime";
 import { parseURL, withoutLeadingSlash, withoutTrailingSlash, withQuery } from "ufo";
 import { normalizeKey } from "unstorage";
+import { createError } from "#nuxtseo/h3";
+import { useNitroApp } from "#nuxtseo/nitro";
 import { prerenderOptionsCache } from "#og-image-cache";
 import { getSiteConfig } from "#site-config/server/composables/getSiteConfig";
 import { createSitePathResolver } from "#site-config/server/composables/utils";
@@ -202,7 +202,6 @@ export async function resolveContext(e) {
     basePath,
     options: normalised.options,
     timings,
-    // @ts-expect-error hookable v6
     _nitro: useNitroApp()
   };
   const hookTimeout = runtimeConfig.security?.renderTimeout ?? 15e3;

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

@@ -1,5 +1,5 @@
-import { useStorage } from "nitropack/runtime";
 import { withBase, withoutLeadingSlash } from "ufo";
+import { useStorage } from "#nuxtseo/nitro";
 import { getNitroOrigin } from "#site-config/server/composables/getNitroOrigin";
 import { toBase64Image } from "../../../../shared.js";
 import { decodeHtml } from "../../../util/encoding.js";

package/dist/runtime/server/og-image/core/transforms/emojis/local.d.ts

@@ -1,20 +1,6 @@
-import type { OgImageRenderEventContext } from '../../../../../types.js';
-interface IconsData {
-    icons: Record<string, {
-        body: string;
-        width?: number;
-        height?: number;
-    }>;
-    width: number;
-    height: number;
-}
+import type { OgImageIconsData, OgImageRenderEventContext } from '../../../../../types.js';
 declare module '#og-image-virtual/iconify-json-icons.mjs' {
-    function loadIcons(): Promise<IconsData>;
-}
-declare module 'nitropack/types' {
-    interface NitroApp {
-        _ogImageIconsData?: IconsData;
-    }
+    function loadIcons(): Promise<OgImageIconsData>;
 }
 /**
  * Service function to get emoji SVGs from local iconify JSON files
@@ -23,4 +9,3 @@ declare module 'nitropack/types' {
  * Icons are loaded lazily on first use to avoid 24MB+ memory at startup
  */
 export declare function getEmojiSvg(ctx: OgImageRenderEventContext, emojiChar: string): Promise<string | null>;
-export {};

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

@@ -1,4 +1,4 @@
-import { useNitroApp } from "nitropack/runtime";
+import { useNitroApp } from "#nuxtseo/nitro";
 import { getEmojiCodePoint, getEmojiIconNames } from "./emoji-utils.js";
 function wrapDefsElements(body) {
   const defsElements = ["linearGradient", "radialGradient", "filter", "clipPath", "mask", "pattern"];

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

@@ -1,4 +1,4 @@
-import type { H3Error, H3Event } from 'h3';
+import type { H3Error, H3Event } from '#nuxtseo/h3';
 import type { DevToolsMetaDataExtraction, OgImageOptionsInternal } from '../../types.js';
 export interface DevToolsExtractPayload {
     options: OgImageOptionsInternal[];

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

@@ -1,5 +1,5 @@
 import { parse } from "devalue";
-import { createError } from "h3";
+import { createError } from "#nuxtseo/h3";
 import { htmlPayloadCache } from "#og-image-cache";
 import { extractSocialPreviewTags } from "../../pure.js";
 import { logger } from "../util/logger.js";

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

@@ -1,4 +1,4 @@
-import type { H3Event } from 'h3';
+import type { H3Event } from '#nuxtseo/h3';
 import type { OgImageRenderEventContext, RuntimeFontConfig } from '../../types.js';
 import type { FontFormat } from './font-source.js';
 export { buildSubsetFamilyChain, renameSubsetFonts, resolveSubsetChain } from './font-subsets.js';

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

@@ -198,7 +198,9 @@ export async function loadDefinedFonts(event, fontDefs) {
     const weight = normalizeFontWeight(def.weight);
     const style = def.style === "italic" ? "italic" : "normal";
     const fontConfig = { family: name, weight, style, src: path, localPath: path };
-    const data = await resolve(event.e, fontConfig).catch(() => null);
+    const data = await resolve(event.e, fontConfig).catch(() => {
+      return null;
+    });
     if (data) {
       results.push({
         ...fontConfig,

package/dist/runtime/server/og-image/templates/html.js

@@ -1,5 +1,5 @@
 import { createHead, renderSSRHead } from "@unhead/vue/server";
-import { createError } from "h3";
+import { createError } from "#nuxtseo/h3";
 import resolvedFonts from "#og-image/fonts";
 import { fetchIsland } from "../../util/kit.js";
 import { applyEmojis } from "../core/transforms/emojis/index.js";

package/dist/runtime/server/plugins/prerender.d.ts

@@ -1,2 +1,2 @@
-declare const _default: import("nitropack/types").NitroAppPlugin;
+declare const _default: any;
 export default _default;

package/dist/runtime/server/plugins/prerender.js

@@ -1,7 +1,7 @@
 import { parse } from "devalue";
-import { appendResponseHeader } from "h3";
-import { defineNitroPlugin } from "nitropack/runtime";
 import { parseURL } from "ufo";
+import { appendResponseHeader } from "#nuxtseo/h3";
+import { defineNitroPlugin } from "#nuxtseo/nitro";
 import { prerenderOptionsCache } from "#og-image-cache";
 import { createSitePathResolver } from "#site-config/server/composables/utils";
 import { isInternalRoute } from "../../shared.js";

package/dist/runtime/server/routes/__zero-runtime/image.d.ts

@@ -1,2 +1,2 @@
-declare const _default: import("h3").EventHandler<import("h3").EventHandlerRequest, Promise<any>>;
+declare const _default: any;
 export default _default;

package/dist/runtime/server/routes/__zero-runtime/image.js

@@ -1,4 +1,4 @@
-import { defineEventHandler } from "h3";
+import { defineEventHandler } from "#nuxtseo/h3";
 import { imageEventHandler } from "../../util/eventHandlers.js";
 export default defineEventHandler(async (e) => {
   if (import.meta.dev || import.meta.prerender) {

package/dist/runtime/server/routes/debug.json.d.ts

@@ -1,11 +1,2 @@
-declare const _default: import("h3").EventHandler<import("h3").EventHandlerRequest, Promise<{
-    siteConfigUrl: string;
-    origin: string;
-    componentNames: any;
-    runtimeConfig: import("../../types.js").OgImageRuntimeConfig;
-    compatibility: any;
-    resolvedFonts: any;
-    availableFonts: any;
-    fontRequirements: any;
-}>>;
+declare const _default: any;
 export default _default;

package/dist/runtime/server/routes/debug.json.js

@@ -1,4 +1,4 @@
-import { defineEventHandler, setHeader } from "h3";
+import { defineEventHandler, setHeader } from "#nuxtseo/h3";
 import { componentNames } from "#og-image-virtual/component-names.mjs";
 import compatibility from "#og-image/compatibility";
 import { fontRequirements } from "#og-image/font-requirements";

package/dist/runtime/server/routes/image.d.ts

@@ -1,2 +1,2 @@
-declare const _default: import("h3").EventHandler<import("h3").EventHandlerRequest, Promise<any>>;
+declare const _default: any;
 export default _default;

package/dist/runtime/server/routes/image.js

@@ -1,3 +1,3 @@
-import { defineEventHandler } from "h3";
+import { defineEventHandler } from "#nuxtseo/h3";
 import { imageEventHandler } from "../util/eventHandlers.js";
 export default defineEventHandler(imageEventHandler);

package/dist/runtime/server/routes/resolve.d.ts

@@ -1,2 +1,2 @@
-declare const _default: import("h3").EventHandler<import("h3").EventHandlerRequest, Promise<void>>;
+declare const _default: any;
 export default _default;

package/dist/runtime/server/routes/resolve.js

@@ -1,5 +1,5 @@
-import { createError, defineEventHandler, getRequestHost, sendRedirect } from "h3";
 import { parseURL, withLeadingSlash, withQuery } from "ufo";
+import { createError, defineEventHandler, getRequestHost, sendRedirect } from "#nuxtseo/h3";
 import { getSiteConfig } from "#site-config/server/composables/getSiteConfig";
 import { isInternalRoute } from "../../shared.js";
 import { getEventQuery } from "../util/query.js";

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

@@ -1,10 +1,5 @@
-import type { H3Error } from 'h3';
+import type { H3Error } from '#nuxtseo/h3';
 import type { OgImageRenderEventContext } from '../../types.js';
-declare module 'nitropack/types' {
-    interface NitroApp {
-        _ogImageCacheBackendWarned?: boolean;
-    }
-}
 export declare function useOgImageBufferCache(ctx: OgImageRenderEventContext, options: {
     baseCacheKey: string | false;
     cacheMaxAgeSeconds?: number;

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

@@ -1,8 +1,8 @@
 import { fnv1a64Base36 } from "fnv1a-64";
-import { createError, handleCacheHeaders, setHeader, setHeaders } from "h3";
-import { useStorage } from "nitropack/runtime";
 import { withTrailingSlash } from "ufo";
 import { prefixStorage } from "unstorage";
+import { createError, handleCacheHeaders, setHeader, setHeaders } from "#nuxtseo/h3";
+import { useStorage } from "#nuxtseo/nitro";
 import { logger } from "../../logger.js";
 import { getEventQuery } from "./query.js";
 function safeCompare(a, b) {

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

@@ -0,0 +1,3 @@
+import type { H3Event } from '#nuxtseo/h3';
+export type CloudflareEnv = Record<string, unknown>;
+export declare function getCloudflareEnv(event?: H3Event): CloudflareEnv | undefined;