@duffcloudservices/cms 0.6.0 → 0.7.1

package/dist/chunk-FUNIALH6.js

@@ -0,0 +1,1003 @@
+import fs from 'fs';
+import path from 'path';
+import yaml from 'js-yaml';
+
+// src/seo/schemaGraph.ts
+var SCHEMA_CONTEXT = "https://schema.org";
+var LOCAL_BUSINESS_TYPES = /* @__PURE__ */ new Set([
+  "LocalBusiness",
+  "HomeAndConstructionBusiness",
+  "GeneralContractor",
+  "HVACBusiness",
+  "Plumber",
+  "Electrician",
+  "RoofingContractor",
+  "HousePainter",
+  "MovingCompany",
+  "MedicalBusiness",
+  "Dentist",
+  "Physician",
+  "MedicalClinic",
+  "LegalService",
+  "Attorney",
+  "Notary",
+  "AccountingService",
+  "FinancialService",
+  "InsuranceAgency",
+  "RealEstateAgent",
+  "Store",
+  "ProfessionalService",
+  "AutomotiveBusiness",
+  "AutoRepair",
+  "BeautySalon",
+  "HairSalon",
+  "HealthAndBeautyBusiness",
+  "FoodEstablishment",
+  "Restaurant"
+]);
+function isLocalBusinessType(type) {
+  return !!type && LOCAL_BUSINESS_TYPES.has(type);
+}
+function trimSlash(url) {
+  return url.replace(/\/+$/, "");
+}
+function graphIds(siteUrl) {
+  const base = trimSlash(siteUrl);
+  return {
+    organization: `${base}/#organization`,
+    website: `${base}/#website`,
+    localBusiness: `${base}/#localbusiness`
+  };
+}
+function deriveSameAs(global) {
+  const s = global.social;
+  if (!s) return [];
+  const out = [];
+  const push = (u) => {
+    if (u && u.trim()) out.push(u.trim());
+  };
+  if (s.facebook) push(asUrl(s.facebook, "https://www.facebook.com/"));
+  if (s.instagram) push(asUrl(stripAt(s.instagram), "https://www.instagram.com/"));
+  if (s.linkedin) push(asUrl(s.linkedin, "https://www.linkedin.com/in/"));
+  if (s.youtube) push(asUrl(s.youtube, "https://www.youtube.com/"));
+  if (s.github) push(asUrl(stripAt(s.github), "https://github.com/"));
+  if (s.twitter) push(asUrl(stripAt(s.twitter), "https://twitter.com/"));
+  return out;
+}
+function stripAt(handle) {
+  return handle.startsWith("@") ? handle.slice(1) : handle;
+}
+function asUrl(value, base) {
+  if (/^https?:\/\//i.test(value)) return value;
+  return `${base}${value.replace(/^\/+/, "")}`;
+}
+function findLocalBusinessSchema(global) {
+  const schemas = global.schemas ?? [];
+  for (let i = 0; i < schemas.length; i++) {
+    if (isLocalBusinessType(schemas[i]?.type)) {
+      return { schema: schemas[i], index: i };
+    }
+  }
+  return null;
+}
+function graphAbsorbs(schema, global) {
+  if (schema.type === "Organization" || schema.type === "WebSite") return true;
+  const found = findLocalBusinessSchema(global);
+  return !!found && found.schema === schema;
+}
+function filterRealReviews(items) {
+  if (!Array.isArray(items)) return [];
+  const out = [];
+  for (const item of items) {
+    if (!item || typeof item !== "object") continue;
+    const ratingNum = Number(item.rating);
+    const text = typeof item.text === "string" ? item.text.trim() : "";
+    const authorName = typeof item.authorName === "string" ? item.authorName.trim() : "";
+    if (!Number.isFinite(ratingNum) || ratingNum <= 0) continue;
+    if (!text) continue;
+    if (!authorName) continue;
+    out.push({
+      rating: ratingNum,
+      text,
+      authorName,
+      ...typeof item.date === "string" && item.date.trim() ? { date: item.date.trim() } : {},
+      ...typeof item.locationName === "string" && item.locationName.trim() ? { locationName: item.locationName.trim() } : {}
+    });
+  }
+  return out;
+}
+var BEST_RATING = 5;
+var WORST_RATING = 1;
+function clampRating(value) {
+  if (value < WORST_RATING) return WORST_RATING;
+  if (value > BEST_RATING) return BEST_RATING;
+  return value;
+}
+function buildReviewSchemaParts(items) {
+  const real = filterRealReviews(items);
+  if (real.length === 0) return { review: [] };
+  const clamped = real.map((r) => ({ ...r, rating: clampRating(r.rating) }));
+  const review = clamped.map((r) => ({
+    "@type": "Review",
+    reviewRating: {
+      "@type": "Rating",
+      ratingValue: r.rating,
+      bestRating: BEST_RATING,
+      worstRating: WORST_RATING
+    },
+    author: { "@type": "Person", name: r.authorName },
+    reviewBody: r.text,
+    ...r.date ? { datePublished: r.date } : {}
+  }));
+  const sum = clamped.reduce((acc, r) => acc + r.rating, 0);
+  const mean = Math.round(sum / clamped.length * 10) / 10;
+  const aggregateRating = {
+    "@type": "AggregateRating",
+    ratingValue: mean,
+    reviewCount: clamped.length,
+    ratingCount: clamped.length,
+    bestRating: BEST_RATING,
+    worstRating: WORST_RATING
+  };
+  return { review, aggregateRating };
+}
+function buildGlobalGraph(global, opts = {}) {
+  const siteUrl = global.siteUrl ? trimSlash(global.siteUrl) : "";
+  if (!siteUrl) return [];
+  const ids = graphIds(siteUrl);
+  const name = global.siteName || "";
+  const logo = global.images?.logo;
+  const sameAs = deriveSameAs(global);
+  const organization = {
+    "@type": "Organization",
+    "@id": ids.organization,
+    ...name ? { name } : {},
+    url: `${siteUrl}/`,
+    ...logo ? { logo } : {},
+    ...sameAs.length ? { sameAs } : {}
+  };
+  const website = {
+    "@type": "WebSite",
+    "@id": ids.website,
+    url: `${siteUrl}/`,
+    ...name ? { name } : {},
+    publisher: { "@id": ids.organization }
+  };
+  const graph = [organization, website];
+  const found = findLocalBusinessSchema(global);
+  if (found) {
+    const props = found.schema.properties ?? {};
+    const localBusiness = {
+      "@type": found.schema.type,
+      "@id": ids.localBusiness,
+      // Preserve the hand-authored NAP/geo/hours/offers verbatim…
+      ...props,
+      // …but ensure the cross-link to the Organization is present.
+      parentOrganization: { "@id": ids.organization }
+    };
+    if (localBusiness.url == null) localBusiness.url = `${siteUrl}/`;
+    const reviewParts = buildReviewSchemaParts(opts.reviews);
+    if (reviewParts.review.length > 0) {
+      localBusiness.review = reviewParts.review;
+      if (reviewParts.aggregateRating) {
+        localBusiness.aggregateRating = reviewParts.aggregateRating;
+      }
+    }
+    graph.push(localBusiness);
+  }
+  return [
+    {
+      "@context": SCHEMA_CONTEXT,
+      "@graph": graph
+    }
+  ];
+}
+function buildBreadcrumbList(trail) {
+  if (!Array.isArray(trail) || trail.length <= 1) return [];
+  const itemListElement = trail.map((crumb, i) => ({
+    "@type": "ListItem",
+    position: i + 1,
+    name: crumb.name,
+    item: crumb.item
+  }));
+  return [
+    {
+      "@context": SCHEMA_CONTEXT,
+      "@type": "BreadcrumbList",
+      itemListElement
+    }
+  ];
+}
+function breadcrumbTrailFromRoute(route, siteUrl, titles = {}, homeName = "Home") {
+  const base = trimSlash(siteUrl);
+  const home = {
+    name: titles["/"] || homeName,
+    item: `${base}/`
+  };
+  const normalised = (route || "/").split("?")[0].split("#")[0];
+  if (normalised === "/" || normalised === "") return [home];
+  const segments = normalised.replace(/^\/+/, "").replace(/\/+$/, "").split("/");
+  const trail = [home];
+  let acc = "";
+  for (const seg of segments) {
+    acc += `/${seg}`;
+    trail.push({
+      name: titles[acc] || slugToTitle(seg),
+      item: `${base}${acc}`
+    });
+  }
+  return trail;
+}
+function slugToTitle(slug) {
+  const cleaned = (slug || "").replace(/[-_]+/g, " ").trim();
+  if (!cleaned) return slug || "";
+  return cleaned.split(/\s+/).map((w) => w.charAt(0).toUpperCase() + w.slice(1)).join(" ");
+}
+function buildBlogPosting(meta, siteUrl, global) {
+  const headline = typeof meta.headline === "string" ? meta.headline.trim() : "";
+  if (!headline) return [];
+  const ids = graphIds(siteUrl);
+  const base = trimSlash(siteUrl);
+  const name = global?.siteName?.trim();
+  const orgNode = {
+    "@type": "Organization",
+    "@id": ids.organization,
+    ...name ? { name } : {},
+    ...base ? { url: `${base}/` } : {}
+  };
+  const node = {
+    "@context": SCHEMA_CONTEXT,
+    "@type": "BlogPosting",
+    headline,
+    author: orgNode,
+    publisher: orgNode
+  };
+  if (meta.description) node.description = meta.description;
+  if (meta.datePublished) node.datePublished = meta.datePublished;
+  if (meta.dateModified) node.dateModified = meta.dateModified;
+  if (meta.image) node.image = meta.image;
+  if (meta.url) node.mainEntityOfPage = meta.url;
+  return [node];
+}
+function filterRealFaq(entries) {
+  if (!Array.isArray(entries)) return [];
+  const out = [];
+  for (const entry of entries) {
+    if (!entry || typeof entry !== "object") continue;
+    const q = pickString(entry.q ?? entry.question);
+    const a = pickString(entry.a ?? entry.answer);
+    if (!q || !a) continue;
+    out.push({ question: q, answer: a });
+  }
+  return out;
+}
+function pickString(value) {
+  return typeof value === "string" ? value.trim() : "";
+}
+function buildFaqPage(entries) {
+  const real = filterRealFaq(entries);
+  if (real.length === 0) return [];
+  return [
+    {
+      "@context": SCHEMA_CONTEXT,
+      "@type": "FAQPage",
+      mainEntity: real.map((f) => ({
+        "@type": "Question",
+        name: f.question,
+        acceptedAnswer: { "@type": "Answer", text: f.answer }
+      }))
+    }
+  ];
+}
+function isReviewItemsKey(key) {
+  return /^reviews\..+\.items$/.test(key);
+}
+function findReviewItemsForPage(content, pageSlug) {
+  if (!content) return [];
+  const fromBlock = (block) => {
+    if (!block) return null;
+    for (const key of Object.keys(block)) {
+      if (isReviewItemsKey(key) && Array.isArray(block[key])) {
+        return block[key];
+      }
+    }
+    return null;
+  };
+  const page = content.pages?.[pageSlug];
+  return fromBlock(page) ?? fromBlock(content.global) ?? [];
+}
+function absolutizeUrl(value, siteUrl, fallback = "") {
+  const v = (value ?? "").trim();
+  if (!v) return fallback;
+  if (/^https?:\/\//i.test(v)) return v;
+  const base = trimSlash(siteUrl ?? "");
+  if (!base) return v;
+  return `${base}/${v.replace(/^\/+/, "")}`;
+}
+
+// src/seo/headTags.ts
+function generateOpenGraphMeta(og, global, resolvedTitle, pageDescription, canonical) {
+  const tags = [];
+  tags.push({ property: "og:title", content: og.title || resolvedTitle });
+  tags.push({ property: "og:description", content: og.description || pageDescription });
+  tags.push({ property: "og:url", content: absolutizeUrl(og.url, global.siteUrl, canonical) });
+  tags.push({ property: "og:type", content: og.type || "website" });
+  const image = og.image || global.images?.ogDefault;
+  if (image) {
+    tags.push({ property: "og:image", content: image });
+    if (og.imageAlt || resolvedTitle) {
+      tags.push({ property: "og:image:alt", content: og.imageAlt || resolvedTitle });
+    }
+    if (og.imageWidth) {
+      tags.push({ property: "og:image:width", content: String(og.imageWidth) });
+    }
+    if (og.imageHeight) {
+      tags.push({ property: "og:image:height", content: String(og.imageHeight) });
+    }
+  }
+  if (global.siteName) {
+    tags.push({ property: "og:site_name", content: global.siteName });
+  }
+  if (global.locale) {
+    tags.push({ property: "og:locale", content: global.locale });
+  }
+  if (og.type === "article") {
+    if (og.publishedTime) {
+      tags.push({ property: "article:published_time", content: og.publishedTime });
+    }
+    if (og.modifiedTime) {
+      tags.push({ property: "article:modified_time", content: og.modifiedTime });
+    }
+    if (og.author) {
+      tags.push({ property: "article:author", content: og.author });
+    }
+    if (og.section) {
+      tags.push({ property: "article:section", content: og.section });
+    }
+    if (og.tags) {
+      og.tags.forEach((tag) => {
+        tags.push({ property: "article:tag", content: tag });
+      });
+    }
+  }
+  return tags;
+}
+function generateTwitterMeta(twitter, global, resolvedTitle, pageDescription) {
+  const tags = [];
+  tags.push({ name: "twitter:card", content: twitter.card || "summary_large_image" });
+  tags.push({ name: "twitter:title", content: twitter.title || resolvedTitle });
+  tags.push({ name: "twitter:description", content: twitter.description || pageDescription });
+  const image = twitter.image || global.images?.twitterDefault;
+  if (image) {
+    tags.push({ name: "twitter:image", content: image });
+    if (twitter.imageAlt || resolvedTitle) {
+      tags.push({ name: "twitter:image:alt", content: twitter.imageAlt || resolvedTitle });
+    }
+  }
+  const site = twitter.site || global.social?.twitter;
+  if (site) {
+    tags.push({ name: "twitter:site", content: site.startsWith("@") ? site : `@${site}` });
+  }
+  if (twitter.creator) {
+    tags.push({
+      name: "twitter:creator",
+      content: twitter.creator.startsWith("@") ? twitter.creator : `@${twitter.creator}`
+    });
+  }
+  return tags;
+}
+function generateJsonLd(schemas, global) {
+  return schemas.map((schema) => {
+    const base = {
+      "@context": "https://schema.org",
+      "@type": schema.type
+    };
+    if (schema.properties) {
+      Object.assign(base, schema.properties);
+    }
+    if (schema.type === "WebSite" && global.siteUrl && !base.url) {
+      base.url = global.siteUrl;
+    }
+    if (schema.type === "WebSite" && global.siteName && !base.name) {
+      base.name = global.siteName;
+    }
+    return base;
+  });
+}
+function resolvePageSeo(pageSlug, pagePath, seoConfig, fallbackTitle) {
+  const global = seoConfig?.global ?? {};
+  const page = seoConfig?.pages?.[pageSlug] ?? {};
+  let canonical = page.canonical || "";
+  if (!canonical && global.siteUrl) {
+    const path2 = pagePath ?? (pageSlug === "home" ? "/" : `/${pageSlug}`);
+    canonical = `${global.siteUrl.replace(/\/$/, "")}${path2}`;
+  }
+  const pageSpecificTitle = page.title || fallbackTitle;
+  let title;
+  if (pageSpecificTitle) {
+    title = page.noTitleTemplate || !global.titleTemplate ? pageSpecificTitle : global.titleTemplate.replace("%s", pageSpecificTitle);
+  } else {
+    title = global.defaultTitle || pageSlug;
+  }
+  const openGraph = {
+    type: page.openGraph?.type || "website",
+    title: page.openGraph?.title || title,
+    description: page.openGraph?.description || page.description || global.defaultDescription || "",
+    ...page.openGraph
+  };
+  const twitter = {
+    card: page.twitter?.card || "summary_large_image",
+    ...page.twitter
+  };
+  const schemas = [...global.schemas ?? [], ...page.schemas ?? []];
+  return {
+    title,
+    description: page.description || global.defaultDescription || "",
+    canonical,
+    robots: page.robots || global.robots || "index, follow",
+    openGraph,
+    twitter,
+    schemas,
+    alternates: page.alternates ?? [],
+    // Surface keywords on the resolved object so both runtime and emitter can
+    // emit the meta tag without re-reading the raw page config.
+    keywords: page.keywords
+  };
+}
+function buildHeadTags(pageSlug, pagePath, seoConfig, overrides) {
+  const resolved = resolvePageSeo(pageSlug, pagePath, seoConfig, overrides?.fallbackTitle);
+  const global = seoConfig?.global ?? {};
+  const title = overrides?.title ?? resolved.title;
+  const description = overrides?.description ?? resolved.description;
+  const robots = overrides?.robots ?? resolved.robots;
+  const keywords = overrides?.keywords ?? resolved.keywords;
+  const meta = [];
+  meta.push({ name: "description", content: description });
+  if (keywords && overrides?.includeKeywords) {
+    meta.push({ name: "keywords", content: keywords });
+  }
+  if (robots) {
+    meta.push({ name: "robots", content: robots });
+  }
+  if (global.verification?.google) {
+    meta.push({ name: "google-site-verification", content: global.verification.google });
+  }
+  if (global.verification?.bing) {
+    meta.push({ name: "msvalidate.01", content: global.verification.bing });
+  }
+  const ogMeta = generateOpenGraphMeta(resolved.openGraph, global, title, description, resolved.canonical);
+  meta.push(...ogMeta.map((t) => ({ property: t.property, content: t.content })));
+  const twitterMeta = generateTwitterMeta(resolved.twitter, global, title, description);
+  meta.push(...twitterMeta.map((t) => ({ name: t.name, content: t.content })));
+  if (overrides?.meta) {
+    meta.push(...overrides.meta);
+  }
+  const link = [];
+  if (resolved.canonical) {
+    link.push({ rel: "canonical", href: absolutizeUrl(resolved.canonical, global.siteUrl, resolved.canonical) });
+  }
+  resolved.alternates.forEach((alt) => {
+    link.push({ rel: "alternate", href: alt.href, hreflang: alt.hreflang });
+  });
+  const jsonLd = buildJsonLd(resolved, global, overrides);
+  const script = jsonLd.map((schema) => ({
+    type: "application/ld+json",
+    children: JSON.stringify(schema)
+  }));
+  return { title, meta, link, script, jsonLd, resolved };
+}
+function buildJsonLd(resolved, global, overrides) {
+  if (overrides?.schemas) return overrides.schemas;
+  const out = [];
+  const emitGraph = overrides?.emitGraph === true;
+  let perSchema = resolved.schemas;
+  if (emitGraph) {
+    const graph = buildGlobalGraph(global, { reviews: overrides?.reviews });
+    if (graph.length > 0) {
+      out.push(...graph);
+      perSchema = resolved.schemas.filter((s) => !graphAbsorbs(s, global));
+    }
+  }
+  out.push(...generateJsonLd(perSchema, global));
+  if (overrides?.breadcrumbTrail) {
+    out.push(...buildBreadcrumbList(overrides.breadcrumbTrail));
+  }
+  if (overrides?.blogMeta && global.siteUrl) {
+    const alreadyAuthored = resolved.schemas.some((s) => s.type === "BlogPosting");
+    if (!alreadyAuthored) {
+      out.push(...buildBlogPosting(overrides.blogMeta, global.siteUrl, global));
+    }
+  }
+  if (overrides?.faq) {
+    out.push(...buildFaqPage(overrides.faq));
+  }
+  return out;
+}
+
+// src/seo/spliceHeadHtml.ts
+function escapeAttr(value) {
+  return value.replace(/&/g, "&amp;").replace(/"/g, "&quot;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+}
+function escapeJsonLd(json) {
+  return json.replace(/</g, "\\u003c").replace(/>/g, "\\u003e").replace(/&/g, "\\u0026");
+}
+var MANAGED_META_NAMES = /* @__PURE__ */ new Set([
+  "description",
+  "keywords",
+  "robots",
+  "google-site-verification",
+  "msvalidate.01"
+]);
+var MANAGED_PROPERTY_PREFIXES = ["og:", "article:"];
+var MANAGED_NAME_PREFIXES = ["twitter:"];
+function renderHeadTags(tags, indent = "    ") {
+  const lines = [];
+  lines.push(`${indent}<title>${escapeAttr(tags.title)}</title>`);
+  for (const m of tags.meta) {
+    if (m.property !== void 0) {
+      lines.push(`${indent}<meta property="${escapeAttr(m.property)}" content="${escapeAttr(m.content)}" />`);
+    } else if (m.name !== void 0) {
+      lines.push(`${indent}<meta name="${escapeAttr(m.name)}" content="${escapeAttr(m.content)}" />`);
+    }
+  }
+  for (const l of tags.link) {
+    const hreflang = l.hreflang ? ` hreflang="${escapeAttr(l.hreflang)}"` : "";
+    lines.push(`${indent}<link rel="${escapeAttr(l.rel)}" href="${escapeAttr(l.href)}"${hreflang} />`);
+  }
+  for (const s of tags.script) {
+    lines.push(`${indent}<script type="${escapeAttr(s.type)}">${escapeJsonLd(s.children)}</script>`);
+  }
+  return lines.join("\n");
+}
+function stripManagedHeadTags(html) {
+  const headMatch = html.match(/<head[^>]*>([\s\S]*?)<\/head>/i);
+  if (!headMatch) return html;
+  let head = headMatch[1];
+  head = head.replace(/[ \t]*<title>[\s\S]*?<\/title>[ \t]*\r?\n?/gi, "");
+  head = head.replace(
+    /[ \t]*<script[^>]*type=["']application\/ld\+json["'][^>]*>[\s\S]*?<\/script>[ \t]*\r?\n?/gi,
+    ""
+  );
+  head = head.replace(/[ \t]*<meta\b[^>]*>[ \t]*\r?\n?/gi, (tag) => {
+    const nameMatch = tag.match(/\bname=["']([^"']*)["']/i);
+    const propMatch = tag.match(/\bproperty=["']([^"']*)["']/i);
+    const name = nameMatch?.[1]?.toLowerCase();
+    const property = propMatch?.[1]?.toLowerCase();
+    if (name) {
+      if (MANAGED_META_NAMES.has(name)) return "";
+      if (MANAGED_NAME_PREFIXES.some((p) => name.startsWith(p))) return "";
+    }
+    if (property) {
+      if (MANAGED_PROPERTY_PREFIXES.some((p) => property.startsWith(p))) return "";
+    }
+    return tag;
+  });
+  head = head.replace(
+    /[ \t]*<link\b[^>]*\brel=["'](?:canonical|alternate)["'][^>]*>[ \t]*\r?\n?/gi,
+    ""
+  );
+  return html.slice(0, headMatch.index + headMatch[0].indexOf(headMatch[1])) + head + html.slice(headMatch.index + headMatch[0].indexOf(headMatch[1]) + headMatch[1].length);
+}
+function spliceHeadHtml(html, tags) {
+  if (!/<\/head>/i.test(html)) {
+    return html;
+  }
+  const stripped = stripManagedHeadTags(html);
+  const fragment = renderHeadTags(tags);
+  return stripped.replace(/([ \t]*)<\/head>/i, (_m, indent) => {
+    return `${fragment}
+${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 (fs.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(fs.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;
+    routes.push({
+      slug: typeof slug === "string" ? slug : "",
+      path: p,
+      ...typeof title === "string" && title.length > 0 ? { title } : {}
+    });
+  }
+  return routes.length > 0 ? routes : null;
+}
+
+// src/seo/sitemap.ts
+var XML_HEADER = '<?xml version="1.0" encoding="UTF-8"?>';
+var URLSET_NS = "http://www.sitemaps.org/schemas/sitemap/0.9";
+var AI_BOTS = ["GPTBot", "ClaudeBot", "PerplexityBot", "Google-Extended"];
+function trimTrailingSlash(url) {
+  return url.replace(/\/+$/, "");
+}
+function sanitizeLlmsText(value) {
+  if (!value) return "";
+  return value.replace(/[\u0000-\u001f\u007f-\u009f]+/g, " ").replace(/\]\(/g, "] (").replace(/[[\]]/g, " ").replace(/\s+/g, " ").trim().replace(/^([#>*+-]+)/, "\\$1");
+}
+function escapeXml(value) {
+  return value.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&apos;");
+}
+function globToRegExp(glob) {
+  const escaped = glob.replace(/[.+?^${}()|[\]\\]/g, "\\$&").replace(/\*/g, ".*");
+  return new RegExp(`^${escaped}$`);
+}
+function matchesExcludedGlob(routePath, excludedGlobs) {
+  return excludedGlobs.some((g) => globToRegExp(g).test(routePath));
+}
+var W3C_DATETIME_RE = /^\d{4}(-\d{2}(-\d{2}(T\d{2}:\d{2}(:\d{2}(\.\d+)?)?(Z|[+-]\d{2}:\d{2})?)?)?)?$/;
+function validW3CLastmod(value) {
+  if (typeof value !== "string") return void 0;
+  const v = value.trim();
+  if (!v) return void 0;
+  if (!W3C_DATETIME_RE.test(v)) return void 0;
+  const ms = Date.parse(v);
+  if (Number.isNaN(ms)) return void 0;
+  const dateOnly = v.match(/^(\d{4})-(\d{2})-(\d{2})$/);
+  if (dateOnly) {
+    const [, y, m, d] = dateOnly;
+    const dt = new Date(ms);
+    if (dt.getUTCFullYear() !== Number(y) || dt.getUTCMonth() + 1 !== Number(m) || dt.getUTCDate() !== Number(d)) {
+      return void 0;
+    }
+  }
+  return v;
+}
+function isRouteIndexable(route, seoConfig, opts = {}) {
+  const { exclude, noindex, excludedGlobs = [] } = opts;
+  if (exclude && (exclude.has(route.path) || route.slug && exclude.has(route.slug))) return false;
+  if (noindex && (noindex.has(route.path) || route.slug && noindex.has(route.slug))) return false;
+  if (matchesExcludedGlob(route.path, excludedGlobs)) return false;
+  const resolved = resolvePageSeo(route.slug, route.path, seoConfig, route.title);
+  if (/noindex/i.test(resolved.robots)) return false;
+  return true;
+}
+function resolveLoc(route, seoConfig, siteUrl) {
+  const resolved = resolvePageSeo(route.slug, route.path, seoConfig, route.title);
+  if (resolved.canonical) return resolved.canonical;
+  if (siteUrl) return `${trimTrailingSlash(siteUrl)}${route.path}`;
+  return null;
+}
+function buildSitemapXml(params) {
+  const {
+    routes,
+    siteUrl,
+    seoConfig,
+    exclude = [],
+    noindex = [],
+    excludedGlobs = [],
+    lastmod
+  } = params;
+  const excludeSet = new Set(exclude);
+  const noindexSet = new Set(noindex);
+  const seen = /* @__PURE__ */ new Set();
+  const locs = [];
+  for (const route of routes) {
+    if (!isRouteIndexable(route, seoConfig, { exclude: excludeSet, noindex: noindexSet, excludedGlobs })) {
+      continue;
+    }
+    const loc = resolveLoc(route, seoConfig, siteUrl);
+    if (!loc) continue;
+    if (seen.has(loc)) continue;
+    seen.add(loc);
+    locs.push(loc);
+  }
+  if (locs.length === 0) return "";
+  const validLastmod = validW3CLastmod(lastmod);
+  const lastmodLine = validLastmod ? `
+    <lastmod>${escapeXml(validLastmod)}</lastmod>` : "";
+  const urls = locs.map((loc) => `  <url>
+    <loc>${escapeXml(loc)}</loc>${lastmodLine}
+  </url>`).join("\n");
+  return `${XML_HEADER}
+<urlset xmlns="${URLSET_NS}">
+${urls}
+</urlset>
+`;
+}
+function buildRobotsTxt(params) {
+  const { siteUrl, preview = false, robots = {}, hasSitemap = true } = params;
+  const { disallow = [], allow, extra = [], aiBots = true } = robots;
+  const lines = ["User-agent: *"];
+  if (preview) {
+    lines.push("Disallow: /");
+    if (aiBots) {
+      for (const bot of AI_BOTS) {
+        lines.push("");
+        lines.push(`User-agent: ${bot}`);
+        lines.push("Disallow: /");
+      }
+    }
+    if (extra.length > 0) lines.push(...extra);
+    return lines.join("\n") + "\n";
+  }
+  const allowLines = allow ?? ["/"];
+  for (const a of allowLines) lines.push(`Allow: ${a}`);
+  for (const d of disallow) lines.push(`Disallow: ${d}`);
+  if (aiBots) {
+    for (const bot of AI_BOTS) {
+      lines.push("");
+      lines.push(`User-agent: ${bot}`);
+      for (const a of allowLines) lines.push(`Allow: ${a}`);
+      for (const d of disallow) lines.push(`Disallow: ${d}`);
+    }
+  }
+  if (hasSitemap && siteUrl) {
+    lines.push("");
+    lines.push(`Sitemap: ${trimTrailingSlash(siteUrl)}/sitemap.xml`);
+  }
+  if (extra.length > 0) {
+    lines.push(...extra);
+  }
+  return lines.join("\n") + "\n";
+}
+function buildLlmsTxt(params) {
+  const { routes, siteUrl, seoConfig, exclude = [], noindex = [], excludedGlobs = [] } = params;
+  const excludeSet = new Set(exclude);
+  const noindexSet = new Set(noindex);
+  const global = seoConfig?.global ?? {};
+  const siteName = global.siteName;
+  const summary = sanitizeLlmsText(global.defaultDescription);
+  const entries = [];
+  for (const route of routes) {
+    if (!isRouteIndexable(route, seoConfig, { exclude: excludeSet, noindex: noindexSet, excludedGlobs })) {
+      continue;
+    }
+    const loc = resolveLoc(route, seoConfig, siteUrl);
+    if (!loc) continue;
+    const resolved = resolvePageSeo(route.slug, route.path, seoConfig, route.title);
+    entries.push({
+      // title + description are site-controlled free text → sanitize per-line.
+      title: sanitizeLlmsText(resolved.title),
+      canonical: loc,
+      description: sanitizeLlmsText(resolved.description)
+    });
+  }
+  if (!siteName && entries.length === 0) return "";
+  const out = [];
+  out.push(`# ${sanitizeLlmsText(siteName) || entries[0]?.title || "Site"}`);
+  if (summary) {
+    out.push("");
+    out.push(`> ${summary}`);
+  }
+  if (entries.length > 0) {
+    out.push("");
+    out.push("## Pages");
+    out.push("");
+    for (const e of entries) {
+      const desc = e.description ? `: ${e.description}` : "";
+      out.push(`- [${e.title}](${e.canonical})${desc}`);
+    }
+  }
+  return out.join("\n") + "\n";
+}
+
+// src/seo/vitepressTransform.ts
+function defaultRelativePathToRoute(relativePath, params) {
+  let stem = (relativePath ?? "").replace(/\.md$/i, "");
+  if (params) {
+    for (const [key, value] of Object.entries(params)) {
+      if (value == null) continue;
+      stem = stem.replace(`[${key}]`, String(value));
+    }
+  }
+  if (stem === "index") return "/";
+  if (stem.endsWith("/index")) stem = stem.slice(0, -"/index".length);
+  return `/${stem}`;
+}
+function normaliseSiteUrl(siteUrl) {
+  return (siteUrl ?? "").replace(/\/$/, "");
+}
+function ldScript(obj) {
+  return ["script", { type: "application/ld+json" }, escapeJsonLd(JSON.stringify(obj))];
+}
+function buildVitePressSeoHead(pageData, options) {
+  const {
+    seoConfig,
+    pageTypeRules = [],
+    resolvePage,
+    relativePathToRoute = defaultRelativePathToRoute,
+    includeKeywords = true,
+    emitGraph = false,
+    emitBreadcrumbs = false,
+    breadcrumbTitles,
+    emitBlogPosting = false,
+    blogMatch,
+    emitFaq = false,
+    resolveReviews
+  } = options;
+  const global = seoConfig?.global ?? {};
+  const siteUrl = normaliseSiteUrl(global.siteUrl);
+  const fm = pageData.frontmatter ?? {};
+  const route = relativePathToRoute(pageData.relativePath, pageData.params);
+  const slug = route === "/" ? "home" : route.slice(1);
+  const canonical = route === "/" ? `${siteUrl}/` : `${siteUrl}${route}`;
+  const ctx = {
+    route,
+    slug,
+    canonical,
+    siteUrl,
+    frontmatter: fm,
+    global,
+    pageData
+  };
+  const resolved = resolvePageSeo(slug, route, seoConfig, fm.title);
+  const overrides = resolvePage?.(ctx) ?? {};
+  const rawTitle = overrides.title ?? pageSpecificSeoTitle(slug, seoConfig) ?? fm.title ?? resolved.title;
+  const templated = applyTitleTemplate(rawTitle, global, resolved);
+  const pageSeoDescription = seoConfig?.pages?.[slug]?.description;
+  const description = overrides.description || pageSeoDescription || fm.description || global.defaultDescription || "";
+  const keywords = overrides.keywords || seoConfig?.pages?.[slug]?.keywords || (Array.isArray(fm.tags) ? fm.tags.join(", ") : "");
+  const ogType = overrides.ogType || resolved.openGraph.type;
+  const ogImage = overrides.ogImage || resolved.openGraph.image || fm.headerImage || fm.image || global.images?.ogDefault;
+  const head = [];
+  if (includeKeywords && keywords) {
+    head.push(["meta", { name: "keywords", content: keywords }]);
+  }
+  head.push(["meta", { name: "robots", content: resolved.robots }]);
+  head.push(["link", { rel: "canonical", href: canonical }]);
+  if (global.verification?.google) {
+    head.push(["meta", { name: "google-site-verification", content: global.verification.google }]);
+  }
+  if (global.verification?.bing) {
+    head.push(["meta", { name: "msvalidate.01", content: global.verification.bing }]);
+  }
+  const pageOg = seoConfig?.pages?.[slug]?.openGraph;
+  const ogConfig = {
+    ...pageOg,
+    // Site-supplied extra OG fields (publishedTime/section/tags/…) — lower
+    // precedence than the explicit type/title/desc/image resolved below.
+    ...overrides.og,
+    type: ogType,
+    title: overrides.ogTitle || templated,
+    description: overrides.ogDescription || pageOg?.description || description,
+    ...ogImage ? { image: ogImage } : {},
+    url: canonical
+  };
+  for (const t of generateOpenGraphMeta(ogConfig, global, templated, description, canonical)) {
+    head.push(["meta", { property: t.property, content: t.content }]);
+  }
+  for (const t of generateTwitterMeta(resolved.twitter, global, templated, description)) {
+    head.push(["meta", { name: t.name, content: t.content }]);
+  }
+  let globalSchemas = resolved.schemas;
+  if (emitGraph) {
+    const reviews = resolveReviews?.(ctx);
+    const graph = buildGlobalGraph(global, { reviews });
+    if (graph.length > 0) {
+      for (const obj of graph) head.push(ldScript(obj));
+      globalSchemas = resolved.schemas.filter((s) => !graphAbsorbs(s, global));
+    }
+  }
+  for (const obj of generateJsonLd(globalSchemas, global)) {
+    head.push(ldScript(obj));
+  }
+  if (emitBreadcrumbs) {
+    const titles = breadcrumbTitles?.(ctx) ?? {};
+    const trail = breadcrumbTrailFromRoute(route, siteUrl, titles);
+    for (const obj of buildBreadcrumbList(trail)) head.push(ldScript(obj));
+  }
+  if (emitBlogPosting && (blogMatch ? blogMatch(ctx) : false)) {
+    const blogMeta = {
+      headline: typeof fm.title === "string" ? fm.title : slugToTitle(slug),
+      datePublished: typeof fm.date === "string" ? fm.date : void 0,
+      dateModified: typeof fm.lastUpdated === "string" ? fm.lastUpdated : void 0,
+      url: canonical,
+      image: typeof fm.headerImage === "string" ? fm.headerImage : typeof fm.image === "string" ? fm.image : void 0,
+      description: typeof fm.description === "string" ? fm.description : void 0
+    };
+    for (const obj of buildBlogPosting(blogMeta, siteUrl, global)) head.push(ldScript(obj));
+  }
+  if (emitFaq) {
+    const faq = Array.isArray(fm.faq) ? fm.faq : void 0;
+    for (const obj of buildFaqPage(faq)) head.push(ldScript(obj));
+  }
+  for (const rule of pageTypeRules) {
+    let matched = false;
+    try {
+      matched = rule.match(ctx);
+    } catch (err) {
+      console.warn("[dcs-seo] pageTypeRule.match threw; skipping rule:", err);
+      continue;
+    }
+    if (!matched) continue;
+    let objects = [];
+    try {
+      objects = rule.build(ctx) ?? [];
+    } catch (err) {
+      console.warn("[dcs-seo] pageTypeRule.build threw; skipping rule output:", err);
+      continue;
+    }
+    for (const obj of objects) {
+      if (obj) head.push(ldScript(obj));
+    }
+  }
+  return {
+    // Hand back the RAW title for `pageData.title`; VitePress applies its own
+    // `titleTemplate` to produce the templated <title> element.
+    title: rawTitle,
+    head,
+    description: description || void 0,
+    setPageTitle: overrides.setPageTitle ?? false
+  };
+}
+function pageSpecificSeoTitle(slug, seoConfig) {
+  return seoConfig?.pages?.[slug]?.title || void 0;
+}
+function applyTitleTemplate(rawTitle, global, resolved) {
+  if (rawTitle === resolved.title) return rawTitle;
+  if (!global.titleTemplate) return rawTitle;
+  return global.titleTemplate.replace("%s", rawTitle);
+}
+function createSeoTransformPageData(options) {
+  return function transformPageData(pageData) {
+    try {
+      const { head, title, description, setPageTitle } = buildVitePressSeoHead(pageData, options);
+      pageData.frontmatter = pageData.frontmatter ?? {};
+      const existing = pageData.frontmatter.head ?? [];
+      pageData.frontmatter.head = [...existing, ...head];
+      if (description) {
+        pageData.description = description;
+      }
+      if (setPageTitle && title) {
+        pageData.title = title;
+      }
+      if (options.debug) {
+        console.log(
+          `[dcs-seo] transformPageData ${pageData.relativePath} \u2192 +${head.length} head tag(s)` + (setPageTitle && title ? ` (title="${title}")` : "")
+        );
+      }
+    } catch (err) {
+      console.warn(
+        `[dcs-seo] createSeoTransformPageData failed for ${pageData?.relativePath}; head left unchanged:`,
+        err
+      );
+    }
+  };
+}
+
+export { AI_BOTS, absolutizeUrl, breadcrumbTrailFromRoute, buildBlogPosting, buildBreadcrumbList, buildFaqPage, buildGlobalGraph, buildHeadTags, buildLlmsTxt, buildReviewSchemaParts, buildRobotsTxt, buildSitemapXml, buildVitePressSeoHead, createSeoTransformPageData, defaultRelativePathToRoute, deriveSameAs, escapeJsonLd, filterRealFaq, filterRealReviews, findLocalBusinessSchema, findReviewItemsForPage, generateJsonLd, generateOpenGraphMeta, generateTwitterMeta, graphAbsorbs, graphIds, isLocalBusinessType, isRouteIndexable, loadPagesManifest, matchesExcludedGlob, parsePagesManifest, renderHeadTags, resolvePageSeo, slugToTitle, spliceHeadHtml, stripManagedHeadTags };
+//# sourceMappingURL=chunk-FUNIALH6.js.map
+//# sourceMappingURL=chunk-FUNIALH6.js.map