nuxt-seo-utils 8.6.1 → 9.0.0

package/dist/module.mjs

@@ -1,21 +1,23 @@
 import fs, { existsSync } from 'node:fs';
-import { pathToFileURL } from 'node:url';
-import { useNuxt, addTypeTemplate, useLogger, defineNuxtModule, createResolver, addServerHandler, hasNuxtModule, addPlugin, addImports, hasNuxtCompatibility, directoryToURL, addVitePlugin } from '@nuxt/kit';
+import { readFile, readdir } from 'node:fs/promises';
+import { pathToFileURL, fileURLToPath } from 'node:url';
+import { useNuxt, addTypeTemplate, getLayerDirectories, useLogger, addServerHandler, hasNuxtModule, extendRouteRules, defineNuxtModule, createResolver, addPlugin, addImports, directoryToURL, addVitePlugin } from '@nuxt/kit';
 import { unpackMeta } from '@unhead/vue/utils';
 import { defu } from 'defu';
 import { resolveModulePath } from 'exsolve';
-import { installNuxtSiteConfig, useSiteConfig } from 'nuxt-site-config/kit';
-import { useModuleLogger, setupNitroRuntimeCompatibility, renderNitroTypeAugmentations, resolveHostUnheadMajor } from 'nuxtseo-shared/kit';
-import { resolve, extname, relative, dirname, basename } from 'pathe';
-import { readPackageJSON, resolvePackageJSON } from 'pkg-types';
+import { useSiteConfig } from 'nuxt-site-config/kit';
+import { useModuleLogger, setupNitroRuntimeCompatibility, setupRuntimeAliases, renderNitroTypeAugmentations } from 'nuxtseo-shared/kit';
+import { resolve, extname, relative, dirname, basename, join } from 'pathe';
 import { glob } from 'tinyglobby';
-import { encodePath, joinURL } from 'ufo';
+import { encodePath, joinURL, withoutTrailingSlash } from 'ufo';
 import { c as classifyIconFilename, g as getIconRel, n as normalizeIconSizes, a as partitionColorModeIconLinks } from './shared/nuxt-seo-utils.NAV2YNQn.mjs';
 import escapeRE from 'escape-string-regexp';
-import { readFile, readdir } from 'node:fs/promises';
 import { Buffer } from 'node:buffer';
 import { TWITTER_IMAGE_FALLBACK_KEY } from '../dist/runtime/shared/derivedTagKeys.js';
