nuxt-og-image 6.6.0 → 6.7.0

package/dist/shared/{nuxt-og-image.DdbTs-xp.mjs → nuxt-og-image.CPSxZhVO.mjs}

@@ -1,23 +1,21 @@
+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 { resolvePath, useNuxt, addTemplate, updateTemplates, addTypeTemplate, defineNuxtModule, createResolver, addImports, hasNuxtModule, hasNuxtModuleCompatibility, getNuxtModuleVersion, addVitePlugin, addBuildPlugin, addServerHandler, addPlugin, addComponentsDir, addServerPlugin } from '@nuxt/kit';
+import { useNuxt, resolvePath, updateTemplates, addTypeTemplate, addTemplate, defineNuxtModule, createResolver, addImports, hasNuxtModule, hasNuxtModuleCompatibility, getNuxtModuleVersion, addVitePlugin, addBuildPlugin, addServerHandler, addPlugin, addComponentsDir, addServerPlugin } from '@nuxt/kit';
 import { defu } from 'defu';
 import { installNuxtSiteConfig } from 'nuxt-site-config/kit';
 import { hash } from 'ohash';
-import { basename, join, dirname, relative, isAbsolute, resolve } from 'pathe';
+import { join, dirname, relative, isAbsolute, resolve, basename } from 'pathe';
 import { readPackageJSON } from 'pkg-types';
-import { isCI, isAgent, hasTTY } from 'std-env';
-import { createHash } from 'node:crypto';
+import { isCI, isAgent } from 'std-env';
 import { parseAndWalk } from 'oxc-walker';
-import { resolveNitroPreset, getNuxtModuleOptions, isNuxtGenerate } from 'nuxtseo-shared/kit';
-import { logger } from '../../dist/runtime/logger.js';
-import { Launcher } from 'chrome-launcher';
-import { detectPackageManager, addDependency } from 'nypm';
+import { c as applyNitroPresetCompatibility, r as resolveOgImagePreset, R as RE_LEGACY_SUFFIX, g as getPresetNitroPresetCompatibility, d as getRecommendedBinding, e as getMissingDependencies, f as RE_RENDERER_SUFFIX, h as RE_WHITESPACE, p as promptFontsMigration, i as getRendererFromFilename, v as validateProviderSetup, j as getInstalledProviders, T as TAKUMI_CORE_INSTALL_SPEC, k as canPromptInteractively, P as PROVIDER_DEPENDENCIES, l as getRecommendedBindingFromPreset, n as getMissingDependencyInstallSpecs, o as ensureProviderDependencies, q as getProviderDependencyInstallSpecs, s as hasResolvableDependency, t as getRegisteredBaseNames, u as ensureDependencies, w as checkLocalChrome, x as promptForRendererSelection, y as isUndefinedOrTruthy } from './nuxt-og-image.DM30kcDz.mjs';
 import { setupDevToolsUI as setupDevToolsUI$1, setupDevToolsRpc } from 'nuxtseo-shared/devtools';
 import { createStorage } from 'unstorage';
 import fsDriver from 'unstorage/drivers/fs-lite';
+import { logger } from '../../dist/runtime/logger.js';
 import { resolveColorMix, GRADIENT_COLOR_SPACE_RE, splitCssDeclarations } from '../../dist/runtime/server/og-image/utils/css.js';
 import MagicString from 'magic-string';
 import { stripLiteral } from 'strip-literal';
@@ -28,281 +26,11 @@ import { ofetch } from 'ofetch';
 import { parse as parse$1, walkSync, ELEMENT_NODE as ELEMENT_NODE$2, renderSync } from 'ultrahtml';
 import { RE_MATCH_EMOJIS, getEmojiCodePoint, getEmojiIconNames } from '../../dist/runtime/server/og-image/core/transforms/emojis/emoji-utils.js';
 import { resolveModulePath } from 'exsolve';
