@duffcloudservices/cms 0.10.0 → 0.12.0

package/dist/plugins/index.js

@@ -1,19 +1,20 @@
-import { buildSitemapXml, isHandAuthoredRobotsAcceptable, buildRobotsTxt, buildLlmsTxt, matchesExcludedGlob, breadcrumbTrailFromRoute, findReviewItemsForPage, buildHeadTags, spliceHeadHtml, loadPagesManifest } from '../chunk-UPAMLKOQ.js';
-export { buildVitePressSeoHead, createSeoTransformPageData, defaultRelativePathToRoute } from '../chunk-UPAMLKOQ.js';
-import fs3 from 'fs';
-import path3 from 'path';
-import yaml3 from 'js-yaml';
+import { buildSitemapXml, isHandAuthoredRobotsAcceptable, buildRobotsTxt, buildLlmsTxt, matchesExcludedGlob, breadcrumbTrailFromRoute, findReviewItemsForPage, findBusinessLicense, buildHeadTags, spliceHeadHtml, routeToOutputFile, loadPagesManifest, isBodyPrerenderEnabled, prerenderBodies } from '../chunk-F3EIWEZD.js';
+export { buildVitePressSeoHead, createSeoTransformPageData, defaultRelativePathToRoute } from '../chunk-F3EIWEZD.js';
+import fs5 from 'fs';
+import path5 from 'path';
+import yaml4 from 'js-yaml';
+import http from 'http';
 import { defineComponent, h } from 'vue';
 
 function dcsSearchPaths(projectRoot, relPath) {
   return [
-    path3.resolve(projectRoot, relPath),
-    path3.resolve(projectRoot, "..", relPath),
-    path3.resolve(process.cwd(), relPath)
+    path5.resolve(projectRoot, relPath),
+    path5.resolve(projectRoot, "..", relPath),
+    path5.resolve(process.cwd(), relPath)
   ];
 }
 function resolveDcsFile(projectRoot, relPath) {
-  return dcsSearchPaths(projectRoot, relPath).find((p) => fs3.existsSync(p));
+  return dcsSearchPaths(projectRoot, relPath).find((p) => fs5.existsSync(p));
 }
 function readDcsYamlFresh(projectRoot, relPath, label, debug = false) {
   const found = resolveDcsFile(projectRoot, relPath);
@@ -22,7 +23,7 @@ function readDcsYamlFresh(projectRoot, relPath, label, debug = false) {
     return void 0;
   }
   try {
-    return yaml3.load(fs3.readFileSync(found, "utf8"));
+    return yaml4.load(fs5.readFileSync(found, "utf8"));
   } catch (error) {
     console.warn(`[${label}] serve: failed to parse ${relPath}:`, error);
     return void 0;
@@ -67,8 +68,50 @@ function dcsMotionTokensStyleTag() {
     injectTo: "head-prepend"
   };
 }
+var DEFAULT_AGENT_API_BASE_URL = "https://portal.duffcloudservices.com";
+var DEFAULT_AGENT_WIDGET_SCRIPT_URL = "https://files.duffcloudservices.com/agent-widget/v1/dcs-agent-widget.js";
+var trimTrailingSlash = (value) => value.replace(/\/+$/, "");
+var encodeForInlineScript = (value) => JSON.stringify(value).replace(/</g, "\\u003c").replace(/>/g, "\\u003e").replace(/\u2028/g, "\\u2028").replace(/\u2029/g, "\\u2029");
+function buildAgentWidgetLoaderScript(options) {
+  const slug = encodeForInlineScript(options.siteSlug);
+  const api = encodeForInlineScript(trimTrailingSlash(options.apiBaseUrl || DEFAULT_AGENT_API_BASE_URL));
+  const cdn = encodeForInlineScript(options.cdnScriptUrl || DEFAULT_AGENT_WIDGET_SCRIPT_URL);
+  return "(function(){try{if(window.__DCS_AGENT_LOADER__)return;window.__DCS_AGENT_LOADER__=1;try{if(window.self!==window.top)return;}catch(e){return;}if(/[?&]dcs-hide-widget(?:[=&]|$)/.test(location.search))return;var S=" + slug + ",A=" + api + ",C=" + cdn + ';var go=function(){try{var p=function(u){return fetch(u,{headers:{Accept:"application/json"}}).then(function(r){return r&&r.ok?r.json()["catch"](function(){return null;}):null;})["catch"](function(){return null;});};p("/api/v1/agent/config").then(function(c){return c||p(A+"/api/v1/sites/"+encodeURIComponent(S)+"/agent/config");}).then(function(c){if(!c||!c.enabled)return;window.__DCS_AGENT_BOOTSTRAP__={siteSlug:S,apiBaseUrl:A,config:c};var s=document.createElement("script");s.src=C;s.async=true;s.setAttribute("data-dcs-agent-slug",S);(document.head||document.documentElement).appendChild(s);}).catch(function(){});}catch(e){}};if("requestIdleCallback"in window){requestIdleCallback(go,{timeout:4000});}else{setTimeout(go,1200);}}catch(e){}})();';
+}
+var SITE_YAML_CANDIDATES = [".dcs/site.yaml", "../.dcs/site.yaml"];
+function readSiteSlug(projectRoot) {
+  const candidates = [
+    ...SITE_YAML_CANDIDATES.map((rel) => path5.resolve(projectRoot, rel)),
+    path5.resolve(process.cwd(), ".dcs/site.yaml")
+  ];
+  for (const candidate of candidates) {
+    try {
+      if (!fs5.existsSync(candidate)) continue;
+      const parsed = yaml4.load(fs5.readFileSync(candidate, "utf8"));
+      const slug = parsed && typeof parsed.site_slug === "string" ? parsed.site_slug.trim() : "";
+      if (slug) return slug;
+    } catch {
+    }
+  }
+  return null;
+}
+function dcsAgentWidgetLoaderTag(options) {
+  const siteSlug = readSiteSlug(options.projectRoot);
+  if (!siteSlug) return null;
+  return {
+    tag: "script",
+    attrs: { "data-dcs-agent-loader": "" },
+    children: buildAgentWidgetLoaderScript({
+      siteSlug,
+      apiBaseUrl: options.apiBaseUrl,
+      cdnScriptUrl: options.cdnScriptUrl
+    }),
+    injectTo: "head"
+  };
+}
 
 // src/plugins/dcsContentPlugin.ts
+var DCS_SSR_NO_EXTERNAL = ["@duffcloudservices/cms"];
 function dcsContentPlugin(options = {}) {
   const { contentPath = ".dcs/content.yaml", debug = false } = options;
   let resolvedConfig;
@@ -84,18 +127,19 @@ function dcsContentPlugin(options = {}) {
         return {
           define: {
             __DCS_CONTENT__: "globalThis.__DCS_CONTENT__"
-          }
+          },
+          ssr: { noExternal: DCS_SSR_NO_EXTERNAL }
         };
       }
       const projectRoot = config.root || process.cwd();
       const possiblePaths = [
-        path3.resolve(projectRoot, contentPath),
-        path3.resolve(projectRoot, "..", contentPath),
-        path3.resolve(process.cwd(), contentPath)
+        path5.resolve(projectRoot, contentPath),
+        path5.resolve(projectRoot, "..", contentPath),
+        path5.resolve(process.cwd(), contentPath)
       ];
       let foundPath;
       for (const testPath of possiblePaths) {
-        if (fs3.existsSync(testPath)) {
+        if (fs5.existsSync(testPath)) {
           foundPath = testPath;
           break;
         }
@@ -109,12 +153,13 @@ function dcsContentPlugin(options = {}) {
         return {
           define: {
             __DCS_CONTENT__: "undefined"
-          }
+          },
+          ssr: { noExternal: DCS_SSR_NO_EXTERNAL }
         };
       }
       try {
-        const fileContent = fs3.readFileSync(foundPath, "utf8");
-        const content = yaml3.load(fileContent);
+        const fileContent = fs5.readFileSync(foundPath, "utf8");
+        const content = yaml4.load(fileContent);
         if (debug) {
           console.log(`[dcs-content] Loaded ${foundPath}`);
           console.log(`[dcs-content] Version: ${content.version}`);
@@ -124,14 +169,16 @@ function dcsContentPlugin(options = {}) {
         return {
           define: {
             __DCS_CONTENT__: JSON.stringify(content)
-          }
+          },
+          ssr: { noExternal: DCS_SSR_NO_EXTERNAL }
         };
       } catch (error) {
         console.warn("[dcs-content] Failed to parse content.yaml:", error);
         return {
           define: {
             __DCS_CONTENT__: "undefined"
-          }
+          },
+          ssr: { noExternal: DCS_SSR_NO_EXTERNAL }
         };
       }
     },
@@ -157,6 +204,14 @@ function dcsContentPlugin(options = {}) {
       order: "pre",
       handler(html) {
         const tags = [dcsMotionTokensStyleTag()];
+        if (!isDev) {
+          const projectRoot = resolvedConfig?.root || process.cwd();
+          const agentTag = dcsAgentWidgetLoaderTag({
+            projectRoot,
+            apiBaseUrl: process.env.VITE_API_BASE_URL
+          });
+          if (agentTag) tags.push(agentTag);
+        }
         if (isDev) {
           const projectRoot = resolvedConfig?.root || process.cwd();
           const content = readDcsYamlFresh(
@@ -190,17 +245,17 @@ function dcsContentPlugin(options = {}) {
     configureServer(server) {
       const projectRoot = resolvedConfig?.root || process.cwd();
       const watchPaths = [
-        path3.resolve(projectRoot, contentPath),
-        path3.resolve(projectRoot, "..", contentPath)
-      ].map((p) => path3.normalize(p));
+        path5.resolve(projectRoot, contentPath),
+        path5.resolve(projectRoot, "..", contentPath)
+      ].map((p) => path5.normalize(p));
       watchPaths.forEach((watchPath) => {
-        if (fs3.existsSync(watchPath)) {
+        if (fs5.existsSync(watchPath)) {
           server.watcher.add(watchPath);
         }
       });
       let reloadTimer;
       server.watcher.on("change", (changedPath) => {
-        if (!watchPaths.includes(path3.normalize(changedPath))) return;
+        if (!watchPaths.includes(path5.normalize(changedPath))) return;
         if (reloadTimer) clearTimeout(reloadTimer);
         reloadTimer = setTimeout(() => {
           if (debug) {
@@ -212,19 +267,191 @@ function dcsContentPlugin(options = {}) {
     }
   };
 }
+var CONTENT_TYPES = {
+  ".html": "text/html; charset=utf-8",
+  ".js": "text/javascript; charset=utf-8",
+  ".mjs": "text/javascript; charset=utf-8",
+  ".css": "text/css; charset=utf-8",
+  ".json": "application/json; charset=utf-8",
+  ".svg": "image/svg+xml",
+  ".png": "image/png",
+  ".jpg": "image/jpeg",
+  ".jpeg": "image/jpeg",
+  ".webp": "image/webp",
+  ".gif": "image/gif",
+  ".ico": "image/x-icon",
+  ".woff": "font/woff",
+  ".woff2": "font/woff2",
+  ".ttf": "font/ttf",
+  ".txt": "text/plain; charset=utf-8",
+  ".xml": "application/xml; charset=utf-8",
+  ".map": "application/json; charset=utf-8"
+};
+async function startStaticServer(outDir) {
+  const server = http.createServer((req, res) => {
+    let pathname = "/";
+    try {
+      pathname = decodeURIComponent(new URL(req.url ?? "/", "http://127.0.0.1").pathname);
+    } catch {
+      pathname = "/";
+    }
+    const resolved = path5.resolve(outDir, "." + pathname);
+    if (resolved !== outDir && !resolved.startsWith(outDir + path5.sep)) {
+      res.writeHead(403);
+      res.end();
+      return;
+    }
+    let filePath = resolved;
+    try {
+      const stat = fs5.statSync(filePath);
+      if (stat.isDirectory()) filePath = path5.join(filePath, "index.html");
+    } catch {
+      if (path5.extname(pathname)) {
+        res.writeHead(404);
+        res.end();
+        return;
+      }
+      filePath = path5.join(outDir, "index.html");
+    }
+    fs5.readFile(filePath, (err, buf) => {
+      if (err) {
+        res.writeHead(404);
+        res.end();
+        return;
+      }
+      res.writeHead(200, {
+        "Content-Type": CONTENT_TYPES[path5.extname(filePath).toLowerCase()] ?? "application/octet-stream"
+      });
+      res.end(buf);
+    });
+  });
+  await new Promise((resolve) => server.listen(0, "127.0.0.1", resolve));
+  const addr = server.address();
+  const origin = `http://127.0.0.1:${addr.port}`;
+  return {
+    origin,
+    close: () => new Promise((resolve) => {
+      server.close(() => resolve());
+    })
+  };
+}
+async function createPlaywrightRenderer(options) {
+  const {
+    outDir,
+    navTimeoutMs = 3e4,
+    mountTimeoutMs = 15e3,
+    settleMs = 250,
+    debug = false
+  } = options;
+  let chromium;
+  try {
+    const specifier = "playwright";
+    const pw = await import(
+      /* @vite-ignore */
+      specifier
+    );
+    chromium = pw.chromium;
+  } catch {
+    console.warn(
+      "[dcs-seo] body-prerender: `playwright` is not installed; skipping body prerender (head + JSON-LD still emitted). `pnpm add -D playwright` to enable."
+    );
+    return null;
+  }
+  if (!chromium) {
+    console.warn("[dcs-seo] body-prerender: playwright has no chromium export; skipping.");
+    return null;
+  }
+  let browser;
+  try {
+    browser = await chromium.launch({ headless: true });
+  } catch (err) {
+    console.warn(
+      "[dcs-seo] body-prerender: failed to launch Chromium (run `npx playwright install chromium`); skipping body prerender:",
+      err instanceof Error ? err.message : err
+    );
+    return null;
+  }
+  const staticServer = await startStaticServer(outDir);
+  const context = await browser.newContext({ reducedMotion: "reduce" });
+  const renderer = {
+    async renderRoute(routePath) {
+      const page = await context.newPage();
+      const errors = [];
+      page.on("pageerror", (err) => errors.push(`pageerror: ${err.message}`));
+      if (debug) {
+        page.on("console", (msg) => {
+          if (msg.type() === "error") console.log(`[dcs-seo]   (console) ${msg.text()}`);
+        });
+      }
+      await page.route("**/*", (route) => {
+        let sameOrigin = false;
+        try {
+          sameOrigin = new URL(route.request().url()).origin === staticServer.origin;
+        } catch {
+          sameOrigin = false;
+        }
+        if (sameOrigin) {
+          route.continue().catch(() => {
+          });
+        } else {
+          route.abort().catch(() => {
+          });
+        }
+      });
+      try {
+        await page.goto(staticServer.origin + routePath, {
+          waitUntil: "load",
+          timeout: navTimeoutMs
+        });
+        await page.waitForFunction(
+          () => {
+            const el = document.querySelector("#app");
+            return !!el && el.children.length > 0;
+          },
+          void 0,
+          { timeout: mountTimeoutMs }
+        );
+        if (settleMs > 0) await page.waitForTimeout(settleMs);
+        const bodyHtml = await page.$eval("#app", (el) => el.innerHTML);
+        return { bodyHtml: bodyHtml ?? "", errors };
+      } catch (err) {
+        errors.push(err instanceof Error ? err.message : String(err));
+        return { bodyHtml: "", errors };
+      } finally {
+        await page.close();
+      }
+    }
+  };
+  return {
+    renderer,
+    async close() {
+      try {
+        await context.close();
+      } catch {
+      }
+      try {
+        await browser.close();
+      } catch {
+      }
+      await staticServer.close();
+    }
+  };
+}
+
+// src/plugins/dcsSeoPlugin.ts
 function resolveOutDir(config) {
   const out = config.build?.outDir || "dist";
-  return path3.isAbsolute(out) ? out : path3.resolve(config.root || process.cwd(), out);
+  return path5.isAbsolute(out) ? out : path5.resolve(config.root || process.cwd(), out);
 }
 function loadSeoConfig(projectRoot, seoPath, debug) {
   const possiblePaths = [
-    path3.resolve(projectRoot, seoPath),
-    path3.resolve(projectRoot, "..", seoPath),
-    path3.resolve(process.cwd(), seoPath)
+    path5.resolve(projectRoot, seoPath),
+    path5.resolve(projectRoot, "..", seoPath),
+    path5.resolve(process.cwd(), seoPath)
   ];
   let foundPath;
   for (const testPath of possiblePaths) {
-    if (fs3.existsSync(testPath)) {
+    if (fs5.existsSync(testPath)) {
       foundPath = testPath;
       break;
     }
@@ -238,8 +465,8 @@ function loadSeoConfig(projectRoot, seoPath, debug) {
     return null;
   }
   try {
-    const fileContent = fs3.readFileSync(foundPath, "utf8");
-    const config = yaml3.load(fileContent);
+    const fileContent = fs5.readFileSync(foundPath, "utf8");
+    const config = yaml4.load(fileContent);
     return { config, foundPath };
   } catch (error) {
     console.warn("[dcs-seo] Failed to parse seo.yaml:", error);
@@ -248,17 +475,17 @@ function loadSeoConfig(projectRoot, seoPath, debug) {
 }
 function loadContentConfig(projectRoot, contentRelPath, debug) {
   const possiblePaths = [
-    path3.resolve(projectRoot, contentRelPath),
-    path3.resolve(projectRoot, "..", contentRelPath),
-    path3.resolve(process.cwd(), contentRelPath)
+    path5.resolve(projectRoot, contentRelPath),
+    path5.resolve(projectRoot, "..", contentRelPath),
+    path5.resolve(process.cwd(), contentRelPath)
   ];
-  const foundPath = possiblePaths.find((p) => fs3.existsSync(p));
+  const foundPath = possiblePaths.find((p) => fs5.existsSync(p));
   if (!foundPath) {
     if (debug) console.log(`[dcs-seo] No content.yaml found (reviews disabled)`);
     return void 0;
   }
   try {
-    const parsed = yaml3.load(fs3.readFileSync(foundPath, "utf8"));
+    const parsed = yaml4.load(fs5.readFileSync(foundPath, "utf8"));
     if (!parsed || typeof parsed !== "object") return void 0;
     return parsed;
   } catch (error) {
@@ -266,21 +493,16 @@ function loadContentConfig(projectRoot, contentRelPath, debug) {
     return void 0;
   }
 }
-function routeToOutputFile(outDir, routePath) {
-  const trimmed = routePath.replace(/^\/+/, "").replace(/\/+$/, "");
-  if (trimmed === "") return path3.join(outDir, "index.html");
-  return path3.join(outDir, ...trimmed.split("/"), "index.html");
-}
 function loadExcludedGlobs(projectRoot, pagesPath) {
   const possiblePaths = [
-    path3.resolve(projectRoot, pagesPath),
-    path3.resolve(projectRoot, "..", pagesPath),
-    path3.resolve(process.cwd(), pagesPath)
+    path5.resolve(projectRoot, pagesPath),
+    path5.resolve(projectRoot, "..", pagesPath),
+    path5.resolve(process.cwd(), pagesPath)
   ];
-  const found = possiblePaths.find((p) => fs3.existsSync(p));
+  const found = possiblePaths.find((p) => fs5.existsSync(p));
   if (!found) return [];
   try {
-    const raw = yaml3.load(fs3.readFileSync(found, "utf8"));
+    const raw = yaml4.load(fs5.readFileSync(found, "utf8"));
     const excluded = raw?.excluded;
     if (!Array.isArray(excluded)) return [];
     return excluded.filter((e) => typeof e === "string");
@@ -292,14 +514,14 @@ function deriveLastmod(seoConfig, projectRoot, pagesPath) {
   const fromSeo = seoConfig?.lastUpdated;
   if (typeof fromSeo === "string" && fromSeo.length > 0) return fromSeo;
   const possiblePaths = [
-    path3.resolve(projectRoot, pagesPath),
-    path3.resolve(projectRoot, "..", pagesPath),
-    path3.resolve(process.cwd(), pagesPath)
+    path5.resolve(projectRoot, pagesPath),
+    path5.resolve(projectRoot, "..", pagesPath),
+    path5.resolve(process.cwd(), pagesPath)
   ];
-  const found = possiblePaths.find((p) => fs3.existsSync(p));
+  const found = possiblePaths.find((p) => fs5.existsSync(p));
   if (!found) return void 0;
   try {
-    const raw = yaml3.load(fs3.readFileSync(found, "utf8"));
+    const raw = yaml4.load(fs5.readFileSync(found, "utf8"));
     const fromPages = raw?.lastUpdated;
     if (typeof fromPages === "string" && fromPages.length > 0) return fromPages;
   } catch {
@@ -337,7 +559,7 @@ function emitSiteFiles(params) {
       lastmod
     });
     if (xml) {
-      fs3.writeFileSync(path3.join(outDir, "sitemap.xml"), xml, "utf8");
+      fs5.writeFileSync(path5.join(outDir, "sitemap.xml"), xml, "utf8");
       wroteSitemap = true;
       written.push("sitemap.xml");
       if (debug) console.log("[dcs-seo] wrote sitemap.xml");
@@ -346,8 +568,8 @@ function emitSiteFiles(params) {
     }
   }
   if (robots.enabled ?? true) {
-    const robotsPath = path3.join(outDir, "robots.txt");
-    const existing = fs3.existsSync(robotsPath) && !robots.force ? fs3.readFileSync(robotsPath, "utf8") : null;
+    const robotsPath = path5.join(outDir, "robots.txt");
+    const existing = fs5.existsSync(robotsPath) && !robots.force ? fs5.readFileSync(robotsPath, "utf8") : null;
     const keepHandAuthored = existing !== null && isHandAuthoredRobotsAcceptable(existing);
     if (keepHandAuthored) {
       if (debug)
@@ -359,7 +581,7 @@ function emitSiteFiles(params) {
         robots,
         hasSitemap: wroteSitemap
       });
-      fs3.writeFileSync(robotsPath, txt, "utf8");
+      fs5.writeFileSync(robotsPath, txt, "utf8");
       written.push("robots.txt");
       if (debug) {
         console.log(
@@ -378,7 +600,7 @@ function emitSiteFiles(params) {
       excludedGlobs
     });
     if (txt) {
-      fs3.writeFileSync(path3.join(outDir, "llms.txt"), txt, "utf8");
+      fs5.writeFileSync(path5.join(outDir, "llms.txt"), txt, "utf8");
       written.push("llms.txt");
       if (debug) console.log("[dcs-seo] wrote llms.txt");
     } else if (debug) {
@@ -428,6 +650,7 @@ function emitStaticSeoHtml(params) {
     const forceNoindex = noindexSet.has(route.path) || route.slug && noindexSet.has(route.slug);
     const breadcrumbTrail = siteUrl ? breadcrumbTrailFromRoute(route.path, siteUrl, routeTitles) : void 0;
     const reviews = contentConfig ? findReviewItemsForPage(contentConfig, route.slug) : void 0;
+    const license = contentConfig ? findBusinessLicense(contentConfig, route.slug) : void 0;
     const isBlogPost = /^\/blog\/.+/.test(route.path) && !!route.title;
     const blogMeta = isBlogPost ? { headline: route.title, url: breadcrumbTrail?.[breadcrumbTrail.length - 1]?.item } : void 0;
     const faq = pickPageFaq(contentConfig, route.slug);
@@ -438,27 +661,50 @@ function emitStaticSeoHtml(params) {
       emitGraph: true,
       breadcrumbTrail,
       reviews,
+      license,
       blogMeta,
       faq
     });
     const html = spliceHeadHtml(shellHtml, tags);
     const outFile = routeToOutputFile(outDir, route.path);
-    fs3.mkdirSync(path3.dirname(outFile), { recursive: true });
-    fs3.writeFileSync(outFile, html, "utf8");
+    fs5.mkdirSync(path5.dirname(outFile), { recursive: true });
+    fs5.writeFileSync(outFile, html, "utf8");
     written++;
     if (debug) {
       console.log(
-        `[dcs-seo] wrote ${path3.relative(outDir, outFile)} (title="${tags.title}"${forceNoindex ? ", noindex" : ""})`
+        `[dcs-seo] wrote ${path5.relative(outDir, outFile)} (title="${tags.title}"${forceNoindex ? ", noindex" : ""})`
       );
     }
   }
   return written;
 }
+async function runBodyPrerender(ctx, opts) {
+  const handle = await createPlaywrightRenderer({ outDir: ctx.outDir, debug: opts.debug });
+  if (!handle) return;
+  console.log("[dcs-seo] body-prerender: rendering routes via headless Chromium\u2026");
+  try {
+    const result = await prerenderBodies({
+      outDir: ctx.outDir,
+      routes: ctx.routes,
+      renderer: handle.renderer,
+      exclude: opts.exclude,
+      noindex: opts.noindex,
+      excludedGlobs: ctx.excludedGlobs,
+      debug: opts.debug
+    });
+    console.log(
+      `[dcs-seo] body-prerender: ${result.prerendered} route(s) now have crawler-visible body content (${result.skipped} skipped)`
+    );
+  } finally {
+    await handle.close();
+  }
+}
 function dcsSeoPlugin(options = {}) {
   const {
     seoPath = ".dcs/seo.yaml",
     debug = false,
     emitStaticHtml = false,
+    prerenderBody,
     pagesPath = ".dcs/pages.yaml",
     contentPath = ".dcs/content.yaml",
     exclude = [],
@@ -468,7 +714,9 @@ function dcsSeoPlugin(options = {}) {
     emitSiteFiles: emitSiteFilesOpt = emitStaticHtml,
     siteUrl,
     robots = {},
-    preview = false,
+    // Self-detect preview builds from DCS_PREVIEW (mirrors dcsEditorPlugin) so a
+    // release/** SWA preview build never body-prerenders; an explicit option wins.
+    preview = process.env.DCS_PREVIEW === "true",
     llms = true
   } = options;
   let resolvedConfig;
@@ -520,7 +768,7 @@ function dcsSeoPlugin(options = {}) {
      * Fully defensive: any missing/unparseable input logs a warning and
      * no-ops. Never throws (so it can never break a production build).
      */
-    writeBundle() {
+    async writeBundle() {
       if (!emitStaticHtml) {
         if (options.emitSiteFiles === true) {
           console.warn(
@@ -529,15 +777,16 @@ function dcsSeoPlugin(options = {}) {
         }
         return;
       }
+      let bodyPrerenderCtx = null;
       try {
         const projectRoot = resolvedConfig?.root || process.cwd();
         const outDir = resolveOutDir(resolvedConfig);
-        if (!fs3.existsSync(outDir)) {
+        if (!fs5.existsSync(outDir)) {
           console.warn(`[dcs-seo] emitStaticHtml: outDir not found (${outDir}); skipping`);
           return;
         }
-        const shellPath = path3.join(outDir, "index.html");
-        if (!fs3.existsSync(shellPath)) {
+        const shellPath = path5.join(outDir, "index.html");
+        if (!fs5.existsSync(shellPath)) {
           console.warn(
             `[dcs-seo] emitStaticHtml: no index.html in ${outDir}; nothing to emit`
           );
@@ -556,7 +805,7 @@ function dcsSeoPlugin(options = {}) {
             `[dcs-seo] emitStaticHtml: ${seoPath} missing or unparseable; emitting with defaults only`
           );
         }
-        const shellHtml = fs3.readFileSync(shellPath, "utf8");
+        const shellHtml = fs5.readFileSync(shellPath, "utf8");
         const excludedGlobs = loadExcludedGlobs(projectRoot, pagesPath);
         const contentConfig = loadContentConfig(projectRoot, contentPath, debug);
         const written = emitStaticSeoHtml({
@@ -594,9 +843,28 @@ function dcsSeoPlugin(options = {}) {
             );
           }
         }
+        const buildBase = resolvedConfig?.base ?? "/";
+        const baseIsRoot = buildBase === "/" || buildBase === "./" || buildBase === "";
+        if (isBodyPrerenderEnabled({
+          emitStaticHtml,
+          prerenderBodyOption: prerenderBody,
+          preview,
+          seoPrerenderBody: loaded?.config?.prerenderBody
+        })) {
+          if (baseIsRoot) {
+            bodyPrerenderCtx = { outDir, routes, excludedGlobs };
+          } else {
+            console.warn(
+              `[dcs-seo] body prerender skipped: non-root base "${buildBase}" (assets would not resolve through the prerender server; head + JSON-LD still emitted)`
+            );
+          }
+        }
       } catch (error) {
         console.warn("[dcs-seo] emitStaticHtml failed; build output left unchanged:", error);
       }
+      if (bodyPrerenderCtx) {
+        await runBodyPrerender(bodyPrerenderCtx, { exclude, noindex, debug });
+      }
     },
     /**
      * Dev-only: inject the FRESH on-disk `seo.yaml` as an inline
@@ -637,17 +905,17 @@ function dcsSeoPlugin(options = {}) {
     configureServer(server) {
       const projectRoot = resolvedConfig?.root || process.cwd();
       const watchPaths = [
-        path3.resolve(projectRoot, seoPath),
-        path3.resolve(projectRoot, "..", seoPath)
-      ].map((p) => path3.normalize(p));
+        path5.resolve(projectRoot, seoPath),
+        path5.resolve(projectRoot, "..", seoPath)
+      ].map((p) => path5.normalize(p));
       watchPaths.forEach((watchPath) => {
-        if (fs3.existsSync(watchPath)) {
+        if (fs5.existsSync(watchPath)) {
           server.watcher.add(watchPath);
         }
       });
       let reloadTimer;
       server.watcher.on("change", (changedPath) => {
-        if (!watchPaths.includes(path3.normalize(changedPath))) return;
+        if (!watchPaths.includes(path5.normalize(changedPath))) return;
         if (reloadTimer) clearTimeout(reloadTimer);
         reloadTimer = setTimeout(() => {
           if (debug) {
@@ -735,7 +1003,7 @@ if (document.readyState === 'loading') {
      *
      * These are virtual modules resolved via absolute paths (e.g.
      * `/__dcs-editor-bridge.js`). When base !== '/', the app is served at a
-     * sub-path (e.g. /handyman-bryan/) and the absolute virtual paths are NOT
+     * sub-path (e.g. /iron-oak-contractors/) and the absolute virtual paths are NOT
      * routed to the Vite dev server by the reverse proxy — they hit the main
      * DCS server instead and get redirected to portal.duffcloudservices.com
      * (no CORS headers), causing browser console errors.
@@ -784,13 +1052,22 @@ function dcsPreviewPlugin(ribbonComponent, options = {}) {
 function escapeHtml(str) {
   return str.replace(/&/g, "&amp;").replace(/"/g, "&quot;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
 }
+function dimensionAttrs(entry) {
+  const w = entry.width;
+  const h2 = entry.height;
+  if (typeof w === "number" && w > 0 && typeof h2 === "number" && h2 > 0) {
+    return ` width="${w}" height="${h2}"`;
+  }
+  return "";
+}
 function buildPictureElement(entry, alt, extraAttrs, sizes) {
   const variants = entry.variants ?? [];
+  const dims = dimensionAttrs(entry);
   const displayVariants = variants.filter(
     (v) => v.suffix === "-sm" || v.suffix === "-md" || v.suffix === "-lg"
   );
   if (displayVariants.length === 0) {
-    return `<img src="${escapeHtml(entry.cdnUrl)}" alt="${escapeHtml(alt)}"${extraAttrs} loading="lazy" decoding="async" />`;
+    return `<img src="${escapeHtml(entry.cdnUrl)}" alt="${escapeHtml(alt)}"${extraAttrs}${dims} loading="lazy" decoding="async" />`;
   }
   const srcset = displayVariants.map((v) => `${v.cdnUrl} ${v.width}w`).join(", ");
   const mdVariant = variants.find((v) => v.suffix === "-md");
@@ -798,20 +1075,20 @@ function buildPictureElement(entry, alt, extraAttrs, sizes) {
   return [
     "<picture>",
     `  <source srcset="${srcset}" type="image/webp" sizes="${escapeHtml(sizes)}" />`,
-    `  <img src="${escapeHtml(fallbackSrc)}" alt="${escapeHtml(alt)}"${extraAttrs} loading="lazy" decoding="async" />`,
+    `  <img src="${escapeHtml(fallbackSrc)}" alt="${escapeHtml(alt)}"${extraAttrs}${dims} loading="lazy" decoding="async" />`,
     "</picture>"
   ].join("\n");
 }
 function loadCdnImageMap(projectRoot, relativeMapPath, debug) {
   const possiblePaths = [
-    path3.resolve(projectRoot, relativeMapPath),
-    path3.resolve(projectRoot, "..", relativeMapPath),
-    path3.resolve(process.cwd(), relativeMapPath)
+    path5.resolve(projectRoot, relativeMapPath),
+    path5.resolve(projectRoot, "..", relativeMapPath),
+    path5.resolve(process.cwd(), relativeMapPath)
   ];
   for (const testPath of possiblePaths) {
-    if (fs3.existsSync(testPath)) {
+    if (fs5.existsSync(testPath)) {
       try {
-        const raw = fs3.readFileSync(testPath, "utf8");
+        const raw = fs5.readFileSync(testPath, "utf8");
         const data = JSON.parse(raw);
         const map = /* @__PURE__ */ new Map();
         for (const entry of data.images) {
@@ -872,12 +1149,15 @@ function dcsCdnImagePlugin(options = {}) {
       if (!entry) return _match;
       const altMatch = (beforeSrc + afterSrc).match(/alt=["']([^"']*)["']/);
       const alt = altMatch ? altMatch[1] : "";
-      const otherAttrs = (beforeSrc + afterSrc).replace(/\balt=["'][^"']*["']/gi, "").replace(/\bloading=["'][^"']*["']/gi, "").replace(/\bdecoding=["'][^"']*["']/gi, "").trim();
+      let otherAttrs = (beforeSrc + afterSrc).replace(/\balt=["'][^"']*["']/gi, "").replace(/\bloading=["'][^"']*["']/gi, "").replace(/\bdecoding=["'][^"']*["']/gi, "").trim();
+      if (dimensionAttrs(entry)) {
+        otherAttrs = otherAttrs.replace(/\b(?:width|height)=(?:"[^"]*"|'[^']*'|[^\s"'>/]+)/gi, "").replace(/\s{2,}/g, " ").trim();
+      }
       const extraAttrs = otherAttrs ? " " + otherAttrs : "";
       const sizesMatch = (beforeSrc + afterSrc).match(/data-sizes=["']([^"']*)["']/);
       const sizes = sizesMatch ? sizesMatch[1] : defaultSizes;
       if (!entry.variants || entry.variants.length === 0) {
-        return `<img src="${escapeHtml(entry.cdnUrl)}" alt="${escapeHtml(alt)}"${extraAttrs} loading="lazy" decoding="async" />`;
+        return `<img src="${escapeHtml(entry.cdnUrl)}" alt="${escapeHtml(alt)}"${extraAttrs}${dimensionAttrs(entry)} loading="lazy" decoding="async" />`;
       }
       return buildPictureElement(entry, alt, extraAttrs, sizes);
     });
@@ -972,13 +1252,13 @@ function dcsCdnBuildEnd(options = {}) {
       return;
     }
     const outDir = siteConfig.outDir;
-    if (!fs3.existsSync(outDir)) return;
+    if (!fs5.existsSync(outDir)) return;
     let filesProcessed = 0;
     let refsReplaced = 0;
     function walkDir(dir) {
-      const entries = fs3.readdirSync(dir, { withFileTypes: true });
+      const entries = fs5.readdirSync(dir, { withFileTypes: true });
       for (const entry of entries) {
-        const fullPath = path3.join(dir, entry.name);
+        const fullPath = path5.join(dir, entry.name);
         if (entry.isDirectory()) {
           walkDir(fullPath);
         } else if (extensions.some((ext) => entry.name.endsWith(ext))) {
@@ -987,7 +1267,7 @@ function dcsCdnBuildEnd(options = {}) {
       }
     }
     function processFile(filePath) {
-      let content = fs3.readFileSync(filePath, "utf8");
+      let content = fs5.readFileSync(filePath, "utf8");
       if (!pathPrefixes.some((p) => content.includes(p))) return;
       let changed = false;
       if (filePath.endsWith(".html")) {
@@ -1022,7 +1302,7 @@ function dcsCdnBuildEnd(options = {}) {
         }
       }
       if (changed) {
-        fs3.writeFileSync(filePath, content, "utf8");
+        fs5.writeFileSync(filePath, content, "utf8");
         filesProcessed++;
       }
     }
@@ -1070,7 +1350,88 @@ function responsiveImagePlugin(md) {
     ].join("\n");
   };
 }
+var BASE_CDN_ASSET = /^https?:\/\/files\.[^/]+\/(?:content\/)?[^/]+\/assets\/(?:[^/]+\/)*[a-f0-9-]+\.\w+(?:[?#].*)?$/i;
+function isFullSizeCdnUrl(url) {
+  return BASE_CDN_ASSET.test(url.trim());
+}
+function readAttr(tag, name) {
+  const m = tag.match(new RegExp(`\\b${name}=("([^"]*)"|'([^']*)')`, "i"));
+  if (!m) return null;
+  return m[2] ?? m[3] ?? "";
+}
+function findFullSizeCdnImages(html) {
+  const violations = [];
+  for (const m of html.matchAll(/<img\b[^>]*>/gi)) {
+    const src = readAttr(m[0], "src");
+    if (src && isFullSizeCdnUrl(src)) {
+      violations.push({ url: src.trim(), tag: "img" });
+    }
+  }
+  for (const m of html.matchAll(/<source\b[^>]*>/gi)) {
+    const srcset = readAttr(m[0], "srcset");
+    if (!srcset) continue;
+    for (const candidate of srcset.split(",")) {
+      const url = candidate.trim().split(/\s+/)[0];
+      if (url && isFullSizeCdnUrl(url)) {
+        violations.push({ url, tag: "source" });
+      }
+    }
+  }
+  return violations;
+}
+function dcsResponsiveImageLint(options = {}) {
+  const { failOnViolation = false, extensions = [".html"], debug = false } = options;
+  return async (siteConfig) => {
+    const report = { filesScanned: 0, violations: [] };
+    const outDir = siteConfig.outDir;
+    if (!outDir || !fs5.existsSync(outDir)) return report;
+    const walk = (dir) => {
+      for (const entry of fs5.readdirSync(dir, { withFileTypes: true })) {
+        const full = path5.join(dir, entry.name);
+        if (entry.isDirectory()) {
+          walk(full);
+        } else if (extensions.some((ext) => entry.name.endsWith(ext))) {
+          report.filesScanned++;
+          const html = fs5.readFileSync(full, "utf8");
+          if (!html.includes("/assets/")) continue;
+          const rel = path5.relative(outDir, full);
+          for (const v of findFullSizeCdnImages(html)) {
+            report.violations.push({ ...v, file: rel });
+            if (debug) {
+              console.log(`[dcs-responsive-lint] ${rel}: <${v.tag}> full-size ${v.url}`);
+            }
+          }
+        }
+      }
+    };
+    walk(outDir);
+    if (report.violations.length > 0) {
+      const lines = report.violations.map((v) => `  ${v.file}: <${v.tag}> ${v.url}`).join("\n");
+      const summary = `[dcs-responsive-lint] ${report.violations.length} full-size CDN image(s) shipped without a -sm/-md/-lg responsive variant across ${report.filesScanned} file(s):
+${lines}`;
+      if (failOnViolation) {
+        throw new Error(summary);
+      }
+      console.warn(summary);
+    } else if (debug) {
+      console.log(
+        `[dcs-responsive-lint] clean \u2014 scanned ${report.filesScanned} file(s), no full-size images.`
+      );
+    }
+    return report;
+  };
+}
+function chainBuildEnd(...hooks) {
+  const active = hooks.filter(
+    (h2) => typeof h2 === "function"
+  );
+  return async (siteConfig) => {
+    for (const hook of active) {
+      await hook(siteConfig);
+    }
+  };
+}
 
-export { DCS_MOTION_TOKENS_CSS, dcsCdnBuildEnd, dcsCdnImagePlugin, dcsContentPlugin, dcsEditorPlugin, dcsMotionTokensStyleTag, dcsPreviewPlugin, dcsSeoPlugin, emitSiteFiles, emitStaticSeoHtml, responsiveImagePlugin };
+export { DCS_MOTION_TOKENS_CSS, DEFAULT_AGENT_API_BASE_URL, DEFAULT_AGENT_WIDGET_SCRIPT_URL, buildAgentWidgetLoaderScript, chainBuildEnd, dcsAgentWidgetLoaderTag, dcsCdnBuildEnd, dcsCdnImagePlugin, dcsContentPlugin, dcsEditorPlugin, dcsMotionTokensStyleTag, dcsPreviewPlugin, dcsResponsiveImageLint, dcsSeoPlugin, emitSiteFiles, emitStaticSeoHtml, findFullSizeCdnImages, isFullSizeCdnUrl, readSiteSlug, responsiveImagePlugin };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map