-import { JSON_TYPES, SKIP_JS_TYPES } from '../dist/runtime/shared/minify.js';
+import { JSON_TYPES } from '../dist/runtime/shared/minify.js';
+import { resolveI18nConfig } from 'nuxtseo-shared/i18n';
+import { isAbsoluteUrl, parseSourcePattern, createRedirectMatcher, resolveTarget, appendSearch, REDIRECT_CACHE_CONTROL } from '../dist/runtime/shared/redirects.js';
+import { createNitroRouteRuleMatcher } from 'nuxtseo-shared/server';
 import { setupDevToolsUI as setupDevToolsUI$1 } from 'nuxtseo-shared/devtools';
 
 function extendNuxtConfigAppHeadSeoMeta(nuxt = useNuxt()) {
@@ -384,7 +386,7 @@ function addGeneratedRouteRule(nuxt, route, generatedRule) {
     nitroRouteRules[route] = defu(nitroRouteRules[route], structuredClone(rule));
 }
 async function generateTagsFromPageDirImages(nuxt = useNuxt()) {
-  const pagesDirs = nuxt.options._layers.map((layer) => resolve(layer.config.srcDir || layer.cwd, layer.config.dir?.pages || "pages")).filter((dir) => fs.existsSync(dir));
+  const pagesDirs = getLayerDirectories(nuxt).map((layer) => layer.appPages).filter((dir) => fs.existsSync(dir));
   const appendRouteRules = {};
   const registeredFiles = /* @__PURE__ */ new Set();
   const devMiddlewareMap = {};
@@ -499,7 +501,7 @@ function enrichConfiguredIcon(link, baseURL, iconEntries, diagnostics) {
   };
 }
 async function generateTagsFromPublicFiles(nuxt = useNuxt()) {
-  const publicDirs = nuxt.options._layers.map((layer) => resolve(layer.config.rootDir, layer.config.dir?.public || "public"));
+  const publicDirs = getLayerDirectories(nuxt).map((layer) => layer.public);
   const seen = /* @__PURE__ */ new Set();
   const fileEntries = [];
   for (const dir of publicDirs) {
@@ -585,6 +587,7 @@ async function generateTagsFromPublicFiles(nuxt = useNuxt()) {
   return { hasIcons, diagnostics };
 }
 
+const JS_TYPES = /* @__PURE__ */ new Set(["", "module", "text/javascript", "application/javascript", "text/ecmascript", "application/ecmascript"]);
 const logger = useLogger("nuxt-seo-utils");
 async function minifyJSBuildTime(code) {
   try {
@@ -633,7 +636,7 @@ function minifyStaticHead() {
         if (typeof script === "string")
           continue;
         const content = String(script.innerHTML || script.textContent || "");
-        if (!content)
+        if (!content || script.src)
           continue;
         const setContent = (val) => {
           if (script.innerHTML)
@@ -650,7 +653,7 @@ function minifyStaticHead() {
           }
           continue;
         }
-        if (script.type && SKIP_JS_TYPES.has(script.type))
+        if (!JS_TYPES.has(script.type?.toLowerCase().trim() ?? ""))
           continue;
         promises.push(minifyJSBuildTime(content).then((minified) => {
           if (minified && minified.length < content.length)
@@ -680,8 +683,6 @@ function minifyStaticHead() {
 }
 
 function resolveUnheadVitePluginSource(input, resolvePath) {
-  if (input.unheadMajor < 3)
-    return { _tag: "unsupported-v2" };
   const path = resolvePath("@unhead/vue/vite", {
     try: true,
     from: [...input.hostImportPaths, ...input.importPaths]
@@ -703,6 +704,394 @@ function setupNuxtConfigAppHeadWithMoreDefaults(nuxt = useNuxt()) {
   nuxt.options.app.head = headConfig;
 }
 
+const DATE_RE = /^\d{4}-\d{2}-\d{2}$/;
+const MAX_HOPS = 10;
+const DAY_MS = 864e5;
+const MISSING_TARGET = "set `to` for a moved URL, or `statusCode: 410` for a gone URL";
+function parseDate(value) {
+  if (typeof value !== "string" || !DATE_RE.test(value))
+    return void 0;
+  const date = /* @__PURE__ */ new Date(`${value}T00:00:00Z`);
+  return Number.isNaN(date.getTime()) || date.toISOString().slice(0, 10) !== value ? void 0 : date;
+}
+function parseEntry(source, input) {
+  const pattern = parseSourcePattern(source);
+  if (typeof pattern === "string")
+    return { issues: [{ _tag: "InvalidSource", level: "error", source, reason: pattern }] };
+  if (!input || typeof input !== "object")
+    return { issues: [{ _tag: "InvalidTarget", level: "error", source, to: input, reason: MISSING_TARGET }] };
+  const issues = [];
+  const addedAt = parseDate(input.addedAt);
+  if (!addedAt)
+    issues.push({ _tag: "InvalidDate", level: "warn", source, field: "addedAt", value: input.addedAt });
+  const reviewedAt = input.reviewedAt === void 0 ? void 0 : parseDate(input.reviewedAt);
+  if (input.reviewedAt !== void 0 && !reviewedAt)
+    issues.push({ _tag: "InvalidDate", level: "warn", source, field: "reviewedAt", value: input.reviewedAt });
+  const reviewFrom = reviewedAt && (!addedAt || reviewedAt > addedAt) ? reviewedAt : addedAt;
+  if (input.to === void 0) {
+    if (input.statusCode !== 410 && input.statusCode !== 404) {
+      issues.push(input.statusCode === void 0 ? { _tag: "InvalidTarget", level: "error", source, to: void 0, reason: MISSING_TARGET } : { _tag: "InvalidStatusCode", level: "error", source, statusCode: input.statusCode });
+      return { issues };
+    }
+    if (pattern._tag === "Prefix" && pattern.prefix === "") {
+      issues.push({ _tag: "InvalidSource", level: "error", source, reason: "a gone URL cannot match every path" });
+      return { issues };
+    }
+    return { entry: { _tag: "Gone", source, pattern, statusCode: input.statusCode, reviewFrom }, issues };
+  }
+  const to = input.to;
+  if (typeof to !== "string" || to.startsWith("//") || !(to.startsWith("/") || isAbsoluteUrl(to))) {
+    issues.push({ _tag: "InvalidTarget", level: "error", source, to, reason: "use a path that starts with `/`, or an absolute `https://` URL" });
+    return { issues };
+  }
+  if (to.includes("*") && !(to.endsWith("/**") && !to.slice(0, -3).includes("*"))) {
+    issues.push({ _tag: "InvalidTarget", level: "error", source, to, reason: "only a trailing `/**` is supported" });
+    return { issues };
+  }
+  if (to.endsWith("/**") && pattern._tag !== "Prefix") {
+    issues.push({ _tag: "InvalidTarget", level: "error", source, to, reason: "a target that ends in `/**` needs a source that ends in `/**`" });
+    return { issues };
+  }
+  const statusCode = input.statusCode ?? 301;
+  if (statusCode !== 301 && statusCode !== 308) {
+    issues.push({ _tag: "InvalidStatusCode", level: "error", source, statusCode });
+    return { issues };
+  }
+  return { entry: { _tag: "Moved", source, pattern, to, statusCode, reviewFrom }, issues };
+}
+function targetPath(to) {
+  return isAbsoluteUrl(to) ? void 0 : to.split(/[?#]/)[0];
+}
+function withSuffix(target, suffix) {
+  const hashIndex = suffix.indexOf("#");
+  const search = hashIndex === -1 ? suffix : suffix.slice(0, hashIndex);
+  const hash = hashIndex === -1 ? "" : suffix.slice(hashIndex);
+  return appendSearch(target, search) + (target.includes("#") ? "" : hash);
+}
+function flattenChains(entries) {
+  const match = createRedirectMatcher(entries);
+  const issues = [];
+  const loops = /* @__PURE__ */ new Set();
+  const resolved = entries.map((entry) => {
+    if (entry._tag !== "Moved")
+      return entry;
+    let to = entry.to;
+    const visited = [entry.source];
+    const hops = [entry.source, entry.to];
+    for (let i = 0; i < MAX_HOPS; i++) {
+      const path = targetPath(to);
+      if (path === void 0)
+        break;
+      const wildcard = to.endsWith("/**");
+      const lookup = wildcard ? path.slice(0, -3) || "/" : path;
+      const next = match(lookup);
+      if (!next || wildcard && next.pattern._tag !== "Prefix")
+        break;
+      if (visited.includes(next.source)) {
+        const key = [...new Set(visited)].sort().join("\n");
+        if (!loops.has(key)) {
+          loops.add(key);
+          issues.push({ _tag: "RedirectLoop", level: "error", sources: [...visited, next.source] });
+        }
+        return entry;
+      }
+      visited.push(next.source);
+      if (next._tag === "Gone") {
+        issues.push({ _tag: "TargetGone", level: "warn", source: entry.source, to, statusCode: next.statusCode });
+        break;
+      }
+      if (wildcard)
+        to = next.to.endsWith("/**") ? `${resolveTarget(next, lookup).replace(/\/$/, "")}/**` : next.to;
+      else
+        to = withSuffix(resolveTarget(next, path), to.slice(path.length));
+      hops.push(to);
+    }
+    if (to === entry.to)
+      return entry;
+    issues.push({ _tag: "ChainFlattened", level: "info", source: entry.source, hops });
+    return { ...entry, to };
+  });
+  return { entries: resolved, issues };
+}
+function findDueForReview(entries, { now, reviewAfterDays }) {
+  if (reviewAfterDays === false)
+    return [];
+  return entries.flatMap((entry) => {
+    if (!entry.reviewFrom)
+      return [];
+    const days = Math.floor((now.getTime() - entry.reviewFrom.getTime()) / DAY_MS);
+    if (days < reviewAfterDays)
+      return [];
+    return [{
+      _tag: "DueForReview",
+      level: "warn",
+      source: entry.source,
+      target: entry._tag === "Moved" ? entry.to : String(entry.statusCode),
+      since: entry.reviewFrom.toISOString().slice(0, 10),
+      days
+    }];
+  });
+}
+function planRedirects(input, options) {
+  const parsed = Object.entries(input || {}).map(([source, value]) => parseEntry(source, value));
+  const flattened = flattenChains(parsed.flatMap((p) => p.entry ? [p.entry] : []));
+  return {
+    entries: flattened.entries,
+    issues: [...parsed.flatMap((p) => p.issues), ...flattened.issues, ...findDueForReview(flattened.entries, options)]
+  };
+}
+function resolveLocalePrefixes(i18n) {
+  if (!i18n.strategy || i18n.strategy === "no_prefix")
+    return [];
+  return i18n.locales.filter((locale) => i18n.strategy !== "prefix_except_default" || locale.code !== i18n.defaultLocale).map((locale) => `/${locale.code}`);
+}
+function withPrefix(prefix, pattern) {
+  return pattern._tag === "Exact" ? { _tag: "Exact", path: pattern.path === "/" ? prefix : `${prefix}${pattern.path}` } : { _tag: "Prefix", prefix: `${prefix}${pattern.prefix}` };
+}
+function sourceKey$2(pattern) {
+  return pattern._tag === "Exact" ? pattern.path : `${pattern.prefix}/**`;
+}
+function expandLocalePrefixes(entries, prefixes) {
+  if (!prefixes.length)
+    return entries;
+  const taken = new Set(entries.map((entry) => sourceKey$2(entry.pattern)));
+  const isPrefixed = (key) => prefixes.some((prefix) => key === prefix || key.startsWith(`${prefix}/`));
+  const expanded = entries.flatMap((entry) => isPrefixed(sourceKey$2(entry.pattern)) ? [] : prefixes.flatMap((prefix) => {
+    const pattern = withPrefix(prefix, entry.pattern);
+    const key = sourceKey$2(pattern);
+    if (taken.has(key))
+      return [];
+    taken.add(key);
+    if (entry._tag === "Gone")
+      return [{ ...entry, pattern }];
+    return [{ ...entry, pattern, to: isAbsoluteUrl(entry.to) ? entry.to : joinURL(prefix, entry.to) }];
+  }));
+  return [...entries, ...expanded];
+}
+function toRedirectRules(entries) {
+  return entries.map((entry) => entry._tag === "Moved" ? { _tag: "Moved", pattern: entry.pattern, to: entry.to, statusCode: entry.statusCode } : { _tag: "Gone", pattern: entry.pattern, statusCode: entry.statusCode });
+}
+function formatRedirectIssue(issue) {
+  switch (issue._tag) {
+    case "InvalidSource":
+      return `\`${issue.source}\` is not a valid source: ${issue.reason}.`;
+    case "InvalidTarget":
+      return `\`${issue.source}\` has an invalid target ${JSON.stringify(issue.to)}: ${issue.reason}.`;
+    case "InvalidStatusCode":
+      return `\`${issue.source}\` has status code ${JSON.stringify(issue.statusCode)}. Use 301 or 308 with \`to\`, and 410 or 404 without it.`;
+    case "RedirectLoop":
+      return `Redirect loop: ${issue.sources.join(" \u2192 ")}. Remove one of these entries.`;
+    case "InvalidDate":
+      return `\`${issue.source}\` has ${issue.field} ${JSON.stringify(issue.value)}. Use a date such as '2026-10-13'. The entry still works, but the review check skips it.`;
+    case "TargetGone":
+      return `\`${issue.source}\` redirects to \`${issue.to}\`, which returns ${issue.statusCode}. Pick a live target, or make \`${issue.source}\` a gone URL.`;
+    case "DueForReview":
+      return `\`${issue.source}\` \u2192 ${issue.target} (since ${issue.since}, ${issue.days} days)`;
+    case "ChainFlattened":
+      return `${issue.hops.join(" \u2192 ")}. \`${issue.source}\` now redirects to \`${issue.hops.at(-1)}\` in one hop.`;
+  }
+}
+function formatRedirectReport(issues, reviewAfterDays) {
+  const lines = (level, exclude) => issues.filter((issue) => issue.level === level && issue._tag !== exclude).map((issue) => `  - ${formatRedirectIssue(issue)}`);
+  const errors = lines("error");
+  const warnings = lines("warn", "DueForReview");
+  const due = issues.filter((issue) => issue._tag === "DueForReview").map((issue) => `  - ${formatRedirectIssue(issue)}`);
+  const flattened = lines("info");
+  const report = {};
+  if (errors.length)
+    report.error = `Invalid \`seo.redirects\` entries:
+${errors.join("\n")}`;
+  const warn = [
+    ...warnings.length ? [`Check these \`seo.redirects\` entries:
+${warnings.join("\n")}`] : [],
+    ...due.length ? [[
+      `${due.length} \`seo.redirects\` ${due.length === 1 ? "entry is" : "entries are"} due for review (older than ${reviewAfterDays} days):`,
+      ...due,
+      "  If an old URL still gets visits or backlinks, keep it and set `reviewedAt` to today.",
+      "  If it gets none, you can delete the entry."
+    ].join("\n")] : []
+  ];
+  if (warn.length)
+    report.warn = warn.join("\n");
+  if (flattened.length)
+    report.info = `Flattened \`seo.redirects\` chains:
+${flattened.join("\n")}`;
+  return report;
+}
+
+const ERROR_PAGE = "/404.html";
+const HOST_NAMES = {
+  Netlify: "Netlify",
+  CloudflarePages: "Cloudflare Pages",
+  Vercel: "Vercel"
+};
+function isRootBase(baseURL) {
+  return (withoutTrailingSlash(baseURL) || "/") === "/";
+}
+function resolveStaticHost(preset, baseURL) {
+  switch (preset) {
+    case "netlify-static":
+      return isRootBase(baseURL) ? { _tag: "Netlify" } : { _tag: "MetaRefresh", reason: "Nitro writes the Netlify `_redirects` file inside `app.baseURL`, and Netlify does not read it there." };
+    case "cloudflare-pages-static":
+      return { _tag: "CloudflarePages" };
+    case "vercel-static":
+      return { _tag: "Vercel" };
+    default:
+      return { _tag: "MetaRefresh", reason: `The \`${preset}\` preset writes no host redirect file.` };
+  }
+}
+function sourceKey$1(rule) {
+  return rule.pattern._tag === "Exact" ? rule.pattern.path : `${rule.pattern.prefix}/**`;
+}
+function withPrefixPaths(rules) {
+  const exact = new Set(rules.flatMap((rule) => rule.pattern._tag === "Exact" ? [rule.pattern.path] : []));
+  const prefixPaths = rules.flatMap((rule) => {
+    if (rule.pattern._tag !== "Prefix")
+      return [];
+    const path = rule.pattern.prefix || "/";
+    if (exact.has(path))
+      return [];
+    exact.add(path);
+    const pattern = { _tag: "Exact", path };
+    return [rule._tag === "Moved" ? { ...rule, pattern, to: resolveTarget(rule, path) } : { ...rule, pattern }];
+  });
+  const prefixLength = (rule) => rule.pattern._tag === "Prefix" ? rule.pattern.prefix.length : Infinity;
+  return [...rules, ...prefixPaths].sort((a, b) => prefixLength(b) - prefixLength(a));
+}
+function toSplat(to) {
+  return to.endsWith("/**") ? `${to.slice(0, -3)}/:splat` : to;
+}
+function trimSlash(path) {
+  return path === "/" ? "" : withoutTrailingSlash(path);
+}
+function escapeRegExp(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function vercelRoute(rule, baseURL) {
+  const path = trimSlash(joinURL(baseURL, rule.pattern._tag === "Exact" ? rule.pattern.path : rule.pattern.prefix || "/"));
+  const src = rule.pattern._tag === "Prefix" ? `^${escapeRegExp(path)}/(.*)$` : path ? `^${escapeRegExp(path)}/?$` : "^/$";
+  if (rule._tag === "Gone")
+    return { src, status: rule.statusCode, dest: joinURL(baseURL, ERROR_PAGE) };
+  const wildcard = rule.to.endsWith("/**");
+  const target = wildcard ? rule.to.slice(0, -3) || "/" : rule.to;
+  const location = isAbsoluteUrl(target) ? target : joinURL(baseURL, target);
+  return {
+    src,
+    status: rule.statusCode,
+    headers: {
+      "Location": wildcard ? `${trimSlash(location)}/$1` : location,
+      "cache-control": REDIRECT_CACHE_CONTROL
+    }
+  };
+}
+function nativeRedirect(to, statusCode) {
+  return { to, statusCode, status: statusCode };
+}
+function planNativeRedirects(rules, host, ctx) {
+  const servesGone = host._tag !== "CloudflarePages" && ctx.errorPage;
+  const served = withPrefixPaths(rules.filter((rule) => rule._tag === "Moved" || servesGone));
+  const gone = rules.filter((rule) => rule._tag === "Gone");
+  const unservedGone = servesGone ? [] : gone.filter((rule) => host._tag !== "CloudflarePages" || rule.statusCode === 410);
+  const unserved = unservedGone.length ? { _tag: host._tag === "CloudflarePages" ? "NoGoneStatus" : "NoErrorPage", sources: unservedGone.map(sourceKey$1) } : void 0;
+  if (host._tag === "Vercel")
+    return { output: { _tag: "VercelRoutes", routes: served.map((rule) => vercelRoute(rule, ctx.baseURL)) }, unserved };
+  const redirects = served.map((rule) => [
+    sourceKey$1(rule),
+    rule._tag === "Moved" ? nativeRedirect(toSplat(rule.to), rule.statusCode) : nativeRedirect(ERROR_PAGE, rule.statusCode)
+  ]);
+  return { output: { _tag: "RouteRules", redirects: redirects.reverse() }, unserved };
+}
+function nativeSourceKeys(rules) {
+  return [...new Set(withPrefixPaths(rules).map(sourceKey$1))];
+}
+function formatUnservedGone(host, unserved) {
+  const name = HOST_NAMES[host._tag];
+  const intro = unserved._tag === "NoGoneStatus" ? `${name} cannot send 410 from \`_redirects\`. These gone URLs return the host 404 page instead:` : `The build has no \`404.html\` page, so ${name} cannot serve these gone URLs. They return the host 404 page:`;
+  return [intro, ...unserved.sources.map((source) => `  - ${source}`)].join("\n");
+}
+function formatMetaRefreshFallback(reason, unserved) {
+  return [
+    `${reason} So this static build cannot send a redirect or 410 status.`,
+    "Each exact moved URL gets an HTML page with an instant meta refresh.",
+    ...unserved.length ? ["These entries need host redirect rules, or they return the host 404 page:", ...unserved.map((source) => `  - ${source}`)] : []
+  ].join("\n");
+}
+
+function sourceKey(rule) {
+  return rule.pattern._tag === "Exact" ? rule.pattern.path : `${rule.pattern.prefix}/**`;
+}
+function setupRedirects(redirects, reviewAfterDays, ctx) {
+  const { nuxt, logger } = ctx;
+  if (!redirects || !Object.keys(redirects).length || nuxt.options._prepare)
+    return;
+  const plan = planRedirects(redirects, { now: ctx.now, reviewAfterDays });
+  const report = formatRedirectReport(plan.issues, reviewAfterDays);
+  if (report.error)
+    throw new Error(`[nuxt-seo-utils] ${report.error}`);
+  if (report.warn)
+    logger.warn(report.warn);
+  if (report.info)
+    logger.info(report.info);
+  if (!plan.entries.length)
+    return;
+  addServerHandler({ middleware: true, handler: ctx.middleware });
+  let rules = toRedirectRules(plan.entries);
+  nuxt.hook("modules:done", async () => {
+    const i18n = ctx.hasI18n ? await resolveI18nConfig(logger) : false;
+    if (i18n && !i18n.differentDomains && !i18n.multiDomainLocales)
+      rules = expandLocalePrefixes(rules, resolveLocalePrefixes(i18n));
+    nuxt.options.runtimeConfig["seo-utils-redirects"] = rules;
+    if (hasNuxtModule("@nuxtjs/sitemap", nuxt)) {
+      for (const rule of rules)
+        extendRouteRules(sourceKey(rule), { sitemap: false });
+    }
+  });
+  nuxt.hook("nitro:init", (nitro) => {
+    const { baseURL, routeRules } = nitro.options;
+    const setPrerender = (keys, prerender) => {
+      for (const key of keys)
+        routeRules[key] = defu(routeRules[key], { prerender });
+    };
+    const blockPrerender = (keys) => setPrerender(
+      (withoutTrailingSlash(baseURL) || "/") === "/" ? keys : keys.flatMap((key) => [key, joinURL(baseURL, key)]),
+      false
+    );
+    if (!nitro.options.static) {
+      blockPrerender(rules.map(sourceKey));
+      return;
+    }
+    const host = resolveStaticHost(nitro.options.preset, baseURL);
+    if (host._tag === "MetaRefresh") {
+      const pages = rules.filter((rule) => rule._tag === "Moved" && rule.pattern._tag === "Exact");
+      const unserved = rules.filter((rule) => !pages.includes(rule)).map(sourceKey);
+      blockPrerender(rules.filter((rule) => rule._tag === "Gone").map(sourceKey));
+      setPrerender(pages.map(sourceKey), true);
+      if (unserved.length)
+        logger.warn(formatMetaRefreshFallback(host.reason, unserved));
+      return;
+    }
+    blockPrerender(nativeSourceKeys(rules));
+    nitro.hooks.hook("prerender:done", () => {
+      const plan2 = planNativeRedirects(rules, host, {
+        baseURL,
+        errorPage: existsSync(join(nitro.options.output.publicDir, "404.html"))
+      });
+      if (plan2.output._tag === "VercelRoutes") {
+        const config = (nitro.options.vercel ||= { config: { version: 3 } }).config ||= { version: 3 };
+        config.routes = [...config.routes || [], ...plan2.output.routes];
+      } else {
+        for (const [key, redirect] of plan2.output.redirects) {
+          const existing = nitro.options.routeRules[key];
+          delete nitro.options.routeRules[key];
+          nitro.options.routeRules[key] = defu(existing, { redirect });
+        }
+      }
+      if (plan2.unserved)
+        logger.warn(formatUnservedGone(host, plan2.unserved));
+    });
+  });
+}
+
 const NUXT_DEFAULT_VIEWPORT = "width=device-width, initial-scale=1";
 const UNDERSCORE_RE = /_/g;
 const HYPHEN_RE = /-/g;
@@ -946,6 +1335,66 @@ function collectUserAppHead(nuxt) {
   return head;
 }
 
+const NOINDEX = /(?:^|,)\s*(?:noindex|none)\s*(?:,|$)/i;
+const NON_PAGE_PATH = /^\/(?:api|_nuxt|_nitro|__nuxt|\.well-known)(?:\/|$)/;
+function isIndexable(robots) {
+  if (robots === false)
+    return false;
+  if (typeof robots === "string")
+    return !NOINDEX.test(robots);
+  if (robots && typeof robots === "object") {
+    if (typeof robots.indexable === "boolean")
+      return robots.indexable;
+    return !robots.noindex && !robots.none && !(robots.rule && NOINDEX.test(robots.rule));
+  }
+  return true;
+}
+function validateRendering(context) {
+  if (context.indexable === false)
+    return [];
+  const routeRules = context.routeRules || {};
+  const match = createNitroRouteRuleMatcher({ nitro: { routeRules } });
+  const candidates = [
+    ...context.ssr === false ? ["/**"] : [],
+    ...Object.keys(routeRules)
+  ];
+  const diagnostics = [];
+  for (const path of new Set(candidates)) {
+    const rule = match(path);
+    const contentType = Object.entries(rule.headers || {}).find(([name]) => name.toLowerCase() === "content-type")?.[1];
+    if (context.ssr !== false && rule.ssr !== false || !isIndexable(rule.robots) || NON_PAGE_PATH.test(path) || rule.redirect || rule.proxy || typeof contentType === "string" && !/^text\/html(?:;|$)/i.test(contentType)) {
+      continue;
+    }
+    if (diagnostics.some((diagnostic) => diagnostic.path === "/**"))
+      continue;
+    diagnostics.push({ _tag: "ClientRendering", level: "warn", path });
+  }
+  return diagnostics;
+}
+function formatRenderingDiagnostic(diagnostic) {
+  const path = JSON.stringify(diagnostic.path);
+  return [
+    `SSR is disabled for indexable pages matching \`${diagnostic.path}\`.`,
+    "Crawlers and agents that skip JavaScript may miss their page content.",
+    "For public pages, enable global SSR and restore SSR on the route:",
+    "```ts [nuxt.config.ts]",
+    "export default defineNuxtConfig({",
+    "  ssr: true,",
+    `  routeRules: { ${path}: { ssr: true } },`,
+    "})",
+    "```",
+    "For private app pages, keep their rendering rule and disable indexing with Nuxt Robots:",
+    "```ts [nuxt.config.ts]",
+    "export default defineNuxtConfig({",
+    "  modules: ['@nuxtjs/robots'],",
+    `  routeRules: { ${path}: { robots: false } },`,
+    "})",
+    "```",
+    "Requires `@nuxtjs/robots`. Install it with `pnpm add @nuxtjs/robots`.",
+    "Merge the chosen example into your existing Nuxt config."
+  ].join("\n");
+}
+
 function setupDevToolsUI(resolve, nuxt = useNuxt()) {
   setupDevToolsUI$1({
     route: "/__nuxt-seo-utils",
@@ -960,7 +1409,7 @@ const module$1 = defineNuxtModule({
     name: "nuxt-seo-utils",
     configKey: "seo",
     compatibility: {
-      nuxt: ">=3.16.0"
+      nuxt: "^4.6.0 || ^5.0.0-0"
     }
   },
   moduleDependencies: {
@@ -972,14 +1421,17 @@ const module$1 = defineNuxtModule({
       version: ">=1",
       optional: true
     },
-    "nuxt-site-config": {
-      version: ">=3.2"
+    // Keep package-relative resolution until the minimum Nuxt version includes this fix:
+    // https://github.com/nuxt/nuxt/pull/36542
+    [fileURLToPath(import.meta.resolve("nuxt-site-config"))]: {
+      version: ">=5.0.0"
     }
   },
   defaults: {
     enabled: true,
     debug: false,
     redirectToCanonicalSiteUrl: false,
+    redirectReviewAfterDays: 365,
     automaticDefaults: true,
     fallbackTitle: true,
     metaDataFiles: true,
@@ -1004,9 +1456,8 @@ const module$1 = defineNuxtModule({
       return;
     }
     const nitroCompatibility = setupNitroRuntimeCompatibility(nuxt);
-    const { resolve } = createResolver(import.meta.url);
-    const { version } = await readPackageJSON(resolve("../package.json"));
-    await installNuxtSiteConfig();
+    const { resolve, resolvePath } = createResolver(import.meta.url);
+    const { version } = JSON.parse(await readFile(resolve("../package.json"), "utf8"));
     const runtimeDir = resolve("./runtime");
     if (config.metaDataFiles) {
       const { hasIcons, diagnostics } = await generateTagsFromPublicFiles();
@@ -1079,7 +1530,7 @@ const module$1 = defineNuxtModule({
     });
     const polyfills = [
       // @ts-expect-error runtime type
-      ...!hasNuxtModule("nuxt-schema-org") || nuxt.options.schemaOrg?.enable === false ? [
+      ...!hasNuxtModule("nuxt-schema-org") || nuxt.options.schemaOrg?.enabled === false ? [
         "useSchemaOrg",
         "defineWebSite",
         "defineWebPage",
@@ -1100,8 +1551,15 @@ const module$1 = defineNuxtModule({
         middleware: true
       });
     }
-    nuxt.options.alias["#seo-utils"] = runtimeDir;
-    const hasSchemaOrg = hasNuxtModule("nuxt-schema-org") && nuxt.options.schemaOrg?.enable !== false;
+    setupRedirects(config.redirects, config.redirectReviewAfterDays ?? 365, {
+      nuxt,
+      logger,
+      middleware: resolve(runtimeDir, "./server/middleware/redirects"),
+      now: /* @__PURE__ */ new Date(),
+      hasI18n
+    });
+    setupRuntimeAliases({ namespace: "#seo-utils", app: resolve(runtimeDir, "./app") }, nuxt);
+    const hasSchemaOrg = hasNuxtModule("nuxt-schema-org") && nuxt.options.schemaOrg?.enabled !== false;
     nuxt.options.alias["#seo-utils-schema"] = hasSchemaOrg ? resolve(runtimeDir, "./app/composables/schemaOrg") : resolve(runtimeDir, "./app/composables/polyfills");
     nuxt.options.runtimeConfig.public["nuxt-seo-utils-version"] = nuxt.options.runtimeConfig.public["nuxt-seo-utils-version"] || version || "";
     nuxt.options.runtimeConfig.public["seo-utils"] = defu(nuxt.options.runtimeConfig.public["seo-utils"] || {}, {
@@ -1176,17 +1634,15 @@ export {}
       { vite: config.treeShakeUseSeoMeta ? { validate: !nuxt.options.test } : false }
     );
     const viteOpts = nuxt.options.unhead.vite;
-    const nuxtRegistersUnheadVite = nuxt.options.future?.compatibilityVersion >= 5 && nuxt.options.builder === "@nuxt/vite-builder" && await hasNuxtCompatibility({ nuxt: ">=4.5.0" });
+    const nuxtRegistersUnheadVite = nuxt.options.future?.compatibilityVersion >= 5 && nuxt.options.builder === "@nuxt/vite-builder";
     if (!nuxtRegistersUnheadVite && viteOpts !== false) {
-      const unheadMajor = await resolveHostUnheadMajor(nuxt.options.rootDir);
       const importPaths = nuxt.options.modulesDir.map((d) => directoryToURL(d));
       const rolldownPath = resolveModulePath("rolldown/experimental", { try: true, from: importPaths });
       const lightningcssPath = resolveModulePath("lightningcss", { try: true, from: importPaths });
       const rolldownURL = rolldownPath ? pathToFileURL(rolldownPath).href : void 0;
       const lightningcssURL = lightningcssPath ? pathToFileURL(lightningcssPath).href : void 0;
-      const hostImportPaths = unheadMajor >= 3 ? [directoryToURL(dirname(await resolvePackageJSON("nuxt", { url: directoryToURL(nuxt.options.rootDir).href })))] : [];
+      const hostImportPaths = [directoryToURL(dirname(resolveModulePath("nuxt/package.json", { from: importPaths })))];
       const vitePluginSource = resolveUnheadVitePluginSource({
-        unheadMajor,
         hostImportPaths,
         importPaths
       }, resolveModulePath);
@@ -1204,9 +1660,7 @@ export {}
           }).code).trim();
         } : void 0
       };
-      if (vitePluginSource._tag === "unsupported-v2") {
-        logger.warn("`treeShakeUseSeoMeta` requires Unhead v3; skipping the transform on Unhead v2.");
-      } else if (vitePluginSource._tag === "missing-vue") {
+      if (vitePluginSource._tag === "missing-vue") {
         logger.warn("`treeShakeUseSeoMeta` requires `@unhead/vue` with the `/vite` export. Install Unhead v3 or disable `treeShakeUseSeoMeta`.");
       } else {
         addVitePlugin(async () => {
@@ -1217,8 +1671,25 @@ export {}
         });
       }
     }
-    if (config.automaticOgAndTwitterTags)
+    if (config.automaticOgAndTwitterTags) {
+      const minifyImports = ["unhead/minify", await resolvePath("unhead/minify")];
+      nuxt.hook("nitro:config", (nitroConfig) => {
+        if (nitroCompatibility._tag === "nitro-v3") {
+          const nitro3Config = nitroConfig;
+          if (nitro3Config.noExternals !== true) {
+            nitro3Config.noExternals = [
+              ...Array.isArray(nitro3Config.noExternals) ? nitro3Config.noExternals : [],
+              ...minifyImports
+            ];
+          }
+        } else {
+          nitroConfig.externals ||= {};
+          nitroConfig.externals.inline ||= [];
+          nitroConfig.externals.inline.push(...minifyImports);
+        }
+      });
       addPlugin({ src: resolve(appRuntimeDir, "plugins", "inferSeoMetaPlugin") });
+    }
     if (config.mergeWithSiteConfig)
       addPlugin({ src: resolve(appRuntimeDir, "plugins", "siteConfig") });
     if (config.extendRouteRules)
@@ -1259,6 +1730,23 @@ export {}
         handler: resolve("./runtime/server/routes/__nuxt-seo-utils/debug")
       });
     }
+    if (!nuxt.options._prepare) {
+      nuxt.hooks.afterEach((event) => {
+        if (event.name !== "nitro:config")
+          return;
+        const [nitroConfig] = event.args;
+        const site = nuxt.options.site;
+        const robots = nuxt.options.robots;
+        const diagnostics = validateRendering({
+          ssr: nuxt.options.ssr,
+          indexable: site?.indexable === false || robots && robots.indexable === false ? false : void 0,
+          routeRules: defu(nitroConfig.routeRules, nuxt.options.routeRules)
+        });
+        if (diagnostics.length)
+          logger.warn(`Rendering configuration issues:
+${diagnostics.map((d) => `  ${formatRenderingDiagnostic(d)}`).join("\n")}`);
+      });
+    }
     if (config.validateAppHead) {
       nuxt.hook("modules:done", () => {
         try {