nuxt-og-image 6.6.0 → 6.7.0

package/dist/shared/{nuxt-og-image.CfTPCtaS.cjs → nuxt-og-image.yDJBWXBt.cjs}

@@ -1,24 +1,22 @@
 'use strict';
 
+const node_crypto = require('node:crypto');
 const fs = require('node:fs');
 const promises = require('node:fs/promises');
 const node_url = require('node:url');
 const kit = require('@nuxt/kit');
 const defu = require('defu');
-const kit$2 = require('nuxt-site-config/kit');
+const kit$1 = require('nuxt-site-config/kit');
 const ohash = require('ohash');
 const pathe = require('pathe');
 const pkgTypes = require('pkg-types');
 const stdEnv = require('std-env');
-const node_crypto = require('node:crypto');
 const oxcWalker = require('oxc-walker');
-const kit$1 = require('nuxtseo-shared/kit');
-const logger_js = require('../../dist/runtime/logger.js');
-const chromeLauncher = require('chrome-launcher');
-const nypm = require('nypm');
+const dependencies = require('./nuxt-og-image.RI9DgjgV.cjs');
 const devtools = require('nuxtseo-shared/devtools');
 const unstorage = require('unstorage');
 const fsDriver = require('unstorage/drivers/fs-lite');
+const logger_js = require('../../dist/runtime/logger.js');
 const css_js = require('../../dist/runtime/server/og-image/utils/css.js');
 const MagicString = require('magic-string');
 const stripLiteral = require('strip-literal');
@@ -29,7 +27,7 @@ const ofetch = require('ofetch');
 const ultrahtml = require('ultrahtml');
 const emojiUtils_js = require('../../dist/runtime/server/og-image/core/transforms/emojis/emoji-utils.js');
 const exsolve = require('exsolve');
-const fonts = require('./nuxt-og-image.CMYbz66P.cjs');
+const kit$2 = require('nuxtseo-shared/kit');
 
 var _documentCurrentScript = typeof document !== 'undefined' ? document.currentScript : null;
 function _interopDefaultCompat (e) { return e && typeof e === 'object' && 'default' in e ? e.default : e; }
@@ -50,279 +48,9 @@ const fs__namespace = /*#__PURE__*/_interopNamespaceCompat(fs);
 const fsDriver__default = /*#__PURE__*/_interopDefaultCompat(fsDriver);
 const MagicString__default = /*#__PURE__*/_interopDefaultCompat(MagicString);
 
