nuxt-og-image 6.6.0 → 6.7.1

package/dist/shared/nuxt-og-image.LgUGeaz-.mjs

@@ -0,0 +1,660 @@
+import { existsSync } from 'node:fs';
+import { loadFile, writeFile } from 'magicast';
+import { addNuxtModule } from 'magicast/helpers';
+import { join, basename } from 'pathe';
+import { logger } from '../../dist/runtime/logger.js';
+import { detectPackageManager, addDependency } from 'nypm';
+import { isCI, isAgent, hasTTY } from 'std-env';
+import { resolvePath, useNuxt, addTemplate } from '@nuxt/kit';
+import { defu } from 'defu';
+import { resolveNitroPreset } from 'nuxtseo-shared/kit';
+import { Launcher } from 'chrome-launcher';
+
+function parseFontString(font) {
+  const parts = font.split(":");
+  if (parts.length === 3) {
+    return {
+      name: parts[0] || font,
+      style: parts[1] === "ital" ? "italic" : "normal",
+      weight: Number.parseInt(parts[2] || "") || 400
+    };
+  }
+  return {
+    name: parts[0] || font,
+    weight: Number.parseInt(parts[1] || "") || 400,
+    style: "normal"
+  };
+}
+function groupFontsByFamily(fonts) {
+  const families = /* @__PURE__ */ new Map();
+  for (const font of fonts) {
+    const parsed = parseFontString(font);
+    const existing = families.get(parsed.name);
+    if (existing) {
+      existing.weights.add(parsed.weight);
+      existing.styles.add(parsed.style);
+    } else {
+      families.set(parsed.name, {
+        weights: /* @__PURE__ */ new Set([parsed.weight]),
+        styles: /* @__PURE__ */ new Set([parsed.style])
+      });
+    }
+  }
+  return Array.from(families.entries(), ([name, { weights, styles }]) => ({
+    name,
+    weights: [...weights].toSorted((a, b) => a - b),
+    styles: [...styles]
+  }));
+}
+async function migrateFontsConfig(rootDir) {
+  const configPaths = [
+    "nuxt.config.ts",
+    "nuxt.config.js",
+    "nuxt.config.mjs"
+  ];
+  let configPath;
+  for (const p of configPaths) {
+    const fullPath = join(rootDir, p);
+    if (existsSync(fullPath)) {
+      configPath = fullPath;
+      break;
+    }
+  }
+  if (!configPath) {
+    return { migrated: false, message: "No nuxt.config found" };
+  }
+  const mod = await loadFile(configPath);
+  const config = mod.exports.default;
+  if (!config?.ogImage?.fonts) {
+    return { migrated: false, message: "No ogImage.fonts config found" };
+  }
+  const oldFonts = config.ogImage.fonts;
+  if (!Array.isArray(oldFonts) || oldFonts.length === 0) {
+    return { migrated: false, message: "ogImage.fonts is empty or invalid" };
+  }
+  const groupedFonts = groupFontsByFamily(oldFonts);
+  if (!config.fonts) {
+    config.fonts = {};
+  }
+  if (!config.fonts.families) {
+    config.fonts.families = [];
+  }
+  const existingFamilies = config.fonts.families;
+  for (const font of groupedFonts) {
+    const existing = existingFamilies.find((f) => f.name === font.name);
+    if (existing) {
+      const existingWeights = new Set(existing.weights || []);
+      for (const w of font.weights) {
+        existingWeights.add(w);
+      }
+      existing.weights = [...existingWeights].toSorted((a, b) => a - b);
+      if (font.styles.includes("italic")) {
+        const existingStyles = new Set(existing.styles || ["normal"]);
+        existingStyles.add("italic");
+        existing.styles = [...existingStyles];
+      }
+      existing.global = true;
+    } else {
+      const family = {
+        name: font.name,
+        weights: font.weights,
+        global: true
+      };
+      if (font.styles.includes("italic")) {
+        family.styles = font.styles;
+      }
+      existingFamilies.push(family);
+    }
+  }
+  addNuxtModule(mod, "@nuxt/fonts");
+  delete config.ogImage.fonts;
+  if (Object.keys(config.ogImage).length === 0) {
+    delete config.ogImage;
+  }
+  await writeFile(mod, configPath);
+  const familyNames = groupedFonts.map((f) => f.name).join(", ");
+  return {
+    migrated: true,
+    message: `Migrated fonts (${familyNames}) from ogImage.fonts to @nuxt/fonts`
+  };
+}
+async function migrateDefaultsComponent(rootDir) {
+  const configPaths = [
+    "nuxt.config.ts",
+    "nuxt.config.js",
+    "nuxt.config.mjs"
+  ];
+  let configPath;
+  for (const cp of configPaths) {
+    const fullPath = join(rootDir, cp);
+    if (existsSync(fullPath)) {
+      configPath = fullPath;
+      break;
+    }
+  }
+  if (!configPath)
+    return { migrated: false, componentName: null, message: "No nuxt.config found" };
+  const mod = await loadFile(configPath);
+  const config = mod.exports.default;
+  if (!config?.ogImage?.defaults?.component)
+    return { migrated: false, componentName: null, message: "No defaults.component found" };
+  const componentName = String(config.ogImage.defaults.component);
+  delete config.ogImage.defaults.component;
+  if (config.ogImage.defaults && Object.keys(config.ogImage.defaults).length === 0)
+    delete config.ogImage.defaults;
+  if (config.ogImage && Object.keys(config.ogImage).length === 0)
+    delete config.ogImage;
+  await writeFile(mod, configPath);
+  return { migrated: true, componentName, message: `Removed defaults.component: '${componentName}'` };
+}
+async function promptFontsMigration(rootDir) {
+  logger.info("");
+  logger.info("Detected deprecated ogImage.fonts configuration.");
+  logger.info("");
+  logger.info("Inter fonts now work out of the box without any configuration.");
+  logger.info("For custom fonts, use @nuxt/fonts:");
+  logger.info("");
+  logger.info("Before:");
+  logger.info("  ogImage: {");
+  logger.info("    fonts: ['Inter:400', 'Inter:700']");
+  logger.info("  }");
+  logger.info("");
+  logger.info("After (Inter only): Remove the config entirely \u2014 it works by default.");
+  logger.info("");
+  logger.info("After (custom fonts):");
+  logger.info("  modules: ['@nuxt/fonts', 'nuxt-og-image'],");
+  logger.info("  fonts: {");
+  logger.info("    families: [");
+  logger.info("      { name: 'Roboto', weights: [400, 700], global: true }");
+  logger.info("    ]");
+  logger.info("  }");
+  logger.info("");
+  const migrate = await logger.prompt("Automatically migrate nuxt.config?", {
+    type: "confirm",
+    initial: true
+  });
+  if (migrate) {
+    const result = await migrateFontsConfig(rootDir).catch((err) => {
+      logger.error(`Migration failed: ${err.message}`);
+      return { migrated: false, message: err.message };
+    });
+    if (result.migrated) {
+      logger.success(result.message);
+      logger.info("");
+      logger.info("Please install @nuxt/fonts:");
+      logger.info("  npm add @nuxt/fonts");
+    } else {
+      logger.warn(`Could not migrate: ${result.message}`);
+      logger.info("Please migrate manually.");
+    }
+  } else {
+    logger.info("Skipping automatic migration. Please migrate manually.");
+  }
+}
+
+const isUndefinedOrTruthy = (v) => typeof v === "undefined" || v !== false;
+function checkLocalChrome() {
+  if (isCI)
+    return false;
+  let hasChromeLocally = false;
+  try {
+    hasChromeLocally = !!Launcher.getFirstInstallation();
+  } catch {
+  }
+  return hasChromeLocally;
+}
+async function hasResolvableDependency(dep) {
+  return await resolvePath(dep, { fallbackToOriginal: true }).catch(() => null).then((r) => r && r !== dep);
+}
+const VALID_RENDERER_SUFFIXES = ["satori", "browser", "takumi"];
+const RE_RENDERER_SUFFIX_CI = /\.?(satori|browser|takumi)$/i;
+const RE_RENDERER_SUFFIX = /(Satori|Browser|Takumi)$/;
+const RE_LEGACY_SUFFIX = /-legacy$/;
+const RE_WHITESPACE = /\s+/;
+function getRendererFromFilename(filepath) {
+  const filename = basename(filepath).replace(".vue", "");
+  for (const suffix of VALID_RENDERER_SUFFIXES) {
+    if (filename.endsWith(`.${suffix}`))
+      return suffix;
+  }
+  return null;
+}
+const OGIMAGE_PREFIXES = [
+  { prefix: "OgImageCommunity", overlapWord: "Community" },
+  { prefix: "OgImageTemplate", overlapWord: "Template" },
+  { prefix: "OgImage", overlapWord: "Image" }
+];
+function getRegisteredBaseNames(registeredPascalName) {
+  const stripped = registeredPascalName.replace(RE_RENDERER_SUFFIX_CI, "").replace(RE_RENDERER_SUFFIX, "");
+  const names = [];
+  for (const { prefix, overlapWord } of OGIMAGE_PREFIXES) {
+    if (!stripped.startsWith(prefix))
+      continue;
+    const withoutPrefix = stripped.slice(prefix.length);
+    if (withoutPrefix) {
+      names.push(withoutPrefix);
+      if (withoutPrefix !== overlapWord)
+        names.push(overlapWord + withoutPrefix);
+    } else {
+      names.push(overlapWord);
+    }
+    break;
+  }
+  if (names.length === 0)
+    names.push(stripped);
+  return names;
+}
+
+const NodeRuntime = {
+  // node-server runtime
+  browser: "on-demand",
+  // this gets changed build start
+  resvg: "node",
+  satori: "node",
+  takumi: "node",
+  sharp: "node",
+  // will be disabled if they're missing the dependency
+  emoji: "local"
+  // can bundle icons, no size constraints
+};
+const NodeDevRuntime = {
+  ...NodeRuntime,
+  resvg: "node-dev",
+  // use worker to prevent crashes from killing process
+  takumi: "node-dev"
+  // use worker to prevent crashes from killing process
+};
+const NodePrerenderRuntime = {
+  ...NodeRuntime,
+  resvg: "node-dev",
+  // use worker to prevent crashes from killing prerender process
+  takumi: "node-dev"
+  // use worker to prevent crashes from killing prerender process
+};
+const cloudflare = {
+  browser: "cloudflare",
+  resvg: "wasm",
+  satori: "wasm",
+  takumi: "wasm",
+  sharp: false,
+  emoji: "fetch",
+  // edge size limits - use API instead of bundling 24MB icons
+  wasm: {
+    esmImport: true
+    // Do NOT set lazy here — Nitro's cloudflare preset uses lazy: false because
+    // CF Workers require WASM modules to be imported eagerly via top-level await
+  }
+};
+const awsLambda = {
+  browser: false,
+  resvg: "node",
+  satori: "node",
+  takumi: "node",
+  sharp: false,
+  // 0.33.x has issues
+  emoji: "local"
+  // serverless has larger size limits
+};
+const WebContainer = {
+  browser: false,
+  resvg: "wasm-fs",
+  satori: "wasm-fs",
+  takumi: "wasm",
+  sharp: false,
+  emoji: "fetch"
+  // webcontainer has size constraints
+};
+const RuntimeCompatibility = {
+  "nitro-dev": NodeDevRuntime,
+  "nitro-prerender": NodePrerenderRuntime,
+  "node-server": NodeRuntime,
+  "node-cluster": NodeRuntime,
+  "node-listener": NodeRuntime,
+  "bun": NodeRuntime,
+  "deno-server": NodeRuntime,
+  "deno-deploy": NodeRuntime,
+  // node-server extending presets
+  "alwaysdata": NodeRuntime,
+  "cleavr": NodeRuntime,
+  "digital-ocean": NodeRuntime,
+  "edgio": NodeRuntime,
+  "flight-control": NodeRuntime,
+  "heroku": NodeRuntime,
+  "iis-handler": NodeRuntime,
+  "iis-node": NodeRuntime,
+  "koyeb": NodeRuntime,
+  "platform-sh": NodeRuntime,
+  "render-com": NodeRuntime,
+  "zeabur": NodeRuntime,
+  "zerops": NodeRuntime,
+  "stackblitz": WebContainer,
+  "codesandbox": WebContainer,
+  "aws-amplify": awsLambda,
+  "aws-lambda": awsLambda,
+  "azure": awsLambda,
+  "azure-functions": awsLambda,
+  "azure-swa": awsLambda,
+  "netlify": awsLambda,
+  "netlify-edge": {
+    browser: false,
+    resvg: "wasm",
+    satori: "node",
+    takumi: "wasm",
+    sharp: false,
+    emoji: "fetch",
+    // edge size limits
+    wasm: {
+      rollup: {
+        targetEnv: "auto-inline",
+        sync: ["@resvg/resvg-wasm/index_bg.wasm"]
+      }
+    }
+  },
+  "firebase": awsLambda,
+  "firebase-app-hosting": awsLambda,
+  "genezio": awsLambda,
+  "stormkit": awsLambda,
+  "vercel": awsLambda,
+  "vercel-edge": {
+    browser: false,
+    resvg: "wasm",
+    satori: "wasm",
+    takumi: "wasm",
+    sharp: false,
+    emoji: "fetch",
+    // edge size limits - bundling 24MB icons not viable
+    wasm: {
+      // lowers workers kb size
+      esmImport: true,
+      lazy: true
+    }
+  },
+  "cloudflare-pages": cloudflare,
+  "cloudflare-pages-static": cloudflare,
+  "cloudflare": cloudflare,
+  "cloudflare-module": cloudflare,
+  "cloudflare-durable": cloudflare
+};
+function resolveOgImagePreset(nitroConfig) {
+  const nuxt = useNuxt();
+  if (nuxt.options.dev)
+    return "nitro-dev";
+  if (nuxt.options.nitro.static)
+    return "nitro-prerender";
+  return resolveNitroPreset(nitroConfig);
+}
+function getPresetNitroPresetCompatibility(target) {
+  const normalizedTarget = target.replace(RE_LEGACY_SUFFIX, "");
+  let compatibility = RuntimeCompatibility[normalizedTarget];
+  if (!compatibility) {
+    logger.warn(`Unknown Nitro preset "${target}" \u2014 falling back to node-server compatibility. Set ogImage.compatibility.runtime to override.`);
+    compatibility = NodeRuntime;
+  }
+  return compatibility;
+}
+async function applyNitroPresetCompatibility(nitroConfig, options) {
+  const target = resolveOgImagePreset(nitroConfig);
+  const compatibility = getPresetNitroPresetCompatibility(target);
+  const { resolve, detectedRenderers } = options;
+  const satoriEnabled = detectedRenderers.has("satori");
+  const browserEnabled = detectedRenderers.has("browser");
+  const takumiEnabled = detectedRenderers.has("takumi");
+  for (const renderer of detectedRenderers) {
+    if (!compatibility[renderer]) {
+      logger.warn(`Renderer "${renderer}" detected but not supported on "${target}" preset. OG images using .${renderer}.vue components may fail.`);
+    }
+  }
+  const emptyMock = await resolve.resolvePath("./runtime/mock/empty");
+  nitroConfig.alias["#og-image/renderers/satori"] = satoriEnabled ? await resolve.resolvePath("./runtime/server/og-image/satori/renderer") : emptyMock;
+  nitroConfig.alias["#og-image/renderers/browser"] = browserEnabled ? await resolve.resolvePath("./runtime/server/og-image/browser/renderer") : emptyMock;
+  nitroConfig.alias["#og-image/renderers/takumi"] = takumiEnabled ? await resolve.resolvePath("./runtime/server/og-image/takumi/renderer") : emptyMock;
+  const resolvedCompatibility = { ...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(
+    { "#og-image/yoga-wasm": `${yogaWasmPath}?module` },
+    await applyBinding("browser"),
+    await applyBinding("satori"),
+    await applyBinding("takumi"),
+    await applyBinding("resvg"),
+    await applyBinding("sharp"),
+    nitroConfig.alias || {}
+  );
+  if (Object.values(resolvedCompatibility).includes("wasm")) {
+    nitroConfig.experimental = nitroConfig.experimental || {};
+    nitroConfig.experimental.wasm = true;
+  }
+  nitroConfig.rollupConfig = nitroConfig.rollupConfig || {};
+  nitroConfig.wasm = defu(compatibility.wasm, nitroConfig.wasm);
+  nitroConfig.virtual["#og-image/compatibility"] = () => `export default ${JSON.stringify(resolvedCompatibility)}`;
+  addTemplate({
+    filename: "nuxt-og-image/compatibility.mjs",
+    getContents() {
+      return `export default ${JSON.stringify(resolvedCompatibility)}`;
+    },
+    options: { mode: "server" }
+  });
+  return resolvedCompatibility;
+}
+async function ensureDependencies(dep, nuxt = useNuxt()) {
+  const { ensureDependencyInstalled } = await import('nypm');
+  return Promise.all(dep.map((d) => {
+    return ensureDependencyInstalled(d, {
+      cwd: nuxt.options.rootDir,
+      dev: true
+    });
+  }));
+}
+
+const TAKUMI_INSTALL_TAG = "rc";
+const TAKUMI_CORE_PACKAGE = "@takumi-rs/core";
+const TAKUMI_WASM_PACKAGE = "@takumi-rs/wasm";
+const TAKUMI_CORE_INSTALL_SPEC = `${TAKUMI_CORE_PACKAGE}@${TAKUMI_INSTALL_TAG}`;
+const TAKUMI_WASM_INSTALL_SPEC = `${TAKUMI_WASM_PACKAGE}@${TAKUMI_INSTALL_TAG}`;
+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, installSpec: TAKUMI_CORE_INSTALL_SPEC, description: "Native Takumi renderer" }
+      ],
+      "wasm": [
+        { name: TAKUMI_WASM_PACKAGE, installSpec: TAKUMI_WASM_INSTALL_SPEC, description: "WASM Takumi renderer" }
+      ],
+      "wasm-fs": [
+        { name: TAKUMI_WASM_PACKAGE, installSpec: TAKUMI_WASM_INSTALL_SPEC, 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 detectPackageManager(nuxt.options.rootDir);
+  const pmName = pm?.name || "npm";
+  logger.info(`Installing ${provider} dependencies: ${missingInstallSpecs.join(", ")}`);
+  const installed = [];
+  for (const dep of missingDeps) {
+    const installSpec = getDependencyInstallSpec(dep);
+    const success = await addDependency(installSpec, {
+      cwd: nuxt.options.rootDir,
+      dev: false
+    }).then(() => {
+      installed.push(installSpec);
+      return true;
+    }).catch(() => {
+      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,
+  hasStdinTTY: Boolean(process.stdin?.isTTY),
+  isAgent,
+  isCI
+}) {
+  return env.hasTTY && env.hasStdinTTY && !env.isAgent && !env.isCI;
+}
+async function promptForRendererSelection() {
+  logger.info("Welcome to Nuxt OG Image! No renderer dependencies detected.");
+  const renderer = await logger.prompt("Which renderer would you like to use?", {
+    type: "select",
+    options: PROVIDER_DEPENDENCIES.map((p) => p.name),
+    initial: "takumi"
+  });
+  return renderer || "takumi";
+}
+async function validateProviderSetup(renderer, compatibility) {
+  const issues = [];
+  const binding = getRecommendedBinding(renderer, compatibility);
+  const missing = await 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 };
+}
+
+export { PROVIDER_DEPENDENCIES as P, RE_LEGACY_SUFFIX as R, TAKUMI_CORE_INSTALL_SPEC as T, migrateFontsConfig as a, TAKUMI_WASM_INSTALL_SPEC as b, applyNitroPresetCompatibility as c, getRecommendedBinding as d, getMissingDependencies as e, RE_RENDERER_SUFFIX as f, getPresetNitroPresetCompatibility as g, RE_WHITESPACE as h, getRendererFromFilename as i, getInstalledProviders as j, canPromptInteractively as k, getRecommendedBindingFromPreset as l, migrateDefaultsComponent as m, getMissingDependencyInstallSpecs as n, ensureProviderDependencies as o, promptFontsMigration as p, getProviderDependencyInstallSpecs as q, resolveOgImagePreset as r, hasResolvableDependency as s, getRegisteredBaseNames as t, ensureDependencies as u, validateProviderSetup as v, checkLocalChrome as w, promptForRendererSelection as x, isUndefinedOrTruthy as y };