@duffcloudservices/cms 0.12.0 → 0.13.0

package/dist/{chunk-F3EIWEZD.js → chunk-HVSF23P7.js}

@@ -1,5 +1,5 @@
-import fs2 from 'fs';
-import path from 'path';
+import fs3 from 'fs';
+import path3 from 'path';
 import yaml from 'js-yaml';
 
 // src/seo/schemaGraph.ts
@@ -438,8 +438,8 @@ function resolvePageSeo(pageSlug, pagePath, seoConfig, fallbackTitle) {
   const page = seoConfig?.pages?.[pageSlug] ?? {};
   let canonical = page.canonical || "";
   if (!canonical && global.siteUrl) {
-    const path3 = pagePath ?? (pageSlug === "home" ? "/" : `/${pageSlug}`);
-    canonical = `${global.siteUrl.replace(/\/$/, "")}${path3}`;
+    const path4 = pagePath ?? (pageSlug === "home" ? "/" : `/${pageSlug}`);
+    canonical = `${global.siteUrl.replace(/\/$/, "")}${path4}`;
   }
   const pageSpecificTitle = page.title || fallbackTitle;
   let title;
@@ -621,65 +621,6 @@ function spliceHeadHtml(html, tags) {
 ${indent}</head>`;
   });
 }
-function loadPagesManifest(projectRoot, relativePagesPath, debug = false) {
-  const possiblePaths = [
-    path.resolve(projectRoot, relativePagesPath),
-    path.resolve(projectRoot, "..", relativePagesPath),
-    path.resolve(process.cwd(), relativePagesPath)
-  ];
-  let foundPath;
-  for (const testPath of possiblePaths) {
-    if (fs2.existsSync(testPath)) {
-      foundPath = testPath;
-      break;
-    }
-  }
-  if (!foundPath) {
-    if (debug) {
-      console.warn("[dcs-seo] No pages.yaml found at:");
-      possiblePaths.forEach((p) => console.warn(`  - ${p}`));
-    }
-    return null;
-  }
-  let raw;
-  try {
-    raw = yaml.load(fs2.readFileSync(foundPath, "utf8"));
-  } catch (error) {
-    console.warn(`[dcs-seo] Failed to parse ${foundPath}:`, error);
-    return null;
-  }
-  const entries = parsePagesManifest(raw);
-  if (!entries) {
-    console.warn(`[dcs-seo] pages.yaml at ${foundPath} has no usable page entries`);
-    return null;
-  }
-  if (debug) {
-    console.log(`[dcs-seo] Loaded ${entries.length} routes from ${foundPath}`);
-  }
-  return entries;
-}
-function parsePagesManifest(raw) {
-  if (!raw || typeof raw !== "object") return null;
-  const pages = raw.pages;
-  if (!Array.isArray(pages)) return null;
-  const routes = [];
-  for (const entry of pages) {
-    if (!entry || typeof entry !== "object") continue;
-    const p = entry.path;
-    if (typeof p !== "string" || p.length === 0) continue;
-    const slug = entry.slug;
-    const title = entry.title;
-    const lastmodRaw = entry.lastmod ?? entry.lastUpdated ?? entry.dateModified;
-    const lastmod = typeof lastmodRaw === "string" && lastmodRaw.length > 0 ? lastmodRaw : void 0;
-    routes.push({
-      slug: typeof slug === "string" ? slug : "",
-      path: p,
-      ...typeof title === "string" && title.length > 0 ? { title } : {},
-      ...lastmod ? { lastmod } : {}
-    });
-  }
-  return routes.length > 0 ? routes : null;
-}
 
 // src/seo/sitemap.ts
 var XML_HEADER = '<?xml version="1.0" encoding="UTF-8"?>';
@@ -864,10 +805,430 @@ function buildLlmsTxt(params) {
   }
   return out.join("\n") + "\n";
 }
+function loadPagesManifest(projectRoot, relativePagesPath, debug = false) {
+  const possiblePaths = [
+    path3.resolve(projectRoot, relativePagesPath),
+    path3.resolve(projectRoot, "..", relativePagesPath),
+    path3.resolve(process.cwd(), relativePagesPath)
+  ];
+  let foundPath;
+  for (const testPath of possiblePaths) {
+    if (fs3.existsSync(testPath)) {
+      foundPath = testPath;
+      break;
+    }
+  }
+  if (!foundPath) {
+    if (debug) {
+      console.warn("[dcs-seo] No pages.yaml found at:");
+      possiblePaths.forEach((p) => console.warn(`  - ${p}`));
+    }
+    return null;
+  }
+  let raw;
+  try {
+    raw = yaml.load(fs3.readFileSync(foundPath, "utf8"));
+  } catch (error) {
+    console.warn(`[dcs-seo] Failed to parse ${foundPath}:`, error);
+    return null;
+  }
+  const entries = parsePagesManifest(raw);
+  if (!entries) {
+    console.warn(`[dcs-seo] pages.yaml at ${foundPath} has no usable page entries`);
+    return null;
+  }
+  if (debug) {
+    console.log(`[dcs-seo] Loaded ${entries.length} routes from ${foundPath}`);
+  }
+  return entries;
+}
+function parsePagesManifest(raw) {
+  if (!raw || typeof raw !== "object") return null;
+  const pages = raw.pages;
+  if (!Array.isArray(pages)) return null;
+  const routes = [];
+  for (const entry of pages) {
+    if (!entry || typeof entry !== "object") continue;
+    const p = entry.path;
+    if (typeof p !== "string" || p.length === 0) continue;
+    const slug = entry.slug;
+    const title = entry.title;
+    const lastmodRaw = entry.lastmod ?? entry.lastUpdated ?? entry.dateModified;
+    const lastmod = typeof lastmodRaw === "string" && lastmodRaw.length > 0 ? lastmodRaw : void 0;
+    routes.push({
+      slug: typeof slug === "string" ? slug : "",
+      path: p,
+      ...typeof title === "string" && title.length > 0 ? { title } : {},
+      ...lastmod ? { lastmod } : {}
+    });
+  }
+  return routes.length > 0 ? routes : null;
+}
+function routeExclusionReason(route, rules) {
+  const exclude = rules.exclude ?? [];
+  if (exclude.includes(route.path)) return "excluded";
+  if (route.slug && exclude.includes(route.slug)) return "excluded";
+  if (matchesExcludedGlob(route.path, [...rules.excludedGlobs ?? []])) return "excluded-glob";
+  return null;
+}
+function isRouteEmitted(route, rules) {
+  return routeExclusionReason(route, rules) === null;
+}
+
+// src/seo/installSeoHead.ts
+var SEO_HEAD_ROUTE_HAS_NO_META = true;
+function readInjectedSeo() {
+  try {
+    if (typeof __DCS_SEO__ !== "undefined" && __DCS_SEO__ !== null) return __DCS_SEO__;
+  } catch {
+  }
+  return void 0;
+}
+function readInjectedPages() {
+  try {
+    if (typeof __DCS_PAGES__ !== "undefined" && __DCS_PAGES__ !== null) return __DCS_PAGES__;
+  } catch {
+  }
+  return void 0;
+}
+function normalizeSeoHeadPath(input) {
+  if (typeof input !== "string") return "/";
+  let p = input;
+  const hash = p.indexOf("#");
+  if (hash !== -1) p = p.slice(0, hash);
+  const query = p.indexOf("?");
+  if (query !== -1) p = p.slice(0, query);
+  p = p.replace(/\/+$/, "");
+  return p === "" ? "/" : p;
+}
+function findDuplicateNormalizedPaths(routes) {
+  const groups = /* @__PURE__ */ new Map();
+  for (const route of routes) {
+    if (!route || typeof route.path !== "string" || route.path === "") continue;
+    const key = normalizeSeoHeadPath(route.path);
+    const bucket = groups.get(key);
+    if (bucket) bucket.push(route);
+    else groups.set(key, [route]);
+  }
+  const dupes = [];
+  for (const [normalizedPath, group] of groups) {
+    if (group.length > 1) dupes.push({ normalizedPath, routes: group });
+  }
+  return dupes;
+}
+function formatDuplicateNormalizedPaths(dupes) {
+  const lines = dupes.map(
+    (d) => `  ${d.normalizedPath} <= ` + d.routes.map((r) => `${JSON.stringify(r.path)} (slug ${JSON.stringify(r.slug)})`).join(", ")
+  );
+  return `pages.yaml declares ${dupes.length} route path(s) that collide after trailing-slash normalization:
+${lines.join("\n")}
+The build-time emitter's LAST write wins the output file while the runtime lookup's FIRST entry wins the head \u2014 so a colliding manifest guarantees a baked/runtime divergence whichever side is preferred. There is no safe default: the entries carry different slugs and therefore different .dcs/seo.yaml identities. Delete or rename one.`;
+}
+function buildSeoHeadRouteMap(routes) {
+  const map = /* @__PURE__ */ new Map();
+  for (const route of routes) {
+    if (!route || typeof route.path !== "string" || route.path === "") continue;
+    const key = normalizeSeoHeadPath(route.path);
+    if (!map.has(key)) map.set(key, route);
+  }
+  return map;
+}
+function isStartLocation(from) {
+  if (!from || typeof from !== "object") return false;
+  if (from.name !== void 0 && from.name !== null) return false;
+  if (!Array.isArray(from.matched) || from.matched.length > 0) return false;
+  return normalizeSeoHeadPath(typeof from.path === "string" ? from.path : "") === "/";
+}
+function installSeoHead(router, options) {
+  const head = options.head;
+  const manifest = readInjectedPages();
+  const routes = options.pages ?? manifest?.routes;
+  const seo = options.seo ?? readInjectedSeo();
+  const noindex = options.noindex ?? manifest?.noindex ?? [];
+  const onResolve = options.onResolve;
+  const noindexSet = new Set(noindex);
+  const routeMap = routes && routes.length > 0 ? buildSeoHeadRouteMap(routes) : null;
+  if (routes && routes.length > 0) {
+    const dupes = findDuplicateNormalizedPaths(routes);
+    if (dupes.length > 0) {
+      console.error(`[dcs-seo] installSeoHead: ${formatDuplicateNormalizedPaths(dupes)}`);
+    }
+  }
+  let entry = null;
+  let initialNavigationPending = true;
+  return router.afterEach((to, from, failure) => {
+    const path4 = to && typeof to.path === "string" ? to.path : "";
+    const normalizedPath = normalizeSeoHeadPath(path4);
+    if (failure) {
+      onResolve?.({ path: path4, normalizedPath, matched: null, reason: "navigation-failed", title: null });
+      return;
+    }
+    if (initialNavigationPending) {
+      const initial = isStartLocation(from);
+      initialNavigationPending = false;
+      if (initial) {
+        onResolve?.({
+          path: path4,
+          normalizedPath,
+          matched: null,
+          reason: "initial-navigation",
+          title: null
+        });
+        return;
+      }
+    }
+    if (!routeMap) {
+      onResolve?.({ path: path4, normalizedPath, matched: null, reason: "no-manifest", title: null });
+      return;
+    }
+    const matched = routeMap.get(normalizedPath);
+    if (!matched) {
+      onResolve?.({ path: path4, normalizedPath, matched: null, reason: "no-match", title: null });
+      return;
+    }
+    const forceNoindex = noindexSet.has(matched.path) || !!matched.slug && noindexSet.has(matched.slug);
+    const tags = buildHeadTags(matched.slug, matched.path, seo, {
+      // MUST MATCH `dcsSeoPlugin`'s emitter call. `includeKeywords` defaults to
+      // false to keep the legacy `useSEO` runtime byte-identical to its history;
+      // the emitter opts in, so a re-assert that did not would leave the
+      // PREVIOUS post's baked `<meta name="keywords">` in the DOM while title,
+      // description and canonical all moved (C-361 F4, verified at
+      // dcsSeoPlugin.ts). This is a new API — the old composable's omission is
+      // not a compatibility constraint on it.
+      includeKeywords: true,
+      fallbackTitle: matched.title,
+      robots: forceNoindex ? "noindex, nofollow" : void 0
+    });
+    const input = { title: tags.title, meta: tags.meta, link: tags.link };
+    if (entry) entry.patch(input);
+    else entry = head.push(input);
+    onResolve?.({ path: path4, normalizedPath, matched, reason: "applied", title: tags.title });
+  });
+}
+
+// src/seo/headHonesty.ts
+var NAMED_ENTITIES = {
+  amp: "&",
+  lt: "<",
+  gt: ">",
+  quot: '"',
+  apos: "'",
+  nbsp: "\xA0",
+  mdash: "\u2014",
+  ndash: "\u2013",
+  hellip: "\u2026",
+  copy: "\xA9",
+  reg: "\xAE",
+  trade: "\u2122",
+  rsquo: "\u2019",
+  lsquo: "\u2018",
+  ldquo: "\u201C",
+  rdquo: "\u201D"
+};
+function decodeHtmlEntities(value) {
+  return value.replace(/&(#x?[0-9a-fA-F]+|[a-zA-Z][a-zA-Z0-9]*);/g, (whole, body) => {
+    if (body[0] === "#") {
+      const isHex = body[1] === "x" || body[1] === "X";
+      const code = Number.parseInt(isHex ? body.slice(2) : body.slice(1), isHex ? 16 : 10);
+      if (!Number.isFinite(code) || code < 0 || code > 1114111) return whole;
+      try {
+        return String.fromCodePoint(code);
+      } catch {
+        return whole;
+      }
+    }
+    const named = NAMED_ENTITIES[body.toLowerCase()];
+    return named ?? whole;
+  });
+}
+function normalizeHeadText(value) {
+  if (value === null || value === void 0) return null;
+  const decoded = decodeHtmlEntities(value);
+  const collapsed = decoded.replace(/\s+/g, " ").trim();
+  return collapsed.normalize("NFC");
+}
+function readTagAttr(tag, attr) {
+  const re = new RegExp(`\\b${attr}\\s*=\\s*(?:"([^"]*)"|'([^']*)'|([^\\s"'=<>\`]+))`, "i");
+  const m = re.exec(tag);
+  if (!m) return null;
+  return m[1] ?? m[2] ?? m[3] ?? "";
+}
+function extractBakedHead(html) {
+  const titleMatch = /<title[^>]*>([\s\S]*?)<\/title>/i.exec(html);
+  const title = titleMatch ? titleMatch[1] : null;
+  let description = null;
+  const metaRe = /<meta\b[^>]*>/gi;
+  let m;
+  while ((m = metaRe.exec(html)) !== null) {
+    const tag = m[0];
+    const name = readTagAttr(tag, "name");
+    if (name?.toLowerCase() !== "description") continue;
+    description = readTagAttr(tag, "content") ?? "";
+  }
+  return { title, description };
+}
+function findHeadHonestyViolations(observations, options = {}) {
+  const { checkDescription = true, allow = [] } = options;
+  const allowed = new Set(allow);
+  const violations = [];
+  for (const obs of observations) {
+    if (allowed.has(obs.route)) continue;
+    const bakedTitle = normalizeHeadText(obs.bakedTitle);
+    const runtimeTitle = normalizeHeadText(obs.runtimeTitle);
+    if (!(bakedTitle === null && runtimeTitle === null) && bakedTitle !== runtimeTitle) {
+      violations.push({ route: obs.route, field: "title", baked: bakedTitle, runtime: runtimeTitle });
+    }
+    if (!checkDescription) continue;
+    const bakedDescription = normalizeHeadText(obs.bakedDescription);
+    const runtimeDescription = normalizeHeadText(obs.runtimeDescription);
+    if (!(bakedDescription === null && runtimeDescription === null) && bakedDescription !== runtimeDescription) {
+      violations.push({
+        route: obs.route,
+        field: "description",
+        baked: bakedDescription,
+        runtime: runtimeDescription
+      });
+    }
+  }
+  return violations;
+}
+function display(value) {
+  return value === null ? "(absent)" : JSON.stringify(value);
+}
+function formatHeadHonestyReport(violations) {
+  const routes = new Set(violations.map((v) => v.route));
+  const lines = [
+    `[dcs-seo] head honesty: ${violations.length} divergence(s) across ${routes.size} route(s) \u2014 the BAKED <head> (what a non-JS AI crawler receives) does not match the RENDERED <head> (what Google and every human sees).`
+  ];
+  for (const v of violations) {
+    lines.push(`  ${v.route}  [${v.field}]`);
+    lines.push(`      baked   : ${display(v.baked)}`);
+    lines.push(`      rendered: ${display(v.runtime)}`);
+  }
+  lines.push(
+    `  Fix: delete the hardcoded title/description from the route's applyHead({\u2026}) call so .dcs/seo.yaml is the only writer. (applyHead's \`title\` override is used VERBATIM \u2014 it does NOT go through global.titleTemplate, which is why an override that "looks right" still diverges.)`
+  );
+  return lines.join("\n");
+}
+var HeadHonestyError = class extends Error {
+  violations;
+  constructor(violations) {
+    super(formatHeadHonestyReport(violations));
+    this.name = "HeadHonestyError";
+    this.violations = violations;
+  }
+};
+function coerceMode(value) {
+  if (value === void 0 || value === null) return void 0;
+  if (value === true) return "error";
+  if (value === false) return "off";
+  const normalized = String(value).trim().toLowerCase();
+  if (normalized === "error" || normalized === "fail" || normalized === "strict") return "error";
+  if (normalized === "warn" || normalized === "warning" || normalized === "report") return "warn";
+  if (normalized === "off" || normalized === "false" || normalized === "none") return "off";
+  return void 0;
+}
+function resolveHonestyMode(input) {
+  return coerceMode(input.env) ?? coerceMode(input.seoYaml) ?? coerceMode(input.option) ?? input.fallback ?? "error";
+}
+function findHeadHonestyExecutionFaults(ex) {
+  const faults = [];
+  if (!ex.rendererAvailable) {
+    faults.push(
+      "no headless renderer was available (playwright missing, or Chromium failed to launch), so NOT ONE route's rendered <head> was observed"
+    );
+  }
+  if (ex.eligibleRoutes.length === 0) {
+    const byReason = /* @__PURE__ */ new Map();
+    for (const f of ex.filteredRoutes) {
+      byReason.set(f.reason, [...byReason.get(f.reason) ?? [], f.route]);
+    }
+    const detail = [...byReason.entries()].map(([reason, routes]) => `${reason}: ${routes.join(", ")}`).join("; ") || "the route manifest was empty";
+    faults.push(
+      `0 of ${ex.totalRoutes} route(s) were eligible for observation (${detail}), so the baked-vs-rendered comparison had nothing to compare`
+    );
+  } else {
+    const observed = new Set(ex.observedRoutes);
+    const unobserved = ex.eligibleRoutes.filter((r) => !observed.has(r));
+    if (unobserved.length > 0) {
+      faults.push(
+        `${ex.observedRoutes.length} of ${ex.eligibleRoutes.length} eligible route(s) produced an observation; these were NOT checked: ${unobserved.join(", ")}`
+      );
+    }
+  }
+  return faults;
+}
+function formatHeadHonestyExecutionReport(ex, faults) {
+  const lines = [
+    "[dcs-seo] head honesty DID NOT RUN \u2014 the baked/rendered <head> divergence class was NOT checked for this build:"
+  ];
+  for (const f of faults) lines.push(`  - ${f}`);
+  lines.push(
+    `  observed ${ex.observedRoutes.length} / eligible ${ex.eligibleRoutes.length} / manifest ${ex.totalRoutes} route(s); renderer ${ex.rendererAvailable ? "available" : "ABSENT"}`
+  );
+  lines.push(
+    "  Fix: install the renderer (`pnpm add -D playwright && npx playwright install chromium`) BEFORE the build step, or lower this rail deliberately and visibly (DCS_SEO_HEAD_HONESTY=warn / .dcs/seo.yaml headHonesty.mode). A rail that silently does not run is the exact class this work exists to close."
+  );
+  return lines.join("\n");
+}
+var HeadHonestyNotRunError = class extends Error {
+  execution;
+  faults;
+  constructor(execution, faults) {
+    super(formatHeadHonestyExecutionReport(execution, faults));
+    this.name = "HeadHonestyNotRunError";
+    this.execution = execution;
+    this.faults = faults;
+  }
+};
+function assertHeadHonestyExecuted(execution, options) {
+  if (options.mode === "off") return false;
+  const faults = findHeadHonestyExecutionFaults(execution);
+  if (faults.length === 0) return true;
+  const report = formatHeadHonestyExecutionReport(execution, faults);
+  if (options.mode === "warn") {
+    console.warn(report);
+    console.warn(
+      "[dcs-seo] head honesty is in WARN mode; this build is NOT gated on the above (in error mode it would be RED)."
+    );
+    return execution.observedRoutes.length > 0;
+  }
+  throw new HeadHonestyNotRunError(execution, faults);
+}
+function assertHeadHonesty(observations, options) {
+  const { mode, allow = [], debug = false } = options;
+  if (mode === "off") {
+    console.warn(
+      "[dcs-seo] head honesty is OFF for this build \u2014 the baked/rendered <title> divergence class is NOT being checked."
+    );
+    return [];
+  }
+  if (allow.length > 0) {
+    console.warn(
+      `[dcs-seo] head honesty: ${allow.length} route(s) EXEMPTED from the baked==rendered assert: ${allow.join(", ")}`
+    );
+  }
+  const violations = findHeadHonestyViolations(observations, options);
+  if (violations.length === 0) {
+    console.log(
+      `[dcs-seo] head honesty: ${observations.length} route(s) verified \u2014 baked <head> == rendered <head>`
+    );
+    return violations;
+  }
+  if (mode === "warn") {
+    console.warn(formatHeadHonestyReport(violations));
+    console.warn(
+      "[dcs-seo] head honesty is in WARN mode; this build is NOT gated on the divergence above."
+    );
+    return violations;
+  }
+  if (debug) console.error(formatHeadHonestyReport(violations));
+  throw new HeadHonestyError(violations);
+}
 function routeToOutputFile(outDir, routePath) {
   const trimmed = routePath.replace(/^\/+/, "").replace(/\/+$/, "");
-  if (trimmed === "") return path.join(outDir, "index.html");
-  return path.join(outDir, ...trimmed.split("/"), "index.html");
+  if (trimmed === "") return path3.join(outDir, "index.html");
+  return path3.join(outDir, ...trimmed.split("/"), "index.html");
 }
 var BodyPrerenderError = class extends Error {
   route;
@@ -913,6 +1274,7 @@ async function prerenderBodies(params) {
     exclude = [],
     noindex = [],
     excludedGlobs = [],
+    spliceBody = true,
     debug = false
   } = params;
   const excludeSet = new Set(exclude);
@@ -920,55 +1282,79 @@ async function prerenderBodies(params) {
   let prerendered = 0;
   let skipped = 0;
   const done = [];
+  const headObservations = [];
+  const eligibleRoutes = [];
+  const filteredRoutes = [];
   for (const route of routes) {
     if (excludeSet.has(route.path) || route.slug && excludeSet.has(route.slug)) {
       skipped += 1;
+      filteredRoutes.push({ route: route.path, reason: "excluded" });
       if (debug) console.log(`[dcs-seo] body-prerender skip (excluded): ${route.path}`);
       continue;
     }
     if (matchesExcludedGlob(route.path, excludedGlobs)) {
       skipped += 1;
+      filteredRoutes.push({ route: route.path, reason: "excluded-glob" });
       if (debug) console.log(`[dcs-seo] body-prerender skip (excluded glob): ${route.path}`);
       continue;
     }
     if (noindexSet.has(route.path) || route.slug && noindexSet.has(route.slug)) {
       skipped += 1;
+      filteredRoutes.push({ route: route.path, reason: "noindex" });
       if (debug) console.log(`[dcs-seo] body-prerender skip (noindex/auth): ${route.path}`);
       continue;
     }
     const outFile = routeToOutputFile(outDir, route.path);
-    if (!fs2.existsSync(outFile)) {
+    if (!fs3.existsSync(outFile)) {
       skipped += 1;
+      filteredRoutes.push({ route: route.path, reason: "no-head-file" });
       if (debug) console.log(`[dcs-seo] body-prerender skip (no head file): ${route.path}`);
       continue;
     }
+    eligibleRoutes.push(route.path);
     const rendered = await renderer.renderRoute(route.path);
     if (rendered.errors.length > 0) {
       throw new BodyPrerenderError(route.path, rendered.errors);
     }
+    const html = fs3.readFileSync(outFile, "utf8");
+    if (rendered.head) {
+      const baked = extractBakedHead(html);
+      headObservations.push({
+        route: route.path,
+        bakedTitle: baked.title,
+        runtimeTitle: rendered.head.title,
+        bakedDescription: baked.description,
+        runtimeDescription: rendered.head.description,
+        runtimeDescriptionCount: rendered.head.descriptionCount
+      });
+    }
     const body = (rendered.bodyHtml ?? "").trim();
     if (body === "") {
       skipped += 1;
       if (debug) console.log(`[dcs-seo] body-prerender skip (empty render): ${route.path}`);
       continue;
     }
-    const html = fs2.readFileSync(outFile, "utf8");
+    if (!spliceBody) {
+      skipped += 1;
+      if (debug) console.log(`[dcs-seo] body-prerender skip (observe-only): ${route.path}`);
+      continue;
+    }
     const spliced = spliceBodyHtml(html, body);
     if (spliced === html) {
       skipped += 1;
       if (debug) console.log(`[dcs-seo] body-prerender skip (no #app container): ${route.path}`);
       continue;
     }
-    fs2.writeFileSync(outFile, spliced, "utf8");
+    fs3.writeFileSync(outFile, spliced, "utf8");
     prerendered += 1;
     done.push(route.path);
     if (debug) {
       console.log(
-        `[dcs-seo] body-prerender wrote ${path.relative(outDir, outFile)} (${body.length} bytes)`
+        `[dcs-seo] body-prerender wrote ${path3.relative(outDir, outFile)} (${body.length} bytes)`
       );
     }
   }
-  return { prerendered, skipped, routes: done };
+  return { prerendered, skipped, routes: done, headObservations, eligibleRoutes, filteredRoutes };
 }
 function isBodyPrerenderEnabled(input) {
   if (!input.emitStaticHtml) return false;
@@ -977,6 +1363,518 @@ function isBodyPrerenderEnabled(input) {
   if (input.seoPrerenderBody === false) return false;
   return true;
 }
+var NON_HTML_EXTENSIONS = /* @__PURE__ */ new Set([
+  ".svg",
+  ".png",
+  ".jpg",
+  ".jpeg",
+  ".webp",
+  ".avif",
+  ".gif",
+  ".ico",
+  ".bmp",
+  ".woff",
+  ".woff2",
+  ".ttf",
+  ".otf",
+  ".eot",
+  ".txt",
+  ".xml",
+  ".json",
+  ".pdf",
+  ".mp4",
+  ".webm",
+  ".mp3",
+  ".wav",
+  ".css",
+  ".js",
+  ".mjs",
+  ".map"
+]);
+var JSONLD_ASSET_KEYS = /* @__PURE__ */ new Set([
+  "logo",
+  "image",
+  "contentUrl",
+  "thumbnailUrl",
+  "photo",
+  "primaryImageOfPage"
+]);
+var JSONLD_PAGE_KEYS = /* @__PURE__ */ new Set(["url", "item", "mainEntityOfPage"]);
+var ASSET_LINK_RELS = /* @__PURE__ */ new Set([
+  "icon",
+  "shortcut icon",
+  "apple-touch-icon",
+  "apple-touch-icon-precomposed",
+  "mask-icon",
+  "manifest",
+  "preload"
+]);
+var PAGE_LINK_RELS = /* @__PURE__ */ new Set(["canonical", "alternate"]);
+function extensionOf(url) {
+  try {
+    const u = url.startsWith("http") ? new URL(url) : new URL(url, "https://placeholder.invalid");
+    return path3.extname(u.pathname).toLowerCase();
+  } catch {
+    return "";
+  }
+}
+function walkJsonLd(node, from, trail, out) {
+  if (Array.isArray(node)) {
+    for (const item of node) walkJsonLd(item, from, trail, out);
+    return;
+  }
+  if (node === null || typeof node !== "object") return;
+  const nodeType = node["@type"];
+  const scope = typeof nodeType === "string" ? `${trail}${nodeType}.` : trail;
+  for (const [key, value] of Object.entries(node)) {
+    if (key === "@id" || key === "sameAs" || key === "@context" || key === "@type") continue;
+    if (typeof value === "string" && /^(https?:)?\/\//.test(value)) {
+      if (JSONLD_ASSET_KEYS.has(key)) {
+        out.push({ url: value, source: `JSON-LD ${scope}${key}`, from, expectation: "asset" });
+        continue;
+      }
+      if (JSONLD_PAGE_KEYS.has(key)) {
+        out.push({ url: value, source: `JSON-LD ${scope}${key}`, from, expectation: "page" });
+        continue;
+      }
+      continue;
+    }
+    if (Array.isArray(value) && JSONLD_ASSET_KEYS.has(key)) {
+      value.forEach((v, i) => {
+        if (typeof v === "string") {
+          out.push({ url: v, source: `JSON-LD ${scope}${key}[${i}]`, from, expectation: "asset" });
+        } else {
+          walkJsonLd(v, from, `${scope}${key}[${i}].`, out);
+        }
+      });
+      continue;
+    }
+    if (value !== null && typeof value === "object") {
+      walkJsonLd(value, from, Array.isArray(value) ? scope : `${scope}${key}.`, out);
+    }
+  }
+}
+function unescapeAttr(value) {
+  return value.replace(/&quot;/g, '"').replace(/&lt;/g, "<").replace(/&gt;/g, ">").replace(/&amp;/g, "&");
+}
+function collectUrlsFromHtml(html, from) {
+  const out = [];
+  const metaRe = /<meta\b[^>]*>/gi;
+  let m;
+  while ((m = metaRe.exec(html)) !== null) {
+    const tag = m[0];
+    const property = readTagAttr(tag, "property")?.toLowerCase();
+    const name = readTagAttr(tag, "name")?.toLowerCase();
+    const content = readTagAttr(tag, "content");
+    if (!content) continue;
+    const key = property ?? name;
+    if (!key) continue;
+    if (key === "og:image" || key === "twitter:image" || key === "og:image:secure_url") {
+      out.push({ url: unescapeAttr(content), source: key, from, expectation: "asset" });
+    } else if (key === "og:url") {
+      out.push({ url: unescapeAttr(content), source: key, from, expectation: "page" });
+    }
+  }
+  const linkRe = /<link\b[^>]*>/gi;
+  while ((m = linkRe.exec(html)) !== null) {
+    const tag = m[0];
+    const rel = readTagAttr(tag, "rel")?.toLowerCase();
+    const href = readTagAttr(tag, "href");
+    if (!rel || !href) continue;
+    if (ASSET_LINK_RELS.has(rel)) {
+      out.push({ url: unescapeAttr(href), source: `link rel="${rel}"`, from, expectation: "asset" });
+    } else if (PAGE_LINK_RELS.has(rel)) {
+      out.push({ url: unescapeAttr(href), source: `link rel="${rel}"`, from, expectation: "page" });
+    }
+  }
+  const scriptRe = /<script[^>]*type=["']application\/ld\+json["'][^>]*>([\s\S]*?)<\/script>/gi;
+  while ((m = scriptRe.exec(html)) !== null) {
+    try {
+      walkJsonLd(JSON.parse(m[1]), from, "", out);
+    } catch {
+    }
+  }
+  return out;
+}
+function collectUrlsFromSitemap(xml, from = "sitemap.xml") {
+  const out = [];
+  const re = /<loc>\s*([\s\S]*?)\s*<\/loc>/gi;
+  let m;
+  while ((m = re.exec(xml)) !== null) {
+    out.push({ url: unescapeAttr(m[1].trim()), source: "<loc>", from, expectation: "page" });
+  }
+  return out;
+}
+function collectUrlsFromLlmsTxt(txt, from = "llms.txt") {
+  const out = [];
+  const re = /\[[^\]]*\]\((https?:\/\/[^)\s]+)\)/g;
+  let m;
+  while ((m = re.exec(txt)) !== null) {
+    const url = m[1];
+    out.push({
+      url,
+      source: "llms.txt link",
+      from,
+      // An llms.txt entry may point at a page OR at a text artifact
+      // (`llms-full.txt`); classify by extension so a `.txt` reference is held to
+      // the non-HTML bar — that is exactly the shape an answer engine probes for.
+      expectation: NON_HTML_EXTENSIONS.has(extensionOf(url)) ? "asset" : "page"
+    });
+  }
+  return out;
+}
+function collectEmittedUrlsFromFiles(files) {
+  const out = [];
+  for (const entry of files) {
+    let text;
+    try {
+      text = fs3.readFileSync(entry.path, "utf8");
+    } catch {
+      continue;
+    }
+    if (entry.kind === "html") out.push(...collectUrlsFromHtml(text, entry.from));
+    else if (entry.kind === "sitemap") out.push(...collectUrlsFromSitemap(text, entry.from));
+    else out.push(...collectUrlsFromLlmsTxt(text, entry.from));
+  }
+  return out;
+}
+function dedupeUrls(urls) {
+  const seen = /* @__PURE__ */ new Map();
+  for (const u of urls) {
+    const key = `${u.expectation}\0${u.url}`;
+    if (!seen.has(key)) seen.set(key, u);
+  }
+  return [...seen.values()];
+}
+function classifyUrl(entry, siteUrl) {
+  const url = entry.url.trim();
+  if (/^(data|mailto|tel|javascript|blob):/i.test(url)) {
+    return { ...entry, locality: "unfetchable", pathname: "" };
+  }
+  let siteOrigin;
+  try {
+    if (siteUrl) siteOrigin = new URL(siteUrl).origin;
+  } catch {
+    siteOrigin = void 0;
+  }
+  if (url.startsWith("/") && !url.startsWith("//")) {
+    return { ...entry, locality: "same-origin", pathname: url.split(/[?#]/)[0] };
+  }
+  try {
+    const parsed = new URL(url.startsWith("//") ? `https:${url}` : url);
+    if (siteOrigin && parsed.origin === siteOrigin) {
+      return { ...entry, locality: "same-origin", pathname: parsed.pathname };
+    }
+    return { ...entry, locality: "remote", pathname: parsed.pathname };
+  } catch {
+    return { ...entry, locality: "unfetchable", pathname: "" };
+  }
+}
+function resolveDistCandidates(outDir, pathname, base) {
+  const clean = decodeURIComponent(pathname).replace(/^\/+/, "");
+  const candidates = [path3.join(outDir, ...clean.split("/"))];
+  const normalizedBase = base.replace(/^\/+|\/+$/g, "");
+  if (normalizedBase && clean.startsWith(normalizedBase + "/")) {
+    candidates.push(path3.join(outDir, ...clean.slice(normalizedBase.length + 1).split("/")));
+  }
+  return candidates;
+}
+function checkSameOriginAssets(params) {
+  return auditSameOriginAssets(params).violations;
+}
+function auditSameOriginAssets(params) {
+  const { urls, outDir, base = "/", allow = [] } = params;
+  const allowed = new Set(allow);
+  const violations = [];
+  let checked = 0;
+  let exempted = 0;
+  for (const entry of dedupeUrls(urls)) {
+    if (entry.locality !== "same-origin" || entry.expectation !== "asset") continue;
+    if (allowed.has(entry.url) || allowed.has(entry.pathname)) {
+      exempted += 1;
+      continue;
+    }
+    checked += 1;
+    const candidates = resolveDistCandidates(outDir, entry.pathname, base);
+    const found = candidates.some((c) => {
+      try {
+        return fs3.statSync(c).isFile();
+      } catch {
+        return false;
+      }
+    });
+    if (found) continue;
+    violations.push({
+      url: entry.url,
+      source: entry.source,
+      from: entry.from,
+      reason: `no file at ${candidates.map((c) => path3.relative(outDir, c)).join(" or ")} in the build output \u2014 the host's SPA fallback will answer this with index.html (200 text/html), so every crawler resolving it gets a web page where a non-HTML asset was promised`
+    });
+  }
+  return { violations, checked, exempted };
+}
+var CACHE_VERSION = 1;
+function readCache(cacheFile) {
+  try {
+    const parsed = JSON.parse(fs3.readFileSync(cacheFile, "utf8"));
+    if (parsed?.version === CACHE_VERSION && parsed.entries) return parsed;
+  } catch {
+  }
+  return { version: CACHE_VERSION, entries: {} };
+}
+function writeCache(cacheFile, cache) {
+  try {
+    fs3.mkdirSync(path3.dirname(cacheFile), { recursive: true });
+    fs3.writeFileSync(cacheFile, JSON.stringify(cache), "utf8");
+  } catch {
+  }
+}
+function isHtmlContentType(contentType) {
+  if (!contentType) return false;
+  return /^\s*(text\/html|application\/xhtml\+xml)/i.test(contentType);
+}
+async function checkRemoteAssets(urls, options) {
+  const {
+    projectRoot,
+    timeoutMs = 5e3,
+    budgetMs = 2e4,
+    concurrency = 6,
+    cacheTtlMs = 24 * 60 * 60 * 1e3,
+    allow = [],
+    fetchImpl = globalThis.fetch,
+    debug = false
+  } = options;
+  const cacheFile = options.cacheFile ?? path3.join(projectRoot, "node_modules", ".cache", "dcs-seo", "url-probes.json");
+  const allowed = new Set(allow);
+  const remoteAssets = dedupeUrls(
+    urls.filter((u) => u.locality === "remote" && u.expectation === "asset")
+  );
+  const targets = remoteAssets.filter((u) => !allowed.has(u.url));
+  const exempted = remoteAssets.length - targets.length;
+  const violations = [];
+  const warnings = [];
+  let cachedCount = 0;
+  let probedCount = 0;
+  let answeredCount = 0;
+  if (targets.length === 0) {
+    return { violations, warnings, cached: 0, probed: 0, checked: 0, exempted };
+  }
+  if (typeof fetchImpl !== "function") {
+    warnings.push({
+      url: "(all remote)",
+      source: "remote probe",
+      from: "-",
+      reason: "no global fetch available in this Node runtime; remote URL checks skipped"
+    });
+    return { violations, warnings, cached: 0, probed: 0, checked: 0, exempted };
+  }
+  const cache = readCache(cacheFile);
+  const now = Date.now();
+  const deadline = now + budgetMs;
+  const record = (entry, probe) => {
+    if (probe.verdict === "ok") return;
+    if (probe.verdict === "html") {
+      violations.push({
+        url: entry.url,
+        source: entry.source,
+        from: entry.from,
+        reason: `resolved 200 with content-type "${probe.contentType}" \u2014 an HTML page where a non-HTML asset was promised. This is the "worse than a 404" shape: nothing errors, nothing logs, and every crawler resolving it silently gets a web page`
+      });
+      return;
+    }
+    violations.push({
+      url: entry.url,
+      source: entry.source,
+      from: entry.from,
+      reason: `resolved HTTP ${probe.status} \u2014 the URL the factory published does not exist`
+    });
+  };
+  const queue = [...targets];
+  const worker = async () => {
+    for (; ; ) {
+      const entry = queue.shift();
+      if (!entry) return;
+      const cached = cache.entries[entry.url];
+      if (cached && now - cached.at < cacheTtlMs) {
+        cachedCount += 1;
+        answeredCount += 1;
+        record(entry, cached);
+        continue;
+      }
+      if (Date.now() >= deadline) {
+        warnings.push({
+          url: entry.url,
+          source: entry.source,
+          from: entry.from,
+          reason: `remote-probe time budget (${budgetMs}ms) exhausted before this URL was checked`
+        });
+        continue;
+      }
+      probedCount += 1;
+      let res;
+      try {
+        res = await fetchImpl(entry.url, {
+          method: "HEAD",
+          redirect: "follow",
+          signal: AbortSignal.timeout(timeoutMs)
+        });
+        if (res.status === 405 || res.status === 501) {
+          res = await fetchImpl(entry.url, {
+            method: "GET",
+            redirect: "follow",
+            headers: { Range: "bytes=0-2047" },
+            signal: AbortSignal.timeout(timeoutMs)
+          });
+        }
+      } catch (err) {
+        warnings.push({
+          url: entry.url,
+          source: entry.source,
+          from: entry.from,
+          reason: `network probe did not complete (${err instanceof Error ? err.message : String(err)}) \u2014 treated as UNKNOWN, not as a failure`
+        });
+        continue;
+      }
+      const contentType = res.headers.get("content-type") ?? void 0;
+      let probe;
+      if (res.status >= 400) {
+        probe = { verdict: "status", status: res.status, contentType, at: Date.now() };
+      } else if (isHtmlContentType(contentType)) {
+        probe = { verdict: "html", status: res.status, contentType, at: Date.now() };
+      } else {
+        probe = { verdict: "ok", status: res.status, contentType, at: Date.now() };
+      }
+      cache.entries[entry.url] = probe;
+      answeredCount += 1;
+      if (debug) {
+        console.log(`[dcs-seo] url probe ${entry.url} -> ${probe.verdict} (${res.status} ${contentType ?? "?"})`);
+      }
+      record(entry, probe);
+    }
+  };
+  await Promise.all(Array.from({ length: Math.min(concurrency, targets.length) }, worker));
+  writeCache(cacheFile, cache);
+  return {
+    violations,
+    warnings,
+    cached: cachedCount,
+    probed: probedCount,
+    checked: answeredCount,
+    exempted
+  };
+}
+function formatEmittedUrlReport(violations) {
+  const lines = [
+    `[dcs-seo] emitted-URL honesty: ${violations.length} URL(s) the SEO factory publishes do not resolve to what they promise.`
+  ];
+  for (const v of violations) {
+    lines.push(`  ${v.url}`);
+    lines.push(`      emitted by: ${v.source}  (in ${v.from})`);
+    lines.push(`      problem   : ${v.reason}`);
+  }
+  lines.push(
+    `  Fix: point the URL at something that exists (via .dcs/seo.yaml \u2014 brand marks usually live on the per-site CDN), or ship the file into the site's public/ directory.`
+  );
+  return lines.join("\n");
+}
+function auditCheckedTotal(audit) {
+  return audit.sameOriginAssetsChecked + audit.remoteAssetsChecked;
+}
+function formatEmittedUrlAudit(audit, routeCount) {
+  const checked = auditCheckedTotal(audit);
+  const parts = [
+    `[dcs-seo] emitted-URL honesty: ${checked} asset URL(s) VERIFIED (${audit.sameOriginAssetsChecked} proven against dist/, ${audit.remoteAssetsChecked} probed remotely${audit.remoteCached ? `, ${audit.remoteCached} from cache` : ""})`,
+    `${audit.pagesUnverified} page URL(s) collected but NOT verified by this rail`
+  ];
+  if (audit.unknown > 0) parts.push(`${audit.unknown} UNKNOWN (no definitive answer)`);
+  if (audit.exempted > 0) parts.push(`${audit.exempted} exempted`);
+  if (audit.unfetchable > 0) parts.push(`${audit.unfetchable} unfetchable by construction`);
+  return parts.join("; ") + `. ${audit.collected} URL(s) collected across ${routeCount} route(s) + sitemap + llms.txt.`;
+}
+var EmittedUrlNotRunError = class extends Error {
+  audit;
+  constructor(audit, detail) {
+    super(
+      `[dcs-seo] emitted-URL honesty DID NOT RUN \u2014 ${detail}. Nothing was verified, so this build proves nothing about the URLs it publishes. (Emitted artifacts unreadable or empty? outDir wrong?) A rail that silently does not run is the exact class this work exists to close.`
+    );
+    this.name = "EmittedUrlNotRunError";
+    this.audit = audit;
+  }
+};
+var EmittedUrlError = class extends Error {
+  violations;
+  constructor(violations) {
+    super(formatEmittedUrlReport(violations));
+    this.name = "EmittedUrlError";
+    this.violations = violations;
+  }
+};
+
+// src/seo/charsetBudget.ts
+var CHARSET_BUDGET_BYTES = 1024;
+var CHARSET_HEADROOM_WARN_BYTES = 256;
+var META_CHARSET_RE = /<meta\s+[^>]*\bcharset\s*=\s*["']?[^"'>\s]+["']?[^>]*>/i;
+var META_HTTP_EQUIV_CHARSET_RE = /<meta\s+[^>]*http-equiv\s*=\s*["']?content-type["']?[^>]*content\s*=\s*["'][^"']*charset=[^"']*["'][^>]*>/i;
+var CANONICAL_CHARSET_META = '<meta charset="utf-8" />';
+function findCharsetByteOffset(html) {
+  const match = META_CHARSET_RE.exec(html) ?? META_HTTP_EQUIV_CHARSET_RE.exec(html);
+  if (!match) return -1;
+  return Buffer.byteLength(html.slice(0, match.index), "utf8");
+}
+function checkCharsetBudget(html, options = {}) {
+  const limitBytes = options.limitBytes ?? CHARSET_BUDGET_BYTES;
+  const match = META_CHARSET_RE.exec(html) ?? META_HTTP_EQUIV_CHARSET_RE.exec(html);
+  if (!match) {
+    return { ok: false, offset: -1, endOffset: -1, headroom: -limitBytes, limitBytes, declaration: null };
+  }
+  const offset = Buffer.byteLength(html.slice(0, match.index), "utf8");
+  const endOffset = offset + Buffer.byteLength(match[0], "utf8");
+  return {
+    ok: endOffset <= limitBytes,
+    offset,
+    endOffset,
+    headroom: limitBytes - endOffset,
+    limitBytes,
+    declaration: match[0]
+  };
+}
+function hoistCharsetMeta(html, options = {}) {
+  const insertIfMissing = options.insertIfMissing ?? true;
+  const headOpen = /<head(\s[^>]*)?>/i.exec(html);
+  if (!headOpen) return html;
+  const insertAt = headOpen.index + headOpen[0].length;
+  const match = META_CHARSET_RE.exec(html) ?? META_HTTP_EQUIV_CHARSET_RE.exec(html);
+  if (!match) {
+    if (!insertIfMissing) return html;
+    return html.slice(0, insertAt) + "\n    " + CANONICAL_CHARSET_META + html.slice(insertAt);
+  }
+  const between = html.slice(insertAt, match.index);
+  if (between.trim() === "") return html;
+  const headClose = /<\/head\s*>/i.exec(html);
+  if (headClose && match.index > headClose.index) return html;
+  const declaration = match[0];
+  const before = html.slice(0, match.index).replace(/[ \t]*$/, "");
+  const after = html.slice(match.index + declaration.length).replace(/^[ \t]*\r?\n/, "");
+  const withoutDeclaration = before + after;
+  return withoutDeclaration.slice(0, insertAt) + "\n    " + declaration + withoutDeclaration.slice(insertAt);
+}
+var CharsetBudgetError = class extends Error {
+  file;
+  result;
+  constructor(file, result) {
+    super(
+      result.declaration === null ? `[dcs-seo] charset budget FAILED for ${file}: the document declares NO character encoding. Browsers fall back to a locale default and every non-ASCII byte can mojibake. Emit <meta charset="utf-8"> as the first child of <head>.` : `[dcs-seo] charset budget FAILED for ${file}: <meta charset> ends at byte ${result.endOffset} of the ${result.limitBytes}-byte encoding-sniffing window (${result.headroom} bytes of headroom). The HTML parser stops looking after byte ${result.limitBytes}, so this document's encoding is not guaranteed to be detected. Move the declaration to the top of <head>.`
+    );
+    this.name = "CharsetBudgetError";
+    this.file = file;
+    this.result = result;
+  }
+};
+function formatCharsetHeadroomWarning(file, result, warnBelow = CHARSET_HEADROOM_WARN_BYTES) {
+  if (!result.ok) return null;
+  if (result.headroom >= warnBelow) return null;
+  return `[dcs-seo] charset budget: ${file} declares its encoding at byte ${result.offset} \u2014 only ${result.headroom} bytes of the ${result.limitBytes}-byte window remain. One more <head> injection breaks encoding detection on this site.`;
+}
 
 // src/seo/vitepressTransform.ts
 function defaultRelativePathToRoute(relativePath, params) {
@@ -1164,6 +2062,6 @@ function createSeoTransformPageData(options) {
   };
 }
 
-export { AI_BOTS, BodyPrerenderError, absolutizeUrl, breadcrumbTrailFromRoute, buildBlogPosting, buildBreadcrumbList, buildFaqPage, buildGlobalGraph, buildHasCredential, buildHeadTags, buildLlmsTxt, buildReviewSchemaParts, buildRobotsTxt, buildSitemapXml, buildVitePressSeoHead, createSeoTransformPageData, defaultRelativePathToRoute, deriveSameAs, escapeJsonLd, filterRealFaq, filterRealReviews, findBusinessLicense, findLocalBusinessSchema, findReviewItemsForPage, generateJsonLd, generateOpenGraphMeta, generateTwitterMeta, graphAbsorbs, graphIds, isBodyPrerenderEnabled, isHandAuthoredRobotsAcceptable, isLocalBusinessType, isRouteIndexable, loadPagesManifest, matchesExcludedGlob, parsePagesManifest, prerenderBodies, renderHeadTags, resolvePageSeo, routeToOutputFile, slugToTitle, spliceBodyHtml, spliceHeadHtml, stripManagedHeadTags };
-//# sourceMappingURL=chunk-F3EIWEZD.js.map
-//# sourceMappingURL=chunk-F3EIWEZD.js.map
+export { AI_BOTS, BodyPrerenderError, CANONICAL_CHARSET_META, CHARSET_BUDGET_BYTES, CHARSET_HEADROOM_WARN_BYTES, CharsetBudgetError, EmittedUrlError, EmittedUrlNotRunError, HeadHonestyError, HeadHonestyNotRunError, SEO_HEAD_ROUTE_HAS_NO_META, absolutizeUrl, assertHeadHonesty, assertHeadHonestyExecuted, auditCheckedTotal, auditSameOriginAssets, breadcrumbTrailFromRoute, buildBlogPosting, buildBreadcrumbList, buildFaqPage, buildGlobalGraph, buildHasCredential, buildHeadTags, buildLlmsTxt, buildReviewSchemaParts, buildRobotsTxt, buildSeoHeadRouteMap, buildSitemapXml, buildVitePressSeoHead, checkCharsetBudget, checkRemoteAssets, checkSameOriginAssets, classifyUrl, collectEmittedUrlsFromFiles, collectUrlsFromHtml, collectUrlsFromLlmsTxt, collectUrlsFromSitemap, createSeoTransformPageData, decodeHtmlEntities, dedupeUrls, defaultRelativePathToRoute, deriveSameAs, escapeJsonLd, extractBakedHead, filterRealFaq, filterRealReviews, findBusinessLicense, findCharsetByteOffset, findDuplicateNormalizedPaths, findHeadHonestyExecutionFaults, findHeadHonestyViolations, findLocalBusinessSchema, findReviewItemsForPage, formatCharsetHeadroomWarning, formatDuplicateNormalizedPaths, formatEmittedUrlAudit, formatEmittedUrlReport, formatHeadHonestyExecutionReport, formatHeadHonestyReport, generateJsonLd, generateOpenGraphMeta, generateTwitterMeta, graphAbsorbs, graphIds, hoistCharsetMeta, installSeoHead, isBodyPrerenderEnabled, isHandAuthoredRobotsAcceptable, isLocalBusinessType, isRouteEmitted, isRouteIndexable, loadPagesManifest, normalizeHeadText, normalizeSeoHeadPath, parsePagesManifest, prerenderBodies, renderHeadTags, resolveHonestyMode, resolvePageSeo, routeExclusionReason, routeToOutputFile, slugToTitle, spliceBodyHtml, spliceHeadHtml, stripManagedHeadTags };
+//# sourceMappingURL=chunk-HVSF23P7.js.map
+//# sourceMappingURL=chunk-HVSF23P7.js.map