nuxt-og-image 6.7.2 → 6.7.4

package/dist/shared/{nuxt-og-image.BCK8Adm4.cjs → nuxt-og-image.BRBtdkUp.cjs}

@@ -6,17 +6,19 @@ const promises = require('node:fs/promises');
 const node_url = require('node:url');
 const kit = require('@nuxt/kit');
 const defu = require('defu');
-const kit$1 = require('nuxt-site-config/kit');
-const ohash = require('ohash');
+const fnv1a64 = require('fnv1a-64');
+const kit$2 = require('nuxt-site-config/kit');
 const pathe = require('pathe');
 const pkgTypes = require('pkg-types');
 const stdEnv = require('std-env');
 const oxcWalker = require('oxc-walker');
-const dependencies = require('./nuxt-og-image.DQkJQHaN.cjs');
+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 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');
@@ -27,7 +29,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 kit$2 = require('nuxtseo-shared/kit');
+const fonts = require('./nuxt-og-image.CMYbz66P.cjs');
 
 var _documentCurrentScript = typeof document !== 'undefined' ? document.currentScript : null;
 function _interopDefaultCompat (e) { return e && typeof e === 'object' && 'default' in e ? e.default : e; }
@@ -48,6 +50,276 @@ 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 = { ...options.metadata || {} };
+  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, getCompatibilityMeta = () => ({}), nuxt = kit.useNuxt()) {
@@ -70,9 +342,9 @@ async function setupBuildHandler(config, resolve, getDetectedRenderers, getCompa
   });
   nuxt.hooks.hook("nitro:init", async (nitro) => {
     const renderers = getDetectedRenderers();
-    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, "");
+    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);
     const isCloudflarePreset = normalizedTarget.startsWith("cloudflare");
     const isCloudflarePagesOrModule = ["cloudflare-pages", "cloudflare-pages-static", "cloudflare-module", "cloudflare-durable"].includes(normalizedTarget);