-import { p as promptFontsMigration } from './nuxt-og-image.CJa2KCie.mjs';
-
-const isUndefinedOrTruthy = (v) => typeof v === "undefined" || v !== false;
-function checkLocalChrome() {
-  if (isCI)
-    return false;
-  let hasChromeLocally = false;
-  try {
-    hasChromeLocally = !!Launcher.getFirstInstallation();
-  } catch {
-  }
-  return hasChromeLocally;
-}
-async function hasResolvableDependency(dep) {
-  return await resolvePath(dep, { fallbackToOriginal: true }).catch(() => null).then((r) => r && r !== dep);
-}
-const VALID_RENDERER_SUFFIXES = ["satori", "browser", "takumi"];
-const RE_RENDERER_SUFFIX_CI = /\.?(satori|browser|takumi)$/i;
-const RE_RENDERER_SUFFIX = /(Satori|Browser|Takumi)$/;
-const RE_LEGACY_SUFFIX = /-legacy$/;
-const RE_WHITESPACE = /\s+/;
-function getRendererFromFilename(filepath) {
-  const filename = basename(filepath).replace(".vue", "");
-  for (const suffix of VALID_RENDERER_SUFFIXES) {
-    if (filename.endsWith(`.${suffix}`))
-      return suffix;
-  }
-  return null;
-}
-const OGIMAGE_PREFIXES = [
-  { prefix: "OgImageCommunity", overlapWord: "Community" },
-  { prefix: "OgImageTemplate", overlapWord: "Template" },
-  { prefix: "OgImage", overlapWord: "Image" }
-];
-function getRegisteredBaseNames(registeredPascalName) {
-  const stripped = registeredPascalName.replace(RE_RENDERER_SUFFIX_CI, "").replace(RE_RENDERER_SUFFIX, "");
-  const names = [];
-  for (const { prefix, overlapWord } of OGIMAGE_PREFIXES) {
-    if (!stripped.startsWith(prefix))
-      continue;
-    const withoutPrefix = stripped.slice(prefix.length);
-    if (withoutPrefix) {
-      names.push(withoutPrefix);
-      if (withoutPrefix !== overlapWord)
-        names.push(overlapWord + withoutPrefix);
-    } else {
-      names.push(overlapWord);
-    }
-    break;
-  }
-  if (names.length === 0)
-    names.push(stripped);
-  return names;
-}
-
-const NodeRuntime = {
-  // node-server runtime
-  browser: "on-demand",
-  // this gets changed build start
-  resvg: "node",
-  satori: "node",
-  takumi: "node",
-  sharp: "node",
-  // will be disabled if they're missing the dependency
-  emoji: "local"
-  // can bundle icons, no size constraints
-};
-const NodeDevRuntime = {
-  ...NodeRuntime,
-  resvg: "node-dev",
-  // use worker to prevent crashes from killing process
-  takumi: "node-dev"
-  // use worker to prevent crashes from killing process
-};
-const NodePrerenderRuntime = {
-  ...NodeRuntime,
-  resvg: "node-dev",
-  // use worker to prevent crashes from killing prerender process
-  takumi: "node-dev"
-  // use worker to prevent crashes from killing prerender process
-};
-const cloudflare = {
-  browser: "cloudflare",
-  resvg: "wasm",
-  satori: "wasm",
-  takumi: "wasm",
-  sharp: false,
-  emoji: "fetch",
-  // edge size limits - use API instead of bundling 24MB icons
-  wasm: {
-    esmImport: true
-    // Do NOT set lazy here — Nitro's cloudflare preset uses lazy: false because
-    // CF Workers require WASM modules to be imported eagerly via top-level await
-  }
-};
-const awsLambda = {
-  browser: false,
-  resvg: "node",
-  satori: "node",
-  takumi: "node",
-  sharp: false,
-  // 0.33.x has issues
-  emoji: "local"
-  // serverless has larger size limits
-};
-const WebContainer = {
-  browser: false,
-  resvg: "wasm-fs",
-  satori: "wasm-fs",
-  takumi: "wasm",
-  sharp: false,
-  emoji: "fetch"
-  // webcontainer has size constraints
-};
-const RuntimeCompatibility = {
-  "nitro-dev": NodeDevRuntime,
-  "nitro-prerender": NodePrerenderRuntime,
-  "node-server": NodeRuntime,
-  "node-cluster": NodeRuntime,
-  "node-listener": NodeRuntime,
-  "bun": NodeRuntime,
-  "deno-server": NodeRuntime,
-  "deno-deploy": NodeRuntime,
-  // node-server extending presets
-  "alwaysdata": NodeRuntime,
-  "cleavr": NodeRuntime,
-  "digital-ocean": NodeRuntime,
-  "edgio": NodeRuntime,
-  "flight-control": NodeRuntime,
-  "heroku": NodeRuntime,
-  "iis-handler": NodeRuntime,
-  "iis-node": NodeRuntime,
-  "koyeb": NodeRuntime,
-  "platform-sh": NodeRuntime,
-  "render-com": NodeRuntime,
-  "zeabur": NodeRuntime,
-  "zerops": NodeRuntime,
-  "stackblitz": WebContainer,
-  "codesandbox": WebContainer,
-  "aws-amplify": awsLambda,
-  "aws-lambda": awsLambda,
-  "azure": awsLambda,
-  "azure-functions": awsLambda,
-  "azure-swa": awsLambda,
-  "netlify": awsLambda,
-  "netlify-edge": {
-    browser: false,
-    resvg: "wasm",
-    satori: "node",
-    takumi: "wasm",
-    sharp: false,
-    emoji: "fetch",
-    // edge size limits
-    wasm: {
-      rollup: {
-        targetEnv: "auto-inline",
-        sync: ["@resvg/resvg-wasm/index_bg.wasm"]
-      }
-    }
-  },
-  "firebase": awsLambda,
-  "firebase-app-hosting": awsLambda,
-  "genezio": awsLambda,
-  "stormkit": awsLambda,
-  "vercel": awsLambda,
-  "vercel-edge": {
-    browser: false,
-    resvg: "wasm",
-    satori: "wasm",
-    takumi: "wasm",
-    sharp: false,
-    emoji: "fetch",
-    // edge size limits - bundling 24MB icons not viable
-    wasm: {
-      // lowers workers kb size
-      esmImport: true,
-      lazy: true
-    }
-  },
-  "cloudflare-pages": cloudflare,
-  "cloudflare-pages-static": cloudflare,
-  "cloudflare": cloudflare,
-  "cloudflare-module": cloudflare,
-  "cloudflare-durable": cloudflare
-};
-function resolveOgImagePreset(nitroConfig) {
-  const nuxt = useNuxt();
-  if (nuxt.options.dev)
-    return "nitro-dev";
-  if (nuxt.options.nitro.static)
-    return "nitro-prerender";
-  return resolveNitroPreset(nitroConfig);
-}
-function getPresetNitroPresetCompatibility(target) {
-  const normalizedTarget = target.replace(RE_LEGACY_SUFFIX, "");
-  let compatibility = RuntimeCompatibility[normalizedTarget];
-  if (!compatibility) {
-    logger.warn(`Unknown Nitro preset "${target}" \u2014 falling back to node-server compatibility. Set ogImage.compatibility.runtime to override.`);
-    compatibility = NodeRuntime;
-  }
-  return compatibility;
-}
-async function applyNitroPresetCompatibility(nitroConfig, options) {
-  const target = resolveOgImagePreset(nitroConfig);
-  const compatibility = getPresetNitroPresetCompatibility(target);
-  const { resolve, detectedRenderers } = options;
-  const satoriEnabled = detectedRenderers.has("satori");
-  const browserEnabled = detectedRenderers.has("browser");
-  const takumiEnabled = detectedRenderers.has("takumi");
-  for (const renderer of detectedRenderers) {
-    if (!compatibility[renderer]) {
-      logger.warn(`Renderer "${renderer}" detected but not supported on "${target}" preset. OG images using .${renderer}.vue components may fail.`);
-    }
-  }
-  const emptyMock = await resolve.resolvePath("./runtime/mock/empty");
-  nitroConfig.alias["#og-image/renderers/satori"] = satoriEnabled ? await resolve.resolvePath("./runtime/server/og-image/satori/renderer") : emptyMock;
-  nitroConfig.alias["#og-image/renderers/browser"] = browserEnabled ? await resolve.resolvePath("./runtime/server/og-image/browser/renderer") : emptyMock;
-  nitroConfig.alias["#og-image/renderers/takumi"] = takumiEnabled ? await resolve.resolvePath("./runtime/server/og-image/takumi/renderer") : emptyMock;
-  const resolvedCompatibility = {};
-  async function applyBinding(key) {
-    let binding = options.compatibility?.[key];
-    if (typeof binding === "undefined")
-      binding = compatibility[key];
-    const isRendererBinding = key === "browser" || key === "satori" || key === "takumi";
-    if (isRendererBinding && !detectedRenderers.has(key)) {
-      binding = false;
-    }
-    resolvedCompatibility[key] = binding;
-    if (!binding && isRendererBinding) {
-      nitroConfig.alias[`#og-image/renderers/${key}`] = emptyMock;
-    }
-    return {
-      [`#og-image/bindings/${key}`]: !binding ? emptyMock : await resolve.resolvePath(`./runtime/server/og-image/bindings/${key}/${binding}`)
-    };
-  }
-  const satoriPkgDir = await resolve.resolvePath("satori/package.json").then((p) => p.replace("/package.json", ""));
-  const yogaWasmPath = `${satoriPkgDir}/yoga.wasm`;
-  nitroConfig.alias = defu(
-    { "#og-image/yoga-wasm": `${yogaWasmPath}?module` },
-    await applyBinding("browser"),
-    await applyBinding("satori"),
-    await applyBinding("takumi"),
-    await applyBinding("resvg"),
-    await applyBinding("sharp"),
-    nitroConfig.alias || {}
-  );
-  if (Object.values(resolvedCompatibility).includes("wasm")) {
-    nitroConfig.experimental = nitroConfig.experimental || {};
-    nitroConfig.experimental.wasm = true;
-  }
-  nitroConfig.rollupConfig = nitroConfig.rollupConfig || {};
-  nitroConfig.wasm = defu(compatibility.wasm, nitroConfig.wasm);
-  nitroConfig.virtual["#og-image/compatibility"] = () => `export default ${JSON.stringify(resolvedCompatibility)}`;
-  addTemplate({
-    filename: "nuxt-og-image/compatibility.mjs",
-    getContents() {
-      return `export default ${JSON.stringify(resolvedCompatibility)}`;
-    },
-    options: { mode: "server" }
-  });
-  return resolvedCompatibility;
-}
-async function ensureDependencies(dep, nuxt = useNuxt()) {
-  const { ensureDependencyInstalled } = await import('nypm');
-  return Promise.all(dep.map((d) => {
-    return ensureDependencyInstalled(d, {
-      cwd: nuxt.options.rootDir,
-      dev: true
-    });
-  }));
-}
+import { getNuxtModuleOptions, isNuxtGenerate } from 'nuxtseo-shared/kit';
 
 const RE_REFLECT_HAS_MINIFIED = /Reflect\.has\(([\w$]+),([\w$]+)\)\?Reflect\.get\(\1,\2,([\w$]+)\):Reflect\.get\(([\w$]+),\2,\3\)/g;
 const RE_WASM_IMPORT = /import\("(\.\/wasm\/[^"]+\.wasm)"\)/g;