-const isUndefinedOrTruthy = (v) => typeof v === "undefined" || v !== false;
-function checkLocalChrome() {
-  if (stdEnv.isCI)
-    return false;
-  let hasChromeLocally = false;
-  try {
-    hasChromeLocally = !!chromeLauncher.Launcher.getFirstInstallation();
-  } catch {
-  }
-  return hasChromeLocally;
-}
-async function hasResolvableDependency(dep) {
-  return await kit.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 = pathe.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 = kit.useNuxt();
-  if (nuxt.options.dev)
-    return "nitro-dev";
-  if (nuxt.options.nitro.static)
-    return "nitro-prerender";
-  return kit$1.resolveNitroPreset(nitroConfig);
-}
-function getPresetNitroPresetCompatibility(target) {
-  const normalizedTarget = target.replace(RE_LEGACY_SUFFIX, "");
-  let compatibility = RuntimeCompatibility[normalizedTarget];
-  if (!compatibility) {
-    logger_js.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_js.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.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.defu(compatibility.wasm, nitroConfig.wasm);
-  nitroConfig.virtual["#og-image/compatibility"] = () => `export default ${JSON.stringify(resolvedCompatibility)}`;
-  kit.addTemplate({
-    filename: "nuxt-og-image/compatibility.mjs",
-    getContents() {
-      return `export default ${JSON.stringify(resolvedCompatibility)}`;
-    },
-    options: { mode: "server" }
-  });
-  return resolvedCompatibility;
-}
-async function ensureDependencies(dep, nuxt = kit.useNuxt()) {
-  const { ensureDependencyInstalled } = await import('nypm');
-  return Promise.all(dep.map((d) => {
-    return ensureDependencyInstalled(d, {
-      cwd: nuxt.options.rootDir,
-      dev: true
-    });
-  }));
-}
-
 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 = kit.useNuxt()) {
+async function setupBuildHandler(config, resolve, getDetectedRenderers, getCompatibilityMeta = () => ({}), nuxt = kit.useNuxt()) {
   nuxt.options.nitro.storage = nuxt.options.nitro.storage || {};
   if (typeof config.runtimeCacheStorage === "object")
     nuxt.options.nitro.storage["nuxt-og-image"] = config.runtimeCacheStorage;
@@ -342,9 +70,9 @@ async function setupBuildHandler(config, resolve, getDetectedRenderers, nuxt = k
   });
   nuxt.hooks.hook("nitro:init", async (nitro) => {
     const renderers = getDetectedRenderers();
-    await applyNitroPresetCompatibility(nitro.options, { compatibility: config.compatibility?.runtime, resolve, detectedRenderers: renderers });
-    const target = resolveOgImagePreset(nitro.options);
-    const normalizedTarget = target.replace(RE_LEGACY_SUFFIX, "");
+    await dependencies.applyNitroPresetCompatibility(nitro.options, { compatibility: config.compatibility?.runtime, resolve, detectedRenderers: renderers, metadata: getCompatibilityMeta() });
+    const target = dependencies.resolveOgImagePreset(nitro.options);
+    const normalizedTarget = target.replace(dependencies.RE_LEGACY_SUFFIX, "");
     const isEdgePreset = ["cloudflare", "cloudflare-pages", "cloudflare-pages-static", "cloudflare-module", "cloudflare-durable", "vercel-edge", "netlify-edge"].includes(normalizedTarget);
     const isCloudflarePreset = normalizedTarget.startsWith("cloudflare");
     const isCloudflarePagesOrModule = ["cloudflare-pages", "cloudflare-pages-static", "cloudflare-module", "cloudflare-durable"].includes(normalizedTarget);
@@ -356,7 +84,7 @@ async function setupBuildHandler(config, resolve, getDetectedRenderers, nuxt = k
       nitro.options.cloudflare.pages.routes.exclude.push("/_og/s/*");
     }
     nitro.hooks.hook("compiled", async (_nitro) => {
-      const compatibility = getPresetNitroPresetCompatibility(target);
+      const compatibility = dependencies.getPresetNitroPresetCompatibility(target);
       if (!isEdgePreset)
         return;
       const configuredEntry = nitro.options.rollupConfig?.output.entryFileNames;
@@ -475,194 +203,19 @@ 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 nypm.detectPackageManager(nuxt.options.rootDir);
-  const pmName = pm?.name || "npm";
-  logger_js.logger.info(`Installing ${provider} dependencies: ${missing.join(", ")}`);
-  const installed = [];
-  for (const pkg of missing) {
-    const success = await nypm.addDependency(pkg, {
-      cwd: nuxt.options.rootDir,
-      dev: false
-    }).then(() => {
-      installed.push(pkg);
-      return true;
-    }).catch(() => {
-      logger_js.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: stdEnv.hasTTY,
-  hasStdinTTY: Boolean(process.stdin?.isTTY),
-  isAgent: stdEnv.isAgent,
-  isCI: stdEnv.isCI
-}) {
-  return env.hasTTY && env.hasStdinTTY && !env.isAgent && !env.isCI;
-}
-async function promptForRendererSelection() {
-  logger_js.logger.info("Welcome to Nuxt OG Image! No renderer dependencies detected.");
-  const renderer = await logger_js.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 = kit.useNuxt()) {
+function setupDevHandler(options, resolve, getDetectedRenderers, getCompatibilityMeta = () => ({}), nuxt = kit.useNuxt()) {
   nuxt.hooks.hook("nitro:init", async (nitro) => {
     const detectedRenderers = new Set(getDetectedRenderers());
-    const targetCompatibility = getPresetNitroPresetCompatibility(resolveOgImagePreset(nitro.options));
+    const targetCompatibility = dependencies.getPresetNitroPresetCompatibility(dependencies.resolveOgImagePreset(nitro.options));
     for (const renderer of ["satori", "takumi", "browser"]) {
       if (!detectedRenderers.has(renderer)) {
-        const binding = getRecommendedBinding(renderer, targetCompatibility);
-        const missing = await getMissingDependencies(renderer, binding);
+        const binding = dependencies.getRecommendedBinding(renderer, targetCompatibility);
+        const missing = await dependencies.getMissingDependencies(renderer, binding);
         if (missing.length === 0)
           detectedRenderers.add(renderer);
       }
     }
-    await applyNitroPresetCompatibility(nitro.options, { compatibility: options.compatibility?.dev, resolve, detectedRenderers });
+    await dependencies.applyNitroPresetCompatibility(nitro.options, { compatibility: options.compatibility?.dev, resolve, detectedRenderers, metadata: getCompatibilityMeta() });
   });
 }
 
@@ -788,9 +341,9 @@ ${content}`, "utf-8");
       if (nameWithoutExt.includes(".")) {
         dotNotationName = `${nameWithoutExt}.vue`;
       } else {
-        const rendererMatch = nameWithoutExt.match(RE_RENDERER_SUFFIX);
+        const rendererMatch = nameWithoutExt.match(dependencies.RE_RENDERER_SUFFIX);
         const renderer = rendererMatch?.[1]?.toLowerCase() || "satori";
-        const baseName = nameWithoutExt.replace(RE_RENDERER_SUFFIX, "");
+        const baseName = nameWithoutExt.replace(dependencies.RE_RENDERER_SUFFIX, "");
         dotNotationName = `${baseName}.${renderer}.vue`;
       }
       const dir = pathe.join(nuxt.options.srcDir, "components", dirName || "");
@@ -1471,7 +1024,7 @@ async function downlevelColor(prop, value) {
 function convertIndividualTransforms(styles) {
   const parts = [];
   if (styles.translate) {
-    const vals = styles.translate.trim().split(RE_WHITESPACE);
+    const vals = styles.translate.trim().split(dependencies.RE_WHITESPACE);
     parts.push(vals.length === 2 ? `translate(${vals[0]}, ${vals[1]})` : `translateX(${vals[0]})`);
     delete styles.translate;
   }
@@ -1480,7 +1033,7 @@ function convertIndividualTransforms(styles) {
     delete styles.rotate;
   }
   if (styles.scale) {
-    const vals = styles.scale.trim().split(RE_WHITESPACE).filter(Boolean);
+    const vals = styles.scale.trim().split(dependencies.RE_WHITESPACE).filter(Boolean);
     parts.push(`scale(${vals.join(", ")})`);
     delete styles.scale;
   }
@@ -2113,7 +1666,7 @@ function resolveWeightsFromFontEntry(fontWeight, requestedWeights) {
     min = Number(fontWeight[0]);
     max = Number(fontWeight[1]);
   } else if (typeof fontWeight === "string") {
-    const parts = fontWeight.split(RE_WHITESPACE).map(Number);
+    const parts = fontWeight.split(dependencies.RE_WHITESPACE).map(Number);
     if (parts.length >= 2 && !Number.isNaN(parts[0]) && !Number.isNaN(parts[1])) {
       min = parts[0];
       max = parts[1];
@@ -2452,7 +2005,7 @@ ${familyBreakdown}`);
 
 function setupGenerateHandler(_options, resolve, _getDetectedRenderers, nuxt = kit.useNuxt()) {
   nuxt.hooks.hook("nitro:config", async (nitroConfig) => {
-    await applyNitroPresetCompatibility(nitroConfig, {
+    await dependencies.applyNitroPresetCompatibility(nitroConfig, {
       compatibility: {
         browser: false,
         satori: false,
@@ -2466,10 +2019,10 @@ function setupGenerateHandler(_options, resolve, _getDetectedRenderers, nuxt = k
 }
 
 const ONE_WEEK_MS = 7 * 24 * 60 * 60 * 1e3;
-function setupPrerenderHandler(options, resolve, getDetectedRenderers, nuxt = kit.useNuxt()) {
+function setupPrerenderHandler(options, resolve, getDetectedRenderers, getCompatibilityMeta = () => ({}), nuxt = kit.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 dependencies.applyNitroPresetCompatibility(nitroConfig, { compatibility: options.compatibility?.prerender, resolve, detectedRenderers: getDetectedRenderers(), metadata: getCompatibilityMeta() });
       nitroConfig.wasm = nitroConfig.wasm || {};
       nitroConfig.wasm.esmImport = false;
       nitroConfig.prerender = nitroConfig.prerender || {};
@@ -2557,6 +2110,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 } = ufo.parseURL(decodeURIComponent(node_url.pathToFileURL(id).href));
   if (id.endsWith(".vue") && !search) {
@@ -2671,7 +2233,7 @@ async function extractFontRequirementsFromVue(code) {
     const el = node;
     for (const prop of el.props) {
       if (prop.type === ATTRIBUTE_NODE$1 && prop.name === "class" && prop.value) {
-        for (const cls of prop.value.content.split(RE_WHITESPACE)) {
+        for (const cls of prop.value.content.split(dependencies.RE_WHITESPACE)) {
           extractFontWeightFromClass(cls, weights, styles);
           extractFontFamilyFromClass(cls, familyClasses, familyNames);
         }
@@ -2998,7 +2560,7 @@ async function transformVueTemplate(code, options) {
     };
     for (const prop of el.props) {
       if (prop.type === ATTRIBUTE_NODE && prop.name === "class" && prop.value) {
-        collector.classes = prop.value.content.split(RE_WHITESPACE).filter(Boolean);
+        collector.classes = prop.value.content.split(dependencies.RE_WHITESPACE).filter(Boolean);
         collector.classLoc = {
           start: prop.loc.start.offset,
           end: prop.loc.end.offset
@@ -3491,7 +3053,7 @@ const AssetTransformPlugin = unplugin.createUnplugin((options) => {
           const [fullMatch, , attrsStr, classValue] = elMatch;
           if (!classValue)
             continue;
-          const classes = classValue.split(RE_WHITESPACE).filter(Boolean);
+          const classes = classValue.split(dependencies.RE_WHITESPACE).filter(Boolean);
           let iconPrefix;
           let iconName;
           for (const cls of classes) {
@@ -3710,7 +3272,7 @@ const AssetTransformPlugin = unplugin.createUnplugin((options) => {
                 const classAttr = el.attributes?.class;
                 if (!classAttr)
                   return;
-                const elClasses = classAttr.split(RE_WHITESPACE).filter(Boolean);
+                const elClasses = classAttr.split(dependencies.RE_WHITESPACE).filter(Boolean);
                 const matchedStyles = {};
                 const consumedClasses = /* @__PURE__ */ new Set();
                 for (const cls of elClasses) {
@@ -4214,15 +3776,19 @@ async function onInstall(nuxt) {
   if (nuxt.options._prepare)
     return;
   if (stdEnv.isCI) {
-    const installedProviders2 = await getInstalledProviders();
+    const installedProviders2 = await dependencies.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 ${dependencies.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;
   }
-  if (!canPromptInteractively()) {
+  if (!dependencies.canPromptInteractively()) {
     logger_js.logger.info("Skipping interactive onboarding (non-interactive environment). Defaulting to the takumi renderer.");
     return;
   }
@@ -4232,7 +3798,7 @@ async function onInstall(nuxt) {
   logger_js.logger.info("\u2514\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2518");
   logger_js.logger.info("");
   const state = {};
-  const installedProviders = await getInstalledProviders();
+  const installedProviders = await dependencies.getInstalledProviders();
   if (installedProviders.length > 0) {
     logger_js.logger.info("Detected installed providers:");
     for (const { provider, binding } of installedProviders) {
@@ -4250,7 +3816,7 @@ async function onInstall(nuxt) {
   if (!state.selectedRenderer) {
     const rendererChoice = await logger_js.logger.prompt("Select a renderer:", {
       type: "select",
-      options: PROVIDER_DEPENDENCIES.map((p) => ({
+      options: dependencies.PROVIDER_DEPENDENCIES.map((p) => ({
         label: p.name,
         value: p.name,
         hint: p.description
@@ -4263,8 +3829,8 @@ async function onInstall(nuxt) {
     state.selectedRenderer = rendererChoice;
   }
   if (!state.selectedBinding) {
-    const recommendedBinding = getRecommendedBindingFromPreset(state.selectedRenderer);
-    const providerDef = PROVIDER_DEPENDENCIES.find((p) => p.name === state.selectedRenderer);
+    const recommendedBinding = dependencies.getRecommendedBindingFromPreset(state.selectedRenderer);
+    const providerDef = dependencies.PROVIDER_DEPENDENCIES.find((p) => p.name === state.selectedRenderer);
     const hasNodeBinding = !!providerDef?.bindings.node;
     const hasWasmBinding = !!providerDef?.bindings.wasm || !!providerDef?.bindings["wasm-fs"];
     if (hasNodeBinding && hasWasmBinding) {
@@ -4289,10 +3855,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 dependencies.getMissingDependencyInstallSpecs(state.selectedRenderer, state.selectedBinding);
+  if (missingInstallSpecs.length > 0) {
     logger_js.logger.info(`Required dependencies for ${state.selectedRenderer} (${state.selectedBinding}):`);
-    for (const pkg of missing) {
+    for (const pkg of missingInstallSpecs) {
       logger_js.logger.info(`  - ${pkg}`);
     }
     const installDeps = await logger_js.logger.prompt("Install missing dependencies?", {
@@ -4300,7 +3866,7 @@ async function onInstall(nuxt) {
       initial: true
     });
     if (installDeps) {
-      const result = await ensureProviderDependencies(
+      const result = await dependencies.ensureProviderDependencies(
         state.selectedRenderer,
         state.selectedBinding,
         nuxt
@@ -4309,11 +3875,11 @@ async function onInstall(nuxt) {
         logger_js.logger.success(`Installed: ${result.installed.join(", ")}`);
       } else {
         logger_js.logger.error("Failed to install some dependencies. Install manually:");
-        const allDeps = getProviderDependencies(state.selectedRenderer, state.selectedBinding);
+        const allDeps = dependencies.getProviderDependencyInstallSpecs(state.selectedRenderer, state.selectedBinding);
         logger_js.logger.info(`  npm add ${allDeps.join(" ")}`);
       }
     } else {
-      const allDeps = getProviderDependencies(state.selectedRenderer, state.selectedBinding);
+      const allDeps = dependencies.getProviderDependencyInstallSpecs(state.selectedRenderer, state.selectedBinding);
       logger_js.logger.warn("Dependencies required. Install manually:");
       logger_js.logger.info(`  npm add ${allDeps.join(" ")}`);
     }
@@ -4327,14 +3893,14 @@ async function onInstall(nuxt) {
   if (createComponent) {
     await createStarterComponent(nuxt);
   }
-  const hasSharp = await hasResolvableDependency("sharp");
+  const hasSharp = await dependencies.hasResolvableDependency("sharp");
   if (!hasSharp && state.selectedRenderer === "satori") {
     const wantJpeg = await logger_js.logger.prompt("Install sharp for JPEG output support?", {
       type: "confirm",
       initial: false
     });
     if (wantJpeg) {
-      await ensureProviderDependencies("satori", "node", nuxt).catch(() => logger_js.logger.warn("Failed to install sharp, JPEG output unavailable"));
+      await dependencies.ensureProviderDependencies("satori", "node", nuxt).catch(() => logger_js.logger.warn("Failed to install sharp, JPEG output unavailable"));
     }
   }
   logger_js.logger.info("");
@@ -4369,7 +3935,7 @@ async function onUpgrade(nuxt, _options, previousVersion) {
       issues.push(`Config \`defaults.component\` is deprecated: Removed \u2014 rename component to OgImage/Default.{renderer}.vue`);
     }
     if ("fonts" in ogImageConfig && !nuxt.options._prepare && !stdEnv.isCI) {
-      await fonts.promptFontsMigration(nuxt.options.rootDir);
+      await dependencies.promptFontsMigration(nuxt.options.rootDir);
     }
   }
   if (issues.length > 0) {
@@ -4386,17 +3952,17 @@ async function onUpgrade(nuxt, _options, previousVersion) {
   const ogComponentDir = pathe.join(nuxt.options.srcDir, "components", "OgImage");
   if (fs.existsSync(ogComponentDir)) {
     for (const file of fs.readdirSync(ogComponentDir).filter((f) => f.endsWith(".vue"))) {
-      const renderer = getRendererFromFilename(file);
+      const renderer = dependencies.getRendererFromFilename(file);
       if (renderer)
         detectedRenderers.add(renderer);
     }
   }
   if (detectedRenderers.size === 0)
     detectedRenderers.add("satori");
-  const preset = resolveOgImagePreset();
-  const compatibility = getPresetNitroPresetCompatibility(preset);
+  const preset = dependencies.resolveOgImagePreset();
+  const compatibility = dependencies.getPresetNitroPresetCompatibility(preset);
   for (const renderer of detectedRenderers) {
-    const validation = await validateProviderSetup(renderer, compatibility);
+    const validation = await dependencies.validateProviderSetup(renderer, compatibility);
     if (!validation.valid) {
       logger_js.logger.warn(`Provider setup issues for ${renderer}:`);
       for (const issue of validation.issues) {
@@ -4455,7 +4021,7 @@ function registerTypeTemplates(ctx) {
       const sortedDirs = config.componentDirs.sort((a, b) => b.length - a.length);
       const baseNameRenderers = /* @__PURE__ */ new Map();
       for (const component of componentCtx.components) {
-        for (const baseName of getRegisteredBaseNames(component.pascalName)) {
+        for (const baseName of dependencies.getRegisteredBaseNames(component.pascalName)) {
           const renderers = baseNameRenderers.get(baseName) || [];
           renderers.push(component.renderer);
           baseNameRenderers.set(baseName, renderers);
@@ -4466,7 +4032,7 @@ function registerTypeTemplates(ctx) {
         const importType = getComponentTypeExpression(component, nuxt);
         const strippedName = sortedDirs.reduce((n, dir) => n.replace(new RegExp(`^${dir}`), ""), component.pascalName);
         const renderer = component.renderer;
-        const baseNames = getRegisteredBaseNames(component.pascalName);
+        const baseNames = dependencies.getRegisteredBaseNames(component.pascalName);
         lines.push(`    '${strippedName}': ${importType}`);
         const seen = /* @__PURE__ */ new Set([strippedName]);
         for (const baseName of baseNames) {
@@ -4548,8 +4114,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' {
@@ -4665,6 +4231,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 = undefined.endsWith(".ts");
+async function findPackageVersionFromEntry(pkg, resolver) {
+  const entry = await resolver.resolvePath(pkg, { fallbackToOriginal: false }).catch(() => null);
+  if (!entry || entry === pkg)
+    return;
+  let dir = pathe.dirname(entry);
+  while (dir && dir !== pathe.dirname(dir)) {
+    const pkgPath = pathe.join(dir, "package.json");
+    if (fs.existsSync(pkgPath)) {
+      const pkgJson = await pkgTypes.readPackageJSON(pkgPath).catch(() => null);
+      if (pkgJson?.name === pkg)
+        return pkgJson.version;
+    }
+    dir = pathe.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_js.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);
 }
@@ -4713,7 +4317,7 @@ const module$1 = kit.defineNuxtModule({
     await onUpgrade(nuxt, options, previousVersion);
   },
   async setup(config, nuxt) {
-    const _resolver = kit.createResolver((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('shared/nuxt-og-image.CfTPCtaS.cjs', document.baseURI).href)));
+    const _resolver = kit.createResolver((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('shared/nuxt-og-image.yDJBWXBt.cjs', document.baseURI).href)));
     const fixSharedPath = (p) => {
       return p.replace(/\/shared\/runtime(\/|$)/, "/runtime$1").replace(/\/shared\/client(\/|$)/, "/client$1").replace(/\/shared\/devtools(\/|$)/, "/devtools$1");
     };
@@ -4744,23 +4348,30 @@ const module$1 = kit.defineNuxtModule({
     if (config.debug && !nuxt.options.dev) {
       logger_js.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,
+      () => node_crypto.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_js.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_js.logger.warn("OG image URL signing is disabled (`security.secret: false`). Anyone can craft arbitrary image generation requests.");
+      } else if (signing.generated) {
+        logger_js.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) {
@@ -4798,9 +4409,10 @@ Or pin to a specific version in package.json:
     }
     nuxt.options.alias["#og-image"] = resolve("./runtime");
     nuxt.options.alias["#og-image-cache"] = resolve("./runtime/server/og-image/cache/lru");
-    const preset = resolveOgImagePreset(nuxt.options.nitro);
-    const targetCompatibility = getPresetNitroPresetCompatibility(preset);
-    const normalizedPreset = preset.replace(RE_LEGACY_SUFFIX, "");
+    const preset = dependencies.resolveOgImagePreset(nuxt.options.nitro);
+    const targetCompatibility = dependencies.getPresetNitroPresetCompatibility(preset);
+    const runtimeCompatibilityMeta = {};
+    const normalizedPreset = preset.replace(dependencies.RE_LEGACY_SUFFIX, "");
     const isCloudflareWorkers = ["cloudflare", "cloudflare-module", "cloudflare-durable"].includes(normalizedPreset);
     if (isCloudflareWorkers) {
       nuxt.hooks.hook("nitro:init", (nitro) => {
@@ -5071,7 +4683,7 @@ ${familyInfo}`);
           }
         } else if (hasConfiguredJpegs) {
           logger_js.logger.warn("You have enabled `JPEG` images. These require the `sharp` dependency which is missing, installing it for you.");
-          await ensureDependencies(["sharp"]);
+          await dependencies.ensureDependencies(["sharp"]);
           logger_js.logger.warn("Support for `sharp` is limited so check the compatibility guide.");
           attemptSharpUsage = true;
         }
@@ -5085,8 +4697,8 @@ ${familyInfo}`);
       }
     }
     if (isProviderEnabledForEnv("browser", nuxt, config)) {
-      const hasChromeLocally = checkLocalChrome();
-      const hasPlaywrightDependency = await hasResolvableDependency("playwright");
+      const hasChromeLocally = dependencies.checkLocalChrome();
+      const hasPlaywrightDependency = await dependencies.hasResolvableDependency("playwright");
       const browserCompatibilityFlags = {
         prerender: config.compatibility?.prerender?.browser,
         dev: config.compatibility?.dev?.browser,
@@ -5103,7 +4715,7 @@ ${familyInfo}`);
         if (!browserConfig.binding) {
           throw new Error("[nuxt-og-image] `ogImage.browser.binding` is required when provider is cloudflare");
         }
-        const hasCloudfarePuppeteer = await hasResolvableDependency("@cloudflare/puppeteer");
+        const hasCloudfarePuppeteer = await dependencies.hasResolvableDependency("@cloudflare/puppeteer");
         if (!hasCloudfarePuppeteer) {
           throw new Error(
             "[nuxt-og-image] Missing @cloudflare/puppeteer dependency. Install it with: pnpm add @cloudflare/puppeteer"
@@ -5113,12 +4725,12 @@ ${familyInfo}`);
         browserBinding.prerender = hasPlaywrightDependency ? "playwright" : hasChromeLocally ? "chrome-launcher" : "on-demand";
         browserBinding.runtime = "cloudflare";
       } else if (nuxt.options.dev) {
-        if (isUndefinedOrTruthy(browserCompatibilityFlags.dev))
+        if (dependencies.isUndefinedOrTruthy(browserCompatibilityFlags.dev))
           browserBinding.dev = hasChromeLocally ? "chrome-launcher" : hasPlaywrightDependency ? "playwright" : "on-demand";
       } else {
-        if (isUndefinedOrTruthy(browserCompatibilityFlags.prerender))
+        if (dependencies.isUndefinedOrTruthy(browserCompatibilityFlags.prerender))
           browserBinding.prerender = hasChromeLocally ? "chrome-launcher" : hasPlaywrightDependency ? "playwright" : "on-demand";
-        if (isUndefinedOrTruthy(browserCompatibilityFlags.runtime))
+        if (dependencies.isUndefinedOrTruthy(browserCompatibilityFlags.runtime))
           browserBinding.runtime = hasPlaywrightDependency ? "playwright" : null;
       }
       config.compatibility = defu.defu(config.compatibility, {
@@ -5127,7 +4739,7 @@ ${familyInfo}`);
         prerender: { browser: browserBinding.prerender }
       });
     }
-    await kit$2.installNuxtSiteConfig();
+    await kit$1.installNuxtSiteConfig();
     nuxt.options.experimental.componentIslands ||= true;
     if (config.debug || nuxt.options.dev) {
       kit.addServerHandler({
@@ -5240,7 +4852,7 @@ ${familyInfo}`);
       if (isUserDir && fs__namespace.existsSync(resolvedPath)) {
         const files = fs__namespace.readdirSync(resolvedPath).filter((f) => f.endsWith(".vue"));
         for (const file of files) {
-          const renderer = getRendererFromFilename(file);
+          const renderer = dependencies.getRendererFromFilename(file);
           if (renderer) {
             ogImageComponentCtx.detectedRenderers.add(renderer);
             hasUserComponents = true;
@@ -5249,42 +4861,45 @@ ${familyInfo}`);
       }
     }
     if (!nuxt.options._prepare && !hasUserComponents) {
-      const installedProviders = await getInstalledProviders();
+      const installedProviders = await dependencies.getInstalledProviders();
       const preferred = installedProviders.find((p) => p.provider === "takumi") || installedProviders[0];
       if (preferred) {
         ogImageComponentCtx.detectedRenderers.add(preferred.provider);
         logger_js.logger.debug(`Using ${preferred.provider} renderer`);
-      } else if (nuxt.options.dev && !nuxt.options._prepare && canPromptInteractively()) {
-        const renderer = await promptForRendererSelection();
+      } else if (nuxt.options.dev && !nuxt.options._prepare && dependencies.canPromptInteractively()) {
+        const renderer = await dependencies.promptForRendererSelection();
         ogImageComponentCtx.detectedRenderers.add(renderer);
         logger_js.logger.debug(`Using ${renderer} renderer`);
       } else {
         ogImageComponentCtx.detectedRenderers.add("takumi");
-        logger_js.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_js.logger.warn(`No OG image renderer dependency detected. Defaulting to \`takumi\` (non-interactive environment). Install \`${dependencies.TAKUMI_CORE_INSTALL_SPEC}\`, or add a renderer component (e.g. components/OgImage/Default.satori.vue) to choose explicitly.`);
       }
     }
     const availableRenderers = /* @__PURE__ */ new Set();
     if (!nuxt.options._prepare) {
       if (!config.zeroRuntime) {
         for (const renderer of ogImageComponentCtx.detectedRenderers) {
-          const binding = getRecommendedBinding(renderer, targetCompatibility);
-          const missing = await getMissingDependencies(renderer, binding);
+          const binding = dependencies.getRecommendedBinding(renderer, targetCompatibility);
+          const missing = await dependencies.getMissingDependencies(renderer, binding);
           if (missing.length === 0) {
             availableRenderers.add(renderer);
           } else if (nuxt.options.dev && !nuxt.options._prepare) {
-            logger_js.logger.warn(`${renderer} renderer requires: ${missing.join(", ")}`);
-            const { success } = await ensureProviderDependencies(renderer, binding, nuxt);
+            const installSpecs = await dependencies.getMissingDependencyInstallSpecs(renderer, binding);
+            logger_js.logger.warn(`${renderer} renderer requires: ${installSpecs.join(", ")}`);
+            const { success } = await dependencies.ensureProviderDependencies(renderer, binding, nuxt);
             if (success) {
               availableRenderers.add(renderer);
             } else if (stdEnv.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_js.logger.error(`Failed to install ${renderer} dependencies. Templates using this renderer won't work.`);
             }
           } else if (stdEnv.isAgent) {
-            throw new Error(`[nuxt-og-image] ${renderer} renderer missing dependencies: ${missing.join(", ")}. Install with: npx nypm add ${missing.join(" ")}`);
+            const installSpecs = await dependencies.getMissingDependencyInstallSpecs(renderer, binding);
+            throw new Error(`[nuxt-og-image] ${renderer} renderer missing dependencies: ${missing.join(", ")}. Install with: npx nypm add ${installSpecs.join(" ")}`);
           } else {
-            logger_js.logger.error(`${renderer} renderer missing dependencies: ${missing.join(", ")}. Install with: npx nypm add ${missing.join(" ")}`);
+            const installSpecs = await dependencies.getMissingDependencyInstallSpecs(renderer, binding);
+            logger_js.logger.error(`${renderer} renderer missing dependencies: ${missing.join(", ")}. Install with: npx nypm add ${installSpecs.join(" ")}`);
           }
           if (renderer === "satori" && availableRenderers.has(renderer) && binding !== "node") {
             logger_js.logger.warn("ReSVG native binding not available. Falling back to WASM version, this may slow down PNG rendering.");
@@ -5304,11 +4919,19 @@ ${familyInfo}`);
           availableRenderers.add(renderer);
       }
     }
+    runtimeCompatibilityMeta.takumiVersion = await detectTakumiVersion(
+      resolver,
+      dependencies.getRecommendedBinding("takumi", targetCompatibility)
+    );
+    if (ogImageComponentCtx.detectedRenderers.has("takumi") && !runtimeCompatibilityMeta.takumiVersion) {
+      logger_js.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"]) {
-        const binding = getRecommendedBinding(renderer, targetCompatibility);
-        const missing = await getMissingDependencies(renderer, binding);
+        const binding = dependencies.getRecommendedBinding(renderer, targetCompatibility);
+        const missing = await dependencies.getMissingDependencies(renderer, binding);
         if (missing.length === 0)
           communityRenderers.add(renderer);
       }
@@ -5339,7 +4962,7 @@ ${familyInfo}`);
         if (valid && fs__namespace.existsSync(component.filePath)) {
           if (!component.filePath.endsWith(".vue"))
             return;
-          const renderer = getRendererFromFilename(component.filePath);
+          const renderer = dependencies.getRendererFromFilename(component.filePath);
           if (!renderer) {
             invalidComponents.push(component.filePath);
             return;
@@ -5370,18 +4993,18 @@ ${familyInfo}`);
         const communityDir = resolve("./runtime/app/components/Templates/Community");
         if (fs__namespace.existsSync(communityDir)) {
           fs__namespace.readdirSync(communityDir).filter((f) => f.endsWith(".vue")).forEach((file) => {
-            const renderer = getRendererFromFilename(file);
+            const renderer = dependencies.getRendererFromFilename(file);
             if (!renderer)
               return;
             const pascalName = file.replace(".vue", "").split(".").map((s, i) => i === 0 ? s : s.charAt(0).toUpperCase() + s.slice(1)).join("");
             const filePath = resolve(communityDir);
-            const communityBaseNames = getRegisteredBaseNames(pascalName);
+            const communityBaseNames = dependencies.getRegisteredBaseNames(pascalName);
             if (ogImageComponentCtx.components.some((c) => {
               if (c.pascalName === pascalName)
                 return true;
               if (c.renderer !== renderer)
                 return false;
-              const existingBaseNames = getRegisteredBaseNames(c.pascalName);
+              const existingBaseNames = dependencies.getRegisteredBaseNames(c.pascalName);
               return communityBaseNames.some((cb) => existingBaseNames.includes(cb));
             })) {
               return;
@@ -5402,10 +5025,12 @@ ${familyInfo}`);
       if (nuxt.options.dev) {
         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_js.logger.warn(`New ${renderer} component detected but dependencies missing: ${missing.join(", ")}. Install with: npx nypm add ${missing.join(" ")}`);
+            const binding = dependencies.getRecommendedBinding(renderer, targetCompatibility);
+            dependencies.getMissingDependencies(renderer, binding).then(async (missing) => {
+              if (missing.length > 0) {
+                const installSpecs = await dependencies.getMissingDependencyInstallSpecs(renderer, binding);
+                logger_js.logger.warn(`New ${renderer} component detected but dependencies missing: ${missing.join(", ")}. Install with: npx nypm add ${installSpecs.join(" ")}`);
+              }
             });
           }
         }
@@ -5451,7 +5076,7 @@ Run: npx nuxt-og-image migrate v6`;
       maxAge: 60 * 60 * 24 * 365
     });
     nuxt.options.nitro.virtual["#og-image-virtual/public-assets.mjs"] = async () => {
-      const normalizedPreset2 = preset.replace(RE_LEGACY_SUFFIX, "");
+      const normalizedPreset2 = preset.replace(dependencies.RE_LEGACY_SUFFIX, "");
       const isCloudflare = normalizedPreset2 === "cloudflare" || normalizedPreset2.startsWith("cloudflare-");
       if (isCloudflare) {
         const devBinding2 = resolver.resolve("./runtime/server/og-image/bindings/font-assets/dev-prerender");
@@ -5607,7 +5232,7 @@ export const rootDir = ${JSON.stringify(nuxt.options.rootDir)}`;
     const buildCacheDir = config.buildCache ? pathe.join(nuxt.options.rootDir, buildCachePath) : void 0;
     nuxt.hooks.hook("modules:done", async () => {
       const hasColorModeModule = kit.hasNuxtModule("@nuxtjs/color-mode");
-      const colorModeOptions = hasColorModeModule ? await kit$1.getNuxtModuleOptions("@nuxtjs/color-mode") : {};
+      const colorModeOptions = hasColorModeModule ? await kit$2.getNuxtModuleOptions("@nuxtjs/color-mode") : {};
       let colorPreference = colorModeOptions.preference;
       if (!colorPreference || colorPreference === "system")
         colorPreference = colorModeOptions.fallback;
@@ -5643,7 +5268,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) {
@@ -5657,7 +5282,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,
@@ -5678,8 +5303,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);
@@ -5710,14 +5336,14 @@ export const rootDir = ${JSON.stringify(nuxt.options.rootDir)}`;
           await nitro.hooks.callHook("rollup:reload");
         }
       });
-    } else if (kit$1.isNuxtGenerate()) {
+    } else if (kit$2.isNuxtGenerate()) {
       setupGenerateHandler(config, resolver);
     } else if (nuxt.options.build) {
-      await setupBuildHandler(config, resolver, getDetectedRenderers);
+      await setupBuildHandler(config, resolver, getDetectedRenderers, getCompatibilityMeta);
     }
     if (nuxt.options.build)
       kit.addServerPlugin(resolve("./runtime/server/plugins/prerender"));
-    setupPrerenderHandler(config, resolver, getDetectedRenderers);
+    setupPrerenderHandler(config, resolver, getDetectedRenderers, getCompatibilityMeta);
     if (nuxt.options.dev && hasWarnings()) {
       nuxt.hook("ready", () => {
         emitWarnings();