@@ -84,7 +356,7 @@ async function setupBuildHandler(config, resolve, getDetectedRenderers, getCompa
       nitro.options.cloudflare.pages.routes.exclude.push("/_og/s/*");
     }
     nitro.hooks.hook("compiled", async (_nitro) => {
-      const compatibility = dependencies.getPresetNitroPresetCompatibility(target);
+      const compatibility = getPresetNitroPresetCompatibility(target);
       if (!isEdgePreset)
         return;
       const configuredEntry = nitro.options.rollupConfig?.output.entryFileNames;
@@ -203,19 +475,211 @@ function patchWebAssemblyInstantiate(code) {
   return code;
 }
 
+const TAKUMI_CORE_PACKAGE = "@takumi-rs/core";
+const TAKUMI_WASM_PACKAGE = "@takumi-rs/wasm";
+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_CORE_PACKAGE, description: "Native Takumi renderer" }
+      ],
+      "wasm": [
+        { name: TAKUMI_WASM_PACKAGE, description: "WASM Takumi renderer" }
+      ],
+      "wasm-fs": [
+        { name: TAKUMI_WASM_PACKAGE, 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 missing = await getMissingProviderDependencyDefinitions(provider, binding);
+  return missing.map((d) => d.name);
+}
+async function getMissingProviderDependencyDefinitions(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);
+  }
+  return missing;
+}
+function getDependencyDefinitions(provider, binding = "node") {
+  const providerDef = PROVIDER_DEPENDENCIES.find((p) => p.name === provider);
+  if (!providerDef)
+    return [];
+  return providerDef.bindings[binding] || providerDef.bindings.node || [];
+}
+function getDependencyInstallSpec(dep) {
+  return dep.installSpec || dep.name;
+}
+async function getMissingDependencyInstallSpecs(provider, binding = "node") {
+  const missing = await getMissingProviderDependencyDefinitions(provider, binding);
+  return missing.map(getDependencyInstallSpec);
+}
+function getProviderDependencyInstallSpecs(provider, binding = "node") {
+  return getDependencyDefinitions(provider, binding).map(getDependencyInstallSpec);
+}
+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 missingDeps = await getMissingProviderDependencyDefinitions(provider, binding);
+  if (missingDeps.length === 0)
+    return { success: true, installed: [] };
+  const missingInstallSpecs = missingDeps.map(getDependencyInstallSpec);
+  const pm = await nypm.detectPackageManager(nuxt.options.rootDir);
+  const pmName = pm?.name || "npm";
+  logger_js.logger.info(`Installing ${provider} dependencies: ${missingInstallSpecs.join(", ")}`);
+  const installed = [];
+  for (const dep of missingDeps) {
+    const installSpec = getDependencyInstallSpec(dep);
+    const success = await nypm.addDependency(installSpec, {
+      cwd: nuxt.options.rootDir,
+      dev: false
+    }).then(() => {
+      installed.push(installSpec);
+      return true;
+    }).catch(() => {
+      logger_js.logger.error(`Failed to install ${installSpec}. Run manually: ${pmName} add ${installSpec}`);
+      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 getMissingDependencyInstallSpecs(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, getCompatibilityMeta = () => ({}), nuxt = kit.useNuxt()) {
   nuxt.hooks.hook("nitro:init", async (nitro) => {
     const detectedRenderers = new Set(getDetectedRenderers());
-    const targetCompatibility = dependencies.getPresetNitroPresetCompatibility(dependencies.resolveOgImagePreset(nitro.options));
+    const targetCompatibility = getPresetNitroPresetCompatibility(resolveOgImagePreset(nitro.options));
     for (const renderer of ["satori", "takumi", "browser"]) {
       if (!detectedRenderers.has(renderer)) {
-        const binding = dependencies.getRecommendedBinding(renderer, targetCompatibility);
-        const missing = await dependencies.getMissingDependencies(renderer, binding);
+        const binding = getRecommendedBinding(renderer, targetCompatibility);
+        const missing = await getMissingDependencies(renderer, binding);
         if (missing.length === 0)
           detectedRenderers.add(renderer);
       }
     }
-    await dependencies.applyNitroPresetCompatibility(nitro.options, { compatibility: options.compatibility?.dev, resolve, detectedRenderers, metadata: getCompatibilityMeta() });
+    await applyNitroPresetCompatibility(nitro.options, { compatibility: options.compatibility?.dev, resolve, detectedRenderers, metadata: getCompatibilityMeta() });
   });
 }
 
@@ -341,9 +805,9 @@ ${content}`, "utf-8");
       if (nameWithoutExt.includes(".")) {
         dotNotationName = `${nameWithoutExt}.vue`;
       } else {
-        const rendererMatch = nameWithoutExt.match(dependencies.RE_RENDERER_SUFFIX);
+        const rendererMatch = nameWithoutExt.match(RE_RENDERER_SUFFIX);
         const renderer = rendererMatch?.[1]?.toLowerCase() || "satori";
-        const baseName = nameWithoutExt.replace(dependencies.RE_RENDERER_SUFFIX, "");
+        const baseName = nameWithoutExt.replace(RE_RENDERER_SUFFIX, "");
         dotNotationName = `${baseName}.${renderer}.vue`;
       }
       const dir = pathe.join(nuxt.options.srcDir, "components", dirName || "");
@@ -1024,7 +1488,7 @@ async function downlevelColor(prop, value) {
 function convertIndividualTransforms(styles) {
   const parts = [];
   if (styles.translate) {
-    const vals = styles.translate.trim().split(dependencies.RE_WHITESPACE);
+    const vals = styles.translate.trim().split(RE_WHITESPACE);
     parts.push(vals.length === 2 ? `translate(${vals[0]}, ${vals[1]})` : `translateX(${vals[0]})`);
     delete styles.translate;
   }
@@ -1033,7 +1497,7 @@ function convertIndividualTransforms(styles) {
     delete styles.rotate;
   }
   if (styles.scale) {
-    const vals = styles.scale.trim().split(dependencies.RE_WHITESPACE).filter(Boolean);
+    const vals = styles.scale.trim().split(RE_WHITESPACE).filter(Boolean);
     parts.push(`scale(${vals.join(", ")})`);
     delete styles.scale;
   }
@@ -1666,7 +2130,7 @@ function resolveWeightsFromFontEntry(fontWeight, requestedWeights) {
     min = Number(fontWeight[0]);
     max = Number(fontWeight[1]);
   } else if (typeof fontWeight === "string") {
-    const parts = fontWeight.split(dependencies.RE_WHITESPACE).map(Number);
+    const parts = fontWeight.split(RE_WHITESPACE).map(Number);
     if (parts.length >= 2 && !Number.isNaN(parts[0]) && !Number.isNaN(parts[1])) {
       min = parts[0];
       max = parts[1];
@@ -2005,7 +2469,7 @@ ${familyBreakdown}`);
 
 function setupGenerateHandler(_options, resolve, _getDetectedRenderers, nuxt = kit.useNuxt()) {
   nuxt.hooks.hook("nitro:config", async (nitroConfig) => {
-    await dependencies.applyNitroPresetCompatibility(nitroConfig, {
+    await applyNitroPresetCompatibility(nitroConfig, {
       compatibility: {
         browser: false,
         satori: false,
@@ -2022,7 +2486,7 @@ const ONE_WEEK_MS = 7 * 24 * 60 * 60 * 1e3;
 function setupPrerenderHandler(options, resolve, getDetectedRenderers, getCompatibilityMeta = () => ({}), nuxt = kit.useNuxt()) {
   nuxt.hooks.hook("nitro:init", async (nitro) => {
     nitro.hooks.hook("prerender:config", async (nitroConfig) => {
-      await dependencies.applyNitroPresetCompatibility(nitroConfig, { compatibility: options.compatibility?.prerender, resolve, detectedRenderers: getDetectedRenderers(), metadata: getCompatibilityMeta() });
+      await applyNitroPresetCompatibility(nitroConfig, { compatibility: options.compatibility?.prerender, resolve, detectedRenderers: getDetectedRenderers(), metadata: getCompatibilityMeta() });
       nitroConfig.wasm = nitroConfig.wasm || {};
       nitroConfig.wasm.esmImport = false;
       nitroConfig.prerender = nitroConfig.prerender || {};
@@ -2233,7 +2697,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(dependencies.RE_WHITESPACE)) {
+        for (const cls of prop.value.content.split(RE_WHITESPACE)) {
           extractFontWeightFromClass(cls, weights, styles);
           extractFontFamilyFromClass(cls, familyClasses, familyNames);
         }
@@ -2560,7 +3024,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(dependencies.RE_WHITESPACE).filter(Boolean);
+        collector.classes = prop.value.content.split(RE_WHITESPACE).filter(Boolean);
         collector.classLoc = {
           start: prop.loc.start.offset,
           end: prop.loc.end.offset
@@ -3053,7 +3517,7 @@ const AssetTransformPlugin = unplugin.createUnplugin((options) => {
           const [fullMatch, , attrsStr, classValue] = elMatch;
           if (!classValue)
             continue;
-          const classes = classValue.split(dependencies.RE_WHITESPACE).filter(Boolean);
+          const classes = classValue.split(RE_WHITESPACE).filter(Boolean);
           let iconPrefix;
           let iconName;
           for (const cls of classes) {
@@ -3272,7 +3736,7 @@ const AssetTransformPlugin = unplugin.createUnplugin((options) => {
                 const classAttr = el.attributes?.class;
                 if (!classAttr)
                   return;
-                const elClasses = classAttr.split(dependencies.RE_WHITESPACE).filter(Boolean);
+                const elClasses = classAttr.split(RE_WHITESPACE).filter(Boolean);
                 const matchedStyles = {};
                 const consumedClasses = /* @__PURE__ */ new Set();
                 for (const cls of elClasses) {
@@ -3776,11 +4240,11 @@ async function onInstall(nuxt) {
   if (nuxt.options._prepare)
     return;
   if (stdEnv.isCI) {
-    const installedProviders2 = await dependencies.getInstalledProviders();
+    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:
-  npm add ${dependencies.TAKUMI_CORE_INSTALL_SPEC}                # for takumi
+  npm add ${TAKUMI_CORE_PACKAGE}                # 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`
@@ -3788,7 +4252,7 @@ See: https://nuxtseo.com/og-image/getting-started`
     }
     return;
   }
-  if (!dependencies.canPromptInteractively()) {
+  if (!canPromptInteractively()) {
     logger_js.logger.info("Skipping interactive onboarding (non-interactive environment). Defaulting to the takumi renderer.");
     return;
   }
@@ -3798,7 +4262,7 @@ See: https://nuxtseo.com/og-image/getting-started`
   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 dependencies.getInstalledProviders();
+  const installedProviders = await getInstalledProviders();
   if (installedProviders.length > 0) {
     logger_js.logger.info("Detected installed providers:");
     for (const { provider, binding } of installedProviders) {
@@ -3816,7 +4280,7 @@ See: https://nuxtseo.com/og-image/getting-started`
   if (!state.selectedRenderer) {
     const rendererChoice = await logger_js.logger.prompt("Select a renderer:", {
       type: "select",
-      options: dependencies.PROVIDER_DEPENDENCIES.map((p) => ({
+      options: PROVIDER_DEPENDENCIES.map((p) => ({
         label: p.name,
         value: p.name,
         hint: p.description
@@ -3829,8 +4293,8 @@ See: https://nuxtseo.com/og-image/getting-started`
     state.selectedRenderer = rendererChoice;
   }
   if (!state.selectedBinding) {
-    const recommendedBinding = dependencies.getRecommendedBindingFromPreset(state.selectedRenderer);
-    const providerDef = dependencies.PROVIDER_DEPENDENCIES.find((p) => p.name === state.selectedRenderer);
+    const recommendedBinding = getRecommendedBindingFromPreset(state.selectedRenderer);
+    const providerDef = 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) {
@@ -3855,7 +4319,7 @@ See: https://nuxtseo.com/og-image/getting-started`
       state.selectedBinding = hasNodeBinding ? "node" : "wasm";
     }
   }
-  const missingInstallSpecs = await dependencies.getMissingDependencyInstallSpecs(state.selectedRenderer, state.selectedBinding);
+  const missingInstallSpecs = await getMissingDependencyInstallSpecs(state.selectedRenderer, state.selectedBinding);
   if (missingInstallSpecs.length > 0) {
     logger_js.logger.info(`Required dependencies for ${state.selectedRenderer} (${state.selectedBinding}):`);
     for (const pkg of missingInstallSpecs) {
@@ -3866,7 +4330,7 @@ See: https://nuxtseo.com/og-image/getting-started`
       initial: true
     });
     if (installDeps) {
-      const result = await dependencies.ensureProviderDependencies(
+      const result = await ensureProviderDependencies(
         state.selectedRenderer,
         state.selectedBinding,
         nuxt
@@ -3875,11 +4339,11 @@ See: https://nuxtseo.com/og-image/getting-started`
         logger_js.logger.success(`Installed: ${result.installed.join(", ")}`);
       } else {
         logger_js.logger.error("Failed to install some dependencies. Install manually:");
-        const allDeps = dependencies.getProviderDependencyInstallSpecs(state.selectedRenderer, state.selectedBinding);
+        const allDeps = getProviderDependencyInstallSpecs(state.selectedRenderer, state.selectedBinding);
         logger_js.logger.info(`  npm add ${allDeps.join(" ")}`);
       }
     } else {
-      const allDeps = dependencies.getProviderDependencyInstallSpecs(state.selectedRenderer, state.selectedBinding);
+      const allDeps = getProviderDependencyInstallSpecs(state.selectedRenderer, state.selectedBinding);
       logger_js.logger.warn("Dependencies required. Install manually:");
       logger_js.logger.info(`  npm add ${allDeps.join(" ")}`);
     }
@@ -3893,14 +4357,14 @@ See: https://nuxtseo.com/og-image/getting-started`
   if (createComponent) {
     await createStarterComponent(nuxt);
   }
-  const hasSharp = await dependencies.hasResolvableDependency("sharp");
+  const hasSharp = await 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 dependencies.ensureProviderDependencies("satori", "node", nuxt).catch(() => logger_js.logger.warn("Failed to install sharp, JPEG output unavailable"));
+      await ensureProviderDependencies("satori", "node", nuxt).catch(() => logger_js.logger.warn("Failed to install sharp, JPEG output unavailable"));
     }
   }
   logger_js.logger.info("");
@@ -3935,7 +4399,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 dependencies.promptFontsMigration(nuxt.options.rootDir);
+      await fonts.promptFontsMigration(nuxt.options.rootDir);
     }
   }
   if (issues.length > 0) {
@@ -3952,17 +4416,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 = dependencies.getRendererFromFilename(file);
+      const renderer = getRendererFromFilename(file);
       if (renderer)
         detectedRenderers.add(renderer);
     }
   }
   if (detectedRenderers.size === 0)
     detectedRenderers.add("satori");
-  const preset = dependencies.resolveOgImagePreset();
-  const compatibility = dependencies.getPresetNitroPresetCompatibility(preset);
+  const preset = resolveOgImagePreset();
+  const compatibility = getPresetNitroPresetCompatibility(preset);
   for (const renderer of detectedRenderers) {
-    const validation = await dependencies.validateProviderSetup(renderer, compatibility);
+    const validation = await validateProviderSetup(renderer, compatibility);
     if (!validation.valid) {
       logger_js.logger.warn(`Provider setup issues for ${renderer}:`);
       for (const issue of validation.issues) {
@@ -4021,7 +4485,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 dependencies.getRegisteredBaseNames(component.pascalName)) {
+        for (const baseName of getRegisteredBaseNames(component.pascalName)) {
           const renderers = baseNameRenderers.get(baseName) || [];
           renderers.push(component.renderer);
           baseNameRenderers.set(baseName, renderers);
@@ -4032,7 +4496,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 = dependencies.getRegisteredBaseNames(component.pascalName);
+        const baseNames = getRegisteredBaseNames(component.pascalName);
         lines.push(`    '${strippedName}': ${importType}`);
         const seen = /* @__PURE__ */ new Set([strippedName]);
         for (const baseName of baseNames) {
@@ -4094,6 +4558,15 @@ declare module '#og-image/font-requirements' {
   export const hasNuxtFonts: boolean
 }
 
+declare module '#og-image/island-hash' {
+  export function getIslandHash(input: {
+    name: string
+    props?: Record<string, any> | string | null
+    context?: Record<string, any>
+    source?: string
+  }): string
+}
+
 declare module '#og-image-virtual/unocss-config.mjs' {
   export const theme: Record<string, any>
 }
@@ -4317,7 +4790,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.BCK8Adm4.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.BRBtdkUp.cjs', document.baseURI).href)));
     const fixSharedPath = (p) => {
       return p.replace(/\/shared\/runtime(\/|$)/, "/runtime$1").replace(/\/shared\/client(\/|$)/, "/client$1").replace(/\/shared\/devtools(\/|$)/, "/devtools$1");
     };
@@ -4409,10 +4882,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 = dependencies.resolveOgImagePreset(nuxt.options.nitro);
-    const targetCompatibility = dependencies.getPresetNitroPresetCompatibility(preset);
+    const preset = resolveOgImagePreset(nuxt.options.nitro);
+    const targetCompatibility = getPresetNitroPresetCompatibility(preset);
     const runtimeCompatibilityMeta = {};
-    const normalizedPreset = preset.replace(dependencies.RE_LEGACY_SUFFIX, "");
+    const normalizedPreset = preset.replace(RE_LEGACY_SUFFIX, "");
     const isCloudflareWorkers = ["cloudflare", "cloudflare-module", "cloudflare-durable"].includes(normalizedPreset);
     if (isCloudflareWorkers) {
       nuxt.hooks.hook("nitro:init", (nitro) => {
@@ -4683,7 +5156,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 dependencies.ensureDependencies(["sharp"]);
+          await ensureDependencies(["sharp"]);
           logger_js.logger.warn("Support for `sharp` is limited so check the compatibility guide.");
           attemptSharpUsage = true;
         }
@@ -4697,8 +5170,8 @@ ${familyInfo}`);
       }
     }
     if (isProviderEnabledForEnv("browser", nuxt, config)) {
-      const hasChromeLocally = dependencies.checkLocalChrome();
-      const hasPlaywrightDependency = await dependencies.hasResolvableDependency("playwright");
+      const hasChromeLocally = checkLocalChrome();
+      const hasPlaywrightDependency = await hasResolvableDependency("playwright");
       const browserCompatibilityFlags = {
         prerender: config.compatibility?.prerender?.browser,
         dev: config.compatibility?.dev?.browser,
@@ -4715,7 +5188,7 @@ ${familyInfo}`);
         if (!browserConfig.binding) {
           throw new Error("[nuxt-og-image] `ogImage.browser.binding` is required when provider is cloudflare");
         }
-        const hasCloudfarePuppeteer = await dependencies.hasResolvableDependency("@cloudflare/puppeteer");
+        const hasCloudfarePuppeteer = await hasResolvableDependency("@cloudflare/puppeteer");
         if (!hasCloudfarePuppeteer) {
           throw new Error(
             "[nuxt-og-image] Missing @cloudflare/puppeteer dependency. Install it with: pnpm add @cloudflare/puppeteer"
@@ -4725,12 +5198,12 @@ ${familyInfo}`);
         browserBinding.prerender = hasPlaywrightDependency ? "playwright" : hasChromeLocally ? "chrome-launcher" : "on-demand";
         browserBinding.runtime = "cloudflare";
       } else if (nuxt.options.dev) {
-        if (dependencies.isUndefinedOrTruthy(browserCompatibilityFlags.dev))
+        if (isUndefinedOrTruthy(browserCompatibilityFlags.dev))
           browserBinding.dev = hasChromeLocally ? "chrome-launcher" : hasPlaywrightDependency ? "playwright" : "on-demand";
       } else {
-        if (dependencies.isUndefinedOrTruthy(browserCompatibilityFlags.prerender))
+        if (isUndefinedOrTruthy(browserCompatibilityFlags.prerender))
           browserBinding.prerender = hasChromeLocally ? "chrome-launcher" : hasPlaywrightDependency ? "playwright" : "on-demand";
-        if (dependencies.isUndefinedOrTruthy(browserCompatibilityFlags.runtime))
+        if (isUndefinedOrTruthy(browserCompatibilityFlags.runtime))
           browserBinding.runtime = hasPlaywrightDependency ? "playwright" : null;
       }
       config.compatibility = defu.defu(config.compatibility, {
@@ -4739,7 +5212,7 @@ ${familyInfo}`);
         prerender: { browser: browserBinding.prerender }
       });
     }
-    await kit$1.installNuxtSiteConfig();
+    await kit$2.installNuxtSiteConfig();
     nuxt.options.experimental.componentIslands ||= true;
     if (config.debug || nuxt.options.dev) {
       kit.addServerHandler({
@@ -4852,7 +5325,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 = dependencies.getRendererFromFilename(file);
+          const renderer = getRendererFromFilename(file);
           if (renderer) {
             ogImageComponentCtx.detectedRenderers.add(renderer);
             hasUserComponents = true;
@@ -4861,32 +5334,32 @@ ${familyInfo}`);
       }
     }
     if (!nuxt.options._prepare && !hasUserComponents) {
-      const installedProviders = await dependencies.getInstalledProviders();
+      const installedProviders = await 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 && dependencies.canPromptInteractively()) {
-        const renderer = await dependencies.promptForRendererSelection();
+      } else if (nuxt.options.dev && !nuxt.options._prepare && canPromptInteractively()) {
+        const renderer = await 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 \`${dependencies.TAKUMI_CORE_INSTALL_SPEC}\`, 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 \`${TAKUMI_CORE_PACKAGE}\`, 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 = dependencies.getRecommendedBinding(renderer, targetCompatibility);
-          const missing = await dependencies.getMissingDependencies(renderer, binding);
+          const binding = getRecommendedBinding(renderer, targetCompatibility);
+          const missing = await getMissingDependencies(renderer, binding);
           if (missing.length === 0) {
             availableRenderers.add(renderer);
           } else if (nuxt.options.dev && !nuxt.options._prepare) {
-            const installSpecs = await dependencies.getMissingDependencyInstallSpecs(renderer, binding);
+            const installSpecs = await getMissingDependencyInstallSpecs(renderer, binding);
             logger_js.logger.warn(`${renderer} renderer requires: ${installSpecs.join(", ")}`);
-            const { success } = await dependencies.ensureProviderDependencies(renderer, binding, nuxt);
+            const { success } = await ensureProviderDependencies(renderer, binding, nuxt);
             if (success) {
               availableRenderers.add(renderer);
             } else if (stdEnv.isAgent) {
@@ -4895,10 +5368,10 @@ ${familyInfo}`);
               logger_js.logger.error(`Failed to install ${renderer} dependencies. Templates using this renderer won't work.`);
             }
           } else if (stdEnv.isAgent) {
-            const installSpecs = await dependencies.getMissingDependencyInstallSpecs(renderer, binding);
+            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 {
-            const installSpecs = await dependencies.getMissingDependencyInstallSpecs(renderer, binding);
+            const installSpecs = await 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") {
@@ -4921,7 +5394,7 @@ ${familyInfo}`);
     }
     runtimeCompatibilityMeta.takumiVersion = await detectTakumiVersion(
       resolver,
-      dependencies.getRecommendedBinding("takumi", targetCompatibility)
+      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.");
@@ -4930,8 +5403,8 @@ ${familyInfo}`);
     if (nuxt.options.dev) {
       const communityRenderers = /* @__PURE__ */ new Set();
       for (const renderer of ["satori", "takumi", "browser"]) {
-        const binding = dependencies.getRecommendedBinding(renderer, targetCompatibility);
-        const missing = await dependencies.getMissingDependencies(renderer, binding);
+        const binding = getRecommendedBinding(renderer, targetCompatibility);
+        const missing = await getMissingDependencies(renderer, binding);
         if (missing.length === 0)
           communityRenderers.add(renderer);
       }
@@ -4962,7 +5435,7 @@ ${familyInfo}`);
         if (valid && fs__namespace.existsSync(component.filePath)) {
           if (!component.filePath.endsWith(".vue"))
             return;
-          const renderer = dependencies.getRendererFromFilename(component.filePath);
+          const renderer = getRendererFromFilename(component.filePath);
           if (!renderer) {
             invalidComponents.push(component.filePath);
             return;
@@ -4978,7 +5451,7 @@ ${familyInfo}`);
           const credits = componentFile.split("\n").find((line) => line.startsWith(" * @credits"))?.replace("* @credits", "").trim();
           const propNames = extractPropNamesFromVue(componentFile);
           ogImageComponentCtx.components.push({
-            hash: ohash.hash(componentFile).replaceAll("_", "-"),
+            hash: fnv1a64.fnv1a64Base36(componentFile),
             pascalName: component.pascalName,
             kebabName: component.kebabName,
             path: component.filePath,
@@ -4993,18 +5466,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 = dependencies.getRendererFromFilename(file);
+            const renderer = 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 = dependencies.getRegisteredBaseNames(pascalName);
+            const communityBaseNames = getRegisteredBaseNames(pascalName);
             if (ogImageComponentCtx.components.some((c) => {
               if (c.pascalName === pascalName)
                 return true;
               if (c.renderer !== renderer)
                 return false;
-              const existingBaseNames = dependencies.getRegisteredBaseNames(c.pascalName);
+              const existingBaseNames = getRegisteredBaseNames(c.pascalName);
               return communityBaseNames.some((cb) => existingBaseNames.includes(cb));
             })) {
               return;
@@ -5025,10 +5498,10 @@ ${familyInfo}`);
       if (nuxt.options.dev) {
         for (const renderer of ogImageComponentCtx.detectedRenderers) {
           if (!availableRenderers.has(renderer)) {
-            const binding = dependencies.getRecommendedBinding(renderer, targetCompatibility);
-            dependencies.getMissingDependencies(renderer, binding).then(async (missing) => {
+            const binding = getRecommendedBinding(renderer, targetCompatibility);
+            getMissingDependencies(renderer, binding).then(async (missing) => {
               if (missing.length > 0) {
-                const installSpecs = await dependencies.getMissingDependencyInstallSpecs(renderer, binding);
+                const installSpecs = await getMissingDependencyInstallSpecs(renderer, binding);
                 logger_js.logger.warn(`New ${renderer} component detected but dependencies missing: ${missing.join(", ")}. Install with: npx nypm add ${installSpecs.join(" ")}`);
               }
             });
@@ -5063,6 +5536,22 @@ Run: npx nuxt-og-image migrate v6`;
     nuxt.options.nitro.virtual["#og-image-virtual/component-names.mjs"] = () => {
       return `export const componentNames = ${JSON.stringify(ogImageComponentCtx.components)}`;
     };
+    nuxt.options.nitro.virtual["#og-image/island-hash"] = () => {
+      const islandHashFile = pathe.join(nuxt.options.appDir, "island-hash.js");
+      const [nuxtMajor = 0, nuxtMinor = 0] = kit.getNuxtVersion(nuxt).split(".").map((v) => Number.parseInt(v));
+      if (nuxtMajor > 4 || nuxtMajor === 4 && nuxtMinor >= 5)
+        return `export { getIslandHash } from '${islandHashFile}'`;
+      if (fs.existsSync(islandHashFile)) {
+        return `import { computeIslandHash } from '${islandHashFile}'
+export function getIslandHash({ name, props, context, source }) {
+  return computeIslandHash(name, props ?? {}, context ?? {}, source)
+}`;
+      }
+      return `import { hash } from 'ohash'
+export function getIslandHash({ name, props, context, source }) {
+  return hash([name, props ?? {}, context ?? {}, source]).replace(/[-_]/g, '')
+}`;
+    };
     nuxt.options.nitro.publicAssets ||= [];
     const staticFontsTtfDir = pathe.join(nuxt.options.buildDir, "cache", "og-image", "fonts-ttf");
     nuxt.options.nitro.publicAssets.push({
@@ -5076,7 +5565,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(dependencies.RE_LEGACY_SUFFIX, "");
+      const normalizedPreset2 = preset.replace(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");
@@ -5232,7 +5721,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$2.getNuxtModuleOptions("@nuxtjs/color-mode") : {};
+      const colorModeOptions = hasColorModeModule ? await kit$1.getNuxtModuleOptions("@nuxtjs/color-mode") : {};
       let colorPreference = colorModeOptions.preference;
       if (!colorPreference || colorPreference === "system")
         colorPreference = colorModeOptions.fallback;
@@ -5336,7 +5825,7 @@ export const rootDir = ${JSON.stringify(nuxt.options.rootDir)}`;
           await nitro.hooks.callHook("rollup:reload");
         }
       });
-    } else if (kit$2.isNuxtGenerate()) {
+    } else if (kit$1.isNuxtGenerate()) {
       setupGenerateHandler(config, resolver);
     } else if (nuxt.options.build) {
       await setupBuildHandler(config, resolver, getDetectedRenderers, getCompatibilityMeta);