-async function setupBuildHandler(config, resolve, getDetectedRenderers, nuxt = useNuxt()) {
+async function setupBuildHandler(config, resolve, getDetectedRenderers, getCompatibilityMeta = () => ({}), nuxt = useNuxt()) {
   nuxt.options.nitro.storage = nuxt.options.nitro.storage || {};
   if (typeof config.runtimeCacheStorage === "object")
     nuxt.options.nitro.storage["nuxt-og-image"] = config.runtimeCacheStorage;
@@ -322,7 +50,7 @@ async function setupBuildHandler(config, resolve, getDetectedRenderers, nuxt = u
   });
   nuxt.hooks.hook("nitro:init", async (nitro) => {
     const renderers = getDetectedRenderers();
-    await applyNitroPresetCompatibility(nitro.options, { compatibility: config.compatibility?.runtime, resolve, detectedRenderers: renderers });
+    await applyNitroPresetCompatibility(nitro.options, { compatibility: config.compatibility?.runtime, resolve, detectedRenderers: renderers, metadata: getCompatibilityMeta() });
     const target = resolveOgImagePreset(nitro.options);
     const normalizedTarget = target.replace(RE_LEGACY_SUFFIX, "");
     const isEdgePreset = ["cloudflare", "cloudflare-pages", "cloudflare-pages-static", "cloudflare-module", "cloudflare-durable", "vercel-edge", "netlify-edge"].includes(normalizedTarget);
@@ -455,182 +183,7 @@ function patchWebAssemblyInstantiate(code) {
   return code;
 }
 
-const PROVIDER_DEPENDENCIES = [
-  {
-    name: "satori",
-    description: "SVG-based renderer using Satori",
-    bindings: {
-      "node": [
-        { name: "satori", description: "HTML to SVG renderer" },
-        { name: "@resvg/resvg-js", description: "SVG to PNG converter (native)" }
-      ],
-      "wasm": [
-        { name: "satori", description: "HTML to SVG renderer" },
-        { name: "@resvg/resvg-wasm", description: "SVG to PNG converter (WASM)" }
-      ],
-      "wasm-fs": [
-        { name: "satori", description: "HTML to SVG renderer" },
-        { name: "@resvg/resvg-wasm", description: "SVG to PNG converter (WASM)" }
-      ]
-    }
-  },
-  {
-    name: "takumi",
-    description: "Rust-based high-performance renderer (recommended)",
-    bindings: {
-      "node": [
-        { name: "@takumi-rs/core", description: "Native Takumi renderer" }
-      ],
-      "wasm": [
-        { name: "@takumi-rs/wasm", description: "WASM Takumi renderer" }
-      ],
-      "wasm-fs": [
-        { name: "@takumi-rs/wasm", description: "WASM Takumi renderer" }
-      ]
-    }
-  },
-  {
-    name: "browser",
-    description: "Browser-based screenshot renderer",
-    bindings: {
-      node: [
-        { name: "playwright-core", description: "Headless browser automation" }
-      ]
-    }
-  }
-];
-async function getInstalledProviders() {
-  const installed = [];
-  for (const provider of PROVIDER_DEPENDENCIES) {
-    if (provider.bindings.node) {
-      const allNodeInstalled = await Promise.all(
-        provider.bindings.node.map((dep) => hasResolvableDependency(dep.name))
-      );
-      if (allNodeInstalled.every(Boolean)) {
-        installed.push({ provider: provider.name, binding: "node" });
-        continue;
-      }
-    }
-    if (provider.bindings.wasm) {
-      const allWasmInstalled = await Promise.all(
-        provider.bindings.wasm.map((dep) => hasResolvableDependency(dep.name))
-      );
-      if (allWasmInstalled.every(Boolean)) {
-        installed.push({ provider: provider.name, binding: "wasm" });
-      }
-    }
-  }
-  return installed;
-}
-async function getMissingDependencies(provider, binding = "node") {
-  const providerDef = PROVIDER_DEPENDENCIES.find((p) => p.name === provider);
-  if (!providerDef)
-    return [];
-  const deps = providerDef.bindings[binding] || providerDef.bindings.node || [];
-  const missing = [];
-  for (const dep of deps) {
-    if (!await hasResolvableDependency(dep.name))
-      missing.push(dep.name);
-  }
-  return missing;
-}
-function getProviderDependencies(provider, binding = "node") {
-  const providerDef = PROVIDER_DEPENDENCIES.find((p) => p.name === provider);
-  if (!providerDef)
-    return [];
-  const deps = providerDef.bindings[binding] || providerDef.bindings.node || [];
-  return deps.map((d) => d.name);
-}
-function getRecommendedBindingFromPreset(provider) {
-  const preset = resolveOgImagePreset();
-  const compatibility = getPresetNitroPresetCompatibility(preset);
-  return getRecommendedBinding(provider, compatibility);
-}
-function getRecommendedBinding(provider, compatibility) {
-  if (provider === "satori") {
-    const resvgBinding = compatibility.resvg;
-    if (resvgBinding === "wasm-fs")
-      return "wasm-fs";
-    if (resvgBinding === "wasm")
-      return "wasm";
-    return "node";
-  }
-  if (provider === "takumi") {
-    const takumiBinding = compatibility.takumi;
-    if (takumiBinding === "wasm")
-      return "wasm";
-    return "node";
-  }
-  if (provider === "browser") {
-    return "node";
-  }
-  return "node";
-}
-async function ensureProviderDependencies(provider, binding, nuxt) {
-  const missing = await getMissingDependencies(provider, binding);
-  if (missing.length === 0)
-    return { success: true, installed: [] };
-  const pm = await detectPackageManager(nuxt.options.rootDir);
-  const pmName = pm?.name || "npm";
-  logger.info(`Installing ${provider} dependencies: ${missing.join(", ")}`);
-  const installed = [];
-  for (const pkg of missing) {
-    const success = await addDependency(pkg, {
-      cwd: nuxt.options.rootDir,
-      dev: false
-    }).then(() => {
-      installed.push(pkg);
-      return true;
-    }).catch(() => {
-      logger.error(`Failed to install ${pkg}. Run manually: ${pmName} add ${pkg}`);
-      return false;
-    });
-    if (!success)
-      return { success: false, installed };
-  }
-  return { success: true, installed };
-}
-function canPromptInteractively(env = {
-  hasTTY,
-  hasStdinTTY: Boolean(process.stdin?.isTTY),
-  isAgent,
-  isCI
-}) {
-  return env.hasTTY && env.hasStdinTTY && !env.isAgent && !env.isCI;
-}
-async function promptForRendererSelection() {
-  logger.info("Welcome to Nuxt OG Image! No renderer dependencies detected.");
-  const renderer = await logger.prompt("Which renderer would you like to use?", {
-    type: "select",
-    options: PROVIDER_DEPENDENCIES.map((p) => p.name),
-    initial: "takumi"
-  });
-  return renderer || "takumi";
-}
-async function validateProviderSetup(renderer, compatibility) {
-  const issues = [];
-  const binding = getRecommendedBinding(renderer, compatibility);
-  const missing = await getMissingDependencies(renderer, binding);
-  if (missing.length > 0) {
-    issues.push(`Missing ${renderer} dependencies: ${missing.join(", ")}`);
-  }
-  if (renderer === "satori") {
-    const hasResvgNode = await hasResolvableDependency("@resvg/resvg-js");
-    const hasResvgWasm = await hasResolvableDependency("@resvg/resvg-wasm");
-    if (!hasResvgNode && !hasResvgWasm) {
-      issues.push("Satori requires either @resvg/resvg-js (node) or @resvg/resvg-wasm to render PNGs");
-    }
-  }
-  if (renderer === "browser") {
-    const hasPlaywright = await hasResolvableDependency("playwright-core");
-    if (!hasPlaywright && binding === "node") {
-      issues.push("Browser renderer requires playwright-core");
-    }
-  }
-  return { valid: issues.length === 0, issues };
-}
-
-function setupDevHandler(options, resolve, getDetectedRenderers, nuxt = useNuxt()) {
+function setupDevHandler(options, resolve, getDetectedRenderers, getCompatibilityMeta = () => ({}), nuxt = useNuxt()) {
   nuxt.hooks.hook("nitro:init", async (nitro) => {
     const detectedRenderers = new Set(getDetectedRenderers());
     const targetCompatibility = getPresetNitroPresetCompatibility(resolveOgImagePreset(nitro.options));
@@ -642,7 +195,7 @@ function setupDevHandler(options, resolve, getDetectedRenderers, nuxt = useNuxt(
           detectedRenderers.add(renderer);
       }
     }
-    await applyNitroPresetCompatibility(nitro.options, { compatibility: options.compatibility?.dev, resolve, detectedRenderers });
+    await applyNitroPresetCompatibility(nitro.options, { compatibility: options.compatibility?.dev, resolve, detectedRenderers, metadata: getCompatibilityMeta() });
   });
 }
 
@@ -2446,10 +1999,10 @@ function setupGenerateHandler(_options, resolve, _getDetectedRenderers, nuxt = u
 }
 
 const ONE_WEEK_MS = 7 * 24 * 60 * 60 * 1e3;
-function setupPrerenderHandler(options, resolve, getDetectedRenderers, nuxt = useNuxt()) {
+function setupPrerenderHandler(options, resolve, getDetectedRenderers, getCompatibilityMeta = () => ({}), nuxt = useNuxt()) {
   nuxt.hooks.hook("nitro:init", async (nitro) => {
     nitro.hooks.hook("prerender:config", async (nitroConfig) => {
-      await applyNitroPresetCompatibility(nitroConfig, { compatibility: options.compatibility?.prerender, resolve, detectedRenderers: getDetectedRenderers() });
+      await applyNitroPresetCompatibility(nitroConfig, { compatibility: options.compatibility?.prerender, resolve, detectedRenderers: getDetectedRenderers(), metadata: getCompatibilityMeta() });
       nitroConfig.wasm = nitroConfig.wasm || {};
       nitroConfig.wasm.esmImport = false;
       nitroConfig.prerender = nitroConfig.prerender || {};
@@ -2537,6 +2090,15 @@ function extractPropNamesFromVue(code) {
   }
 }
 
+function resolveSigningSecret(configSecret, envSecret, generate) {
+  if (configSecret === false)
+    return { secret: "", hasExplicit: false, optOut: true, generated: false };
+  const explicit = configSecret || "" || (envSecret || "");
+  if (explicit)
+    return { secret: explicit, hasExplicit: true, optOut: false, generated: false };
+  return { secret: generate(), hasExplicit: false, optOut: false, generated: true };
+}
+
 function isVue(id, opts = {}) {
   const { search } = parseURL(decodeURIComponent(pathToFileURL(id).href));
   if (id.endsWith(".vue") && !search) {
@@ -4197,7 +3759,11 @@ async function onInstall(nuxt) {
     const installedProviders2 = await getInstalledProviders();
     if (installedProviders2.length === 0) {
       throw new Error(
-        "[nuxt-og-image] No OG image provider dependencies found. Install a provider before running in CI:\n  npm add @resvg/resvg-js satori yoga-wasm-web  # for satori\n  npm add playwright-core                       # for browser\nSee: https://nuxtseo.com/og-image/getting-started"
+        `[nuxt-og-image] No OG image provider dependencies found. Install a provider before running in CI:
+  npm add ${TAKUMI_CORE_INSTALL_SPEC}                # for takumi
+  npm add @resvg/resvg-js satori yoga-wasm-web  # for satori
+  npm add playwright-core                       # for browser
+See: https://nuxtseo.com/og-image/getting-started`
       );
     }
     return;
@@ -4269,10 +3835,10 @@ async function onInstall(nuxt) {
       state.selectedBinding = hasNodeBinding ? "node" : "wasm";
     }
   }
-  const missing = await getMissingDependencies(state.selectedRenderer, state.selectedBinding);
-  if (missing.length > 0) {
+  const missingInstallSpecs = await getMissingDependencyInstallSpecs(state.selectedRenderer, state.selectedBinding);
+  if (missingInstallSpecs.length > 0) {
     logger.info(`Required dependencies for ${state.selectedRenderer} (${state.selectedBinding}):`);
-    for (const pkg of missing) {
+    for (const pkg of missingInstallSpecs) {
       logger.info(`  - ${pkg}`);
     }
     const installDeps = await logger.prompt("Install missing dependencies?", {
@@ -4289,11 +3855,11 @@ async function onInstall(nuxt) {
         logger.success(`Installed: ${result.installed.join(", ")}`);
       } else {
         logger.error("Failed to install some dependencies. Install manually:");
-        const allDeps = getProviderDependencies(state.selectedRenderer, state.selectedBinding);
+        const allDeps = getProviderDependencyInstallSpecs(state.selectedRenderer, state.selectedBinding);
         logger.info(`  npm add ${allDeps.join(" ")}`);
       }
     } else {
-      const allDeps = getProviderDependencies(state.selectedRenderer, state.selectedBinding);
+      const allDeps = getProviderDependencyInstallSpecs(state.selectedRenderer, state.selectedBinding);
       logger.warn("Dependencies required. Install manually:");
       logger.info(`  npm add ${allDeps.join(" ")}`);
     }
@@ -4528,8 +4094,8 @@ declare module '#og-image-virtual/build-dir.mjs' {
 }
 
 declare module '#og-image/compatibility' {
-  import type { RuntimeCompatibilitySchema } from '${typesPath}'
-  const compatibility: Partial<Omit<RuntimeCompatibilitySchema, 'wasm'>>
+  import type { RuntimeCompatibilityPayload } from '${typesPath}'
+  const compatibility: RuntimeCompatibilityPayload
   export default compatibility
 }
 declare module '#og-image-virtual/tw4-theme.mjs' {
@@ -4645,6 +4211,44 @@ const RE_INLINE_CONFIG = /const\s+inlineConfig\s*=\s*(\{[\s\S]*?\n\})/;
 const RE_PASCAL_TO_KEBAB = /([a-z])([A-Z])/g;
 const RE_TILDE_PREFIX = /^~\//;
 const IS_MODULE_DEVELOPMENT = import.meta.filename.endsWith(".ts");
+async function findPackageVersionFromEntry(pkg, resolver) {
+  const entry = await resolver.resolvePath(pkg, { fallbackToOriginal: false }).catch(() => null);
+  if (!entry || entry === pkg)
+    return;
+  let dir = dirname(entry);
+  while (dir && dir !== dirname(dir)) {
+    const pkgPath = join(dir, "package.json");
+    if (existsSync(pkgPath)) {
+      const pkgJson = await readPackageJSON(pkgPath).catch(() => null);
+      if (pkgJson?.name === pkg)
+        return pkgJson.version;
+    }
+    dir = dirname(dir);
+  }
+}
+function normalizeTakumiVersion(version) {
+  const major = version ? Number.parseInt(version.split(".")[0], 10) : Number.NaN;
+  if (major >= 2)
+    return 2;
+  if (major === 1)
+    return 1;
+}
+async function detectTakumiVersion(resolver, binding) {
+  const packages = binding === "wasm" ? ["@takumi-rs/wasm", "@takumi-rs/core"] : ["@takumi-rs/core", "@takumi-rs/wasm"];
+  const versions = (await Promise.all(packages.map(async (pkg) => {
+    const version = await findPackageVersionFromEntry(pkg, resolver);
+    const major = normalizeTakumiVersion(version);
+    return version && major ? { pkg, version, major } : void 0;
+  }))).filter(Boolean);
+  const detectedMajors = new Set(versions.map(({ major }) => major));
+  if (detectedMajors.size > 1) {
+    const preferred = versions[0];
+    logger.warn(
+      `Mismatched @takumi-rs package major versions detected (${versions.map(({ pkg, version }) => `${pkg}@${version}`).join(", ")}). Using ${preferred.pkg}@${preferred.version} for Takumi v${preferred.major} compatibility.`
+    );
+  }
+  return versions[0]?.major;
+}
 function isProviderEnabledForEnv(provider, nuxt, config) {
   return nuxt.options.dev && config.compatibility?.dev?.[provider] !== false || !nuxt.options.dev && (config.compatibility?.runtime?.[provider] !== false || config.compatibility?.prerender?.[provider] !== false);
 }
@@ -4724,23 +4328,30 @@ const module$1 = defineNuxtModule({
     if (config.debug && !nuxt.options.dev) {
       logger.warn("`ogImage.debug` is enabled in production. This exposes the `/_og/debug.json` endpoint and should not be enabled in production. Disable it before deploying.");
     }
-    const hasSecret = !!(config.security?.secret || process.env.NUXT_OG_IMAGE_SECRET);
-    if (config.security?.strict && !hasSecret) {
+    const signing = resolveSigningSecret(
+      config.security?.secret,
+      process.env.NUXT_OG_IMAGE_SECRET,
+      () => randomBytes(32).toString("base64url")
+    );
+    const resolvedSecret = signing.secret;
+    if (config.security?.strict && !signing.hasExplicit) {
       throw new Error("[nuxt-og-image] `security.strict` requires a signing secret. Generate one with: npx nuxt-og-image generate-secret");
     }
-    if (nuxt.options.dev && !config.zeroRuntime && !hasSecret) {
-      logger.warn([
-        "OG image URLs are not signed. Anyone can craft arbitrary image generation requests.",
-        "",
-        "Set a signing secret via env variable:",
-        "  NUXT_OG_IMAGE_SECRET=<secret>",
-        "",
-        "  Generate one with: npx nuxt-og-image generate-secret",
-        "",
-        "Or enable zero-runtime mode to disable dynamic generation entirely:",
-        "  ogImage: { zeroRuntime: true }"
-      ].join("\n"));
-    }
+    nuxt.hook("nitro:init", (nitro) => {
+      const hasServerRuntime = !nitro.options.static && !nuxt.options._generate;
+      if (!nuxt.options.dev || config.zeroRuntime || !hasServerRuntime)
+        return;
+      if (signing.optOut) {
+        logger.warn("OG image URL signing is disabled (`security.secret: false`). Anyone can craft arbitrary image generation requests.");
+      } else if (signing.generated) {
+        logger.warn([
+          "OG image URLs are signed with an auto-generated secret that changes every build.",
+          "This is fine for single-instance deploys; for rolling or multi-instance deploys set a stable secret:",
+          "  NUXT_OG_IMAGE_SECRET=<secret>",
+          "  Generate one with: npx nuxt-og-image generate-secret"
+        ].join("\n"));
+      }
+    });
     const ogImageConfig = config;
     for (const key of Object.keys(REMOVED_CONFIG)) {
       if (key !== "chromium-node" && key !== "browser-node" && key in ogImageConfig && ogImageConfig[key] !== void 0) {
@@ -4780,6 +4391,7 @@ Or pin to a specific version in package.json:
     nuxt.options.alias["#og-image-cache"] = resolve("./runtime/server/og-image/cache/lru");
     const preset = resolveOgImagePreset(nuxt.options.nitro);
     const targetCompatibility = getPresetNitroPresetCompatibility(preset);
+    const runtimeCompatibilityMeta = {};
     const normalizedPreset = preset.replace(RE_LEGACY_SUFFIX, "");
     const isCloudflareWorkers = ["cloudflare", "cloudflare-module", "cloudflare-durable"].includes(normalizedPreset);
     if (isCloudflareWorkers) {
@@ -5240,7 +4852,7 @@ ${familyInfo}`);
         logger.debug(`Using ${renderer} renderer`);
       } else {
         ogImageComponentCtx.detectedRenderers.add("takumi");
-        logger.warn("No OG image renderer dependency detected. Defaulting to `takumi` (non-interactive environment). Install `@takumi-rs/core`, or add a renderer component (e.g. components/OgImage/Default.satori.vue) to choose explicitly.");
+        logger.warn(`No OG image renderer dependency detected. Defaulting to \`takumi\` (non-interactive environment). Install \`${TAKUMI_CORE_INSTALL_SPEC}\`, or add a renderer component (e.g. components/OgImage/Default.satori.vue) to choose explicitly.`);
       }
     }
     const availableRenderers = /* @__PURE__ */ new Set();
@@ -5252,19 +4864,22 @@ ${familyInfo}`);
           if (missing.length === 0) {
             availableRenderers.add(renderer);
           } else if (nuxt.options.dev && !nuxt.options._prepare) {
-            logger.warn(`${renderer} renderer requires: ${missing.join(", ")}`);
+            const installSpecs = await getMissingDependencyInstallSpecs(renderer, binding);
+            logger.warn(`${renderer} renderer requires: ${installSpecs.join(", ")}`);
             const { success } = await ensureProviderDependencies(renderer, binding, nuxt);
             if (success) {
               availableRenderers.add(renderer);
             } else if (isAgent) {
-              throw new Error(`[nuxt-og-image] Failed to install ${renderer} dependencies: ${missing.join(", ")}. Install manually: npx nypm add ${missing.join(" ")}`);
+              throw new Error(`[nuxt-og-image] Failed to install ${renderer} dependencies: ${missing.join(", ")}. Install manually: npx nypm add ${installSpecs.join(" ")}`);
             } else {
               logger.error(`Failed to install ${renderer} dependencies. Templates using this renderer won't work.`);
             }
           } else if (isAgent) {
-            throw new Error(`[nuxt-og-image] ${renderer} renderer missing dependencies: ${missing.join(", ")}. Install with: npx nypm add ${missing.join(" ")}`);
+            const installSpecs = await getMissingDependencyInstallSpecs(renderer, binding);
+            throw new Error(`[nuxt-og-image] ${renderer} renderer missing dependencies: ${missing.join(", ")}. Install with: npx nypm add ${installSpecs.join(" ")}`);
           } else {
-            logger.error(`${renderer} renderer missing dependencies: ${missing.join(", ")}. Install with: npx nypm add ${missing.join(" ")}`);
+            const installSpecs = await getMissingDependencyInstallSpecs(renderer, binding);
+            logger.error(`${renderer} renderer missing dependencies: ${missing.join(", ")}. Install with: npx nypm add ${installSpecs.join(" ")}`);
           }
           if (renderer === "satori" && availableRenderers.has(renderer) && binding !== "node") {
             logger.warn("ReSVG native binding not available. Falling back to WASM version, this may slow down PNG rendering.");
@@ -5284,6 +4899,14 @@ ${familyInfo}`);
           availableRenderers.add(renderer);
       }
     }
+    runtimeCompatibilityMeta.takumiVersion = await detectTakumiVersion(
+      resolver,
+      getRecommendedBinding("takumi", targetCompatibility)
+    );
+    if (ogImageComponentCtx.detectedRenderers.has("takumi") && !runtimeCompatibilityMeta.takumiVersion) {
+      logger.warn("Unable to detect @takumi-rs version. Falling back to Takumi v1 renderer compatibility.");
+      runtimeCompatibilityMeta.takumiVersion = 1;
+    }
     if (nuxt.options.dev) {
       const communityRenderers = /* @__PURE__ */ new Set();
       for (const renderer of ["satori", "takumi", "browser"]) {
@@ -5383,9 +5006,11 @@ ${familyInfo}`);
         for (const renderer of ogImageComponentCtx.detectedRenderers) {
           if (!availableRenderers.has(renderer)) {
             const binding = getRecommendedBinding(renderer, targetCompatibility);
-            getMissingDependencies(renderer, binding).then((missing) => {
-              if (missing.length > 0)
-                logger.warn(`New ${renderer} component detected but dependencies missing: ${missing.join(", ")}. Install with: npx nypm add ${missing.join(" ")}`);
+            getMissingDependencies(renderer, binding).then(async (missing) => {
+              if (missing.length > 0) {
+                const installSpecs = await getMissingDependencyInstallSpecs(renderer, binding);
+                logger.warn(`New ${renderer} component detected but dependencies missing: ${missing.join(", ")}. Install with: npx nypm add ${installSpecs.join(" ")}`);
+              }
             });
           }
         }
@@ -5623,7 +5248,7 @@ export const rootDir = ${JSON.stringify(nuxt.options.rootDir)}`;
           imageFetchTimeout: config.security?.imageFetchTimeout ?? 3e3,
           maxQueryParamSize: config.security?.maxQueryParamSize ?? (config.security?.strict ? 2048 : null),
           restrictRuntimeImagesToOrigin: config.security?.restrictRuntimeImagesToOrigin === true || config.security?.strict && config.security?.restrictRuntimeImagesToOrigin == null ? [] : config.security?.restrictRuntimeImagesToOrigin || false,
-          secret: config.security?.secret || process.env.NUXT_OG_IMAGE_SECRET || ""
+          secret: resolvedSecret
         }
       };
       if (nuxt.options.dev) {
@@ -5637,7 +5262,7 @@ export const rootDir = ${JSON.stringify(nuxt.options.rootDir)}`;
       const existingOgImageCfg = nuxt.options.runtimeConfig.ogImage;
       nuxt.options.runtimeConfig.ogImage = {
         ...existingOgImageCfg && typeof existingOgImageCfg === "object" ? existingOgImageCfg : {},
-        secret: existingOgImageCfg?.secret || config.security?.secret || process.env.NUXT_OG_IMAGE_SECRET || ""
+        secret: existingOgImageCfg?.secret || (signing.hasExplicit ? signing.secret : "")
       };
       nuxt.options.runtimeConfig.public = {
         ...nuxt.options.runtimeConfig.public,
@@ -5658,8 +5283,9 @@ export const rootDir = ${JSON.stringify(nuxt.options.rootDir)}`;
       };
     });
     const getDetectedRenderers = () => ogImageComponentCtx.detectedRenderers;
+    const getCompatibilityMeta = () => runtimeCompatibilityMeta;
     if (nuxt.options.dev) {
-      setupDevHandler(config, resolver, getDetectedRenderers);
+      setupDevHandler(config, resolver, getDetectedRenderers, getCompatibilityMeta);
       setupDevToolsUI(config, resolve, nuxt, cssFramework || "none");
       const useNitro = new Promise((resolveNitro) => {
         nuxt.hooks.hook("nitro:init", resolveNitro);
@@ -5693,11 +5319,11 @@ export const rootDir = ${JSON.stringify(nuxt.options.rootDir)}`;
     } else if (isNuxtGenerate()) {
       setupGenerateHandler(config, resolver);
     } else if (nuxt.options.build) {
-      await setupBuildHandler(config, resolver, getDetectedRenderers);
+      await setupBuildHandler(config, resolver, getDetectedRenderers, getCompatibilityMeta);
     }
     if (nuxt.options.build)
       addServerPlugin(resolve("./runtime/server/plugins/prerender"));
-    setupPrerenderHandler(config, resolver, getDetectedRenderers);
+    setupPrerenderHandler(config, resolver, getDetectedRenderers, getCompatibilityMeta);
     if (nuxt.options.dev && hasWarnings()) {
       nuxt.hook("ready", () => {
         emitWarnings();