vaza-content 0.1.0

package/dist/chunk-L4VH2NSA.js

@@ -0,0 +1,1050 @@
+// src/normalize/blur-placeholder.ts
+import sharp from "sharp";
+async function generateBlurPlaceholder(imagePath) {
+  try {
+    const buffer = await sharp(imagePath).resize(8, 8, { fit: "inside" }).blur().png().toBuffer();
+    return `data:image/png;base64,${buffer.toString("base64")}`;
+  } catch {
+    return void 0;
+  }
+}
+
+// src/normalize/excerpt.ts
+function stripMarkdown(text) {
+  return text.replace(/!\[.*?\]\(.*?\)/g, "").replace(/\[([^\]]*)\]\(.*?\)/g, "$1").replace(/^#{1,6}\s+/gm, "").replace(/\*{1,3}(.*?)\*{1,3}/g, "$1").replace(/_{1,3}(.*?)_{1,3}/g, "$1").replace(/`([^`]*)`/g, "$1").replace(/^>\s+/gm, "").replace(/^[-*_]{3,}\s*$/gm, "").replace(/\s+/g, " ").trim();
+}
+function generateExcerpt(body, maxLength = 160) {
+  const clean = stripMarkdown(body);
+  if (clean.length <= maxLength) {
+    return clean;
+  }
+  const truncated = clean.slice(0, maxLength);
+  const lastSpace = truncated.lastIndexOf(" ");
+  if (lastSpace === -1) {
+    return truncated;
+  }
+  return truncated.slice(0, lastSpace);
+}
+
+// src/normalize/description.ts
+function generateDescription(body, excerpt) {
+  return excerpt ?? generateExcerpt(body);
+}
+
+// src/normalize/image-dimensions.ts
+import sharp2 from "sharp";
+async function getImageDimensions(imagePath) {
+  try {
+    const metadata = await sharp2(imagePath).metadata();
+    if (metadata.width && metadata.height) {
+      return { width: metadata.width, height: metadata.height };
+    }
+    return void 0;
+  } catch {
+    return void 0;
+  }
+}
+
+// src/normalize/word-count.ts
+function calcWordCount(body) {
+  return body.trim().split(/\s+/).filter(Boolean).length;
+}
+
+// src/normalize/reading-time.ts
+function calcReadingTime(body) {
+  const words = calcWordCount(body);
+  return Math.ceil(words / 200);
+}
+
+// src/normalize/slug.ts
+function generateSlug(title) {
+  return title.toLowerCase().replace(/\s+/g, "-").replace(/[^a-z0-9-]/g, "").replace(/-+/g, "-").replace(/^-|-$/g, "");
+}
+
+// src/normalize/toc.ts
+function toAnchorSlug(text) {
+  return text.toLowerCase().replace(/[^\w\s-]/g, "").replace(/\s+/g, "-").replace(/-+/g, "-").replace(/^-|-$/g, "");
+}
+function extractToc(body) {
+  const headingRegex = /^(#{2,3})\s+(.+)$/gm;
+  const items = [];
+  let match;
+  while ((match = headingRegex.exec(body)) !== null) {
+    const depth = match[1].length;
+    const text = match[2].trim();
+    items.push({
+      depth,
+      text,
+      slug: toAnchorSlug(text)
+    });
+  }
+  return items;
+}
+
+// src/normalize/index.ts
+function toDate(value) {
+  if (value === void 0) return void 0;
+  if (value instanceof Date) return value;
+  return new Date(value);
+}
+async function normalize(partial) {
+  const { body, title } = partial;
+  const slug = partial.slug || generateSlug(title);
+  const wordCount = partial.wordCount ?? calcWordCount(body);
+  const readingTime = partial.readingTime ?? calcReadingTime(body);
+  const excerpt = partial.excerpt ?? generateExcerpt(body);
+  const toc = partial.toc ?? extractToc(body);
+  const description = partial.description ?? generateDescription(body, excerpt);
+  const publishDate = toDate(partial.publishDate) ?? /* @__PURE__ */ new Date();
+  const updateDate = toDate(partial.updateDate);
+  const eventDate = toDate(partial.eventDate);
+  let image = partial.image ? { ...partial.image } : void 0;
+  if (image?.src) {
+    if (!image.blurDataURL) {
+      image.blurDataURL = await generateBlurPlaceholder(image.src);
+    }
+    if (!image.width || !image.height) {
+      const dims = await getImageDimensions(image.src);
+      if (dims) {
+        image.width = dims.width;
+        image.height = dims.height;
+      }
+    }
+  }
+  const entry = {
+    slug,
+    title,
+    body,
+    description,
+    publishDate,
+    readingTime,
+    wordCount,
+    excerpt,
+    toc,
+    ...updateDate && { updateDate },
+    ...image && { image },
+    ...partial.tags && { tags: partial.tags },
+    ...partial.category && { category: partial.category },
+    ...partial.author && { author: partial.author },
+    ...partial.relatedEntries && { relatedEntries: partial.relatedEntries },
+    ...partial.canonical && { canonical: partial.canonical },
+    ...partial.noindex !== void 0 && { noindex: partial.noindex },
+    ...partial.jsonLdType && { jsonLdType: partial.jsonLdType },
+    ...partial.faqs && { faqs: partial.faqs },
+    ...partial.steps && { steps: partial.steps },
+    ...partial.price && { price: partial.price },
+    ...partial.ingredients && { ingredients: partial.ingredients },
+    ...partial.cookTime && { cookTime: partial.cookTime },
+    ...eventDate && { eventDate },
+    ...partial.eventLocation && { eventLocation: partial.eventLocation }
+  };
+  return entry;
+}
+
+// src/generate/sitemap.ts
+function generateSitemap(entries, config) {
+  const siteUrl = config.site.url.replace(/\/$/, "");
+  const defaultChangeFreq = config.sitemap?.changeFrequency ?? "weekly";
+  const defaultPriority = config.sitemap?.priority ?? 0.7;
+  const sitemapEntries = [];
+  for (const [, collection] of Object.entries(config.collections)) {
+    const basePath = collection.basePath.replace(/\/$/, "");
+    for (const entry of entries) {
+      const loc = `${siteUrl}${basePath}/${entry.slug}`;
+      const lastmod = (entry.updateDate ?? entry.publishDate).toISOString();
+      const sitemapEntry = {
+        loc,
+        lastmod,
+        changefreq: defaultChangeFreq,
+        priority: defaultPriority
+      };
+      if (entry.image) {
+        sitemapEntry.images = [
+          {
+            loc: entry.image.src.startsWith("http") ? entry.image.src : `${siteUrl}${entry.image.src}`,
+            title: entry.image.alt
+          }
+        ];
+      }
+      sitemapEntries.push(sitemapEntry);
+    }
+  }
+  return sitemapEntries;
+}
+function renderSitemapXml(entries) {
+  const hasImages = entries.some((e) => e.images && e.images.length > 0);
+  const lines = [
+    '<?xml version="1.0" encoding="UTF-8"?>',
+    `<urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9"${hasImages ? ' xmlns:image="http://www.google.com/schemas/sitemap-image/1.1"' : ""}>`
+  ];
+  for (const entry of entries) {
+    lines.push("  <url>");
+    lines.push(`    <loc>${escapeXml(entry.loc)}</loc>`);
+    if (entry.lastmod) {
+      lines.push(`    <lastmod>${entry.lastmod}</lastmod>`);
+    }
+    if (entry.changefreq) {
+      lines.push(`    <changefreq>${entry.changefreq}</changefreq>`);
+    }
+    if (entry.priority !== void 0) {
+      lines.push(`    <priority>${entry.priority}</priority>`);
+    }
+    if (entry.images) {
+      for (const img of entry.images) {
+        lines.push("    <image:image>");
+        lines.push(`      <image:loc>${escapeXml(img.loc)}</image:loc>`);
+        if (img.title) {
+          lines.push(
+            `      <image:title>${escapeXml(img.title)}</image:title>`
+          );
+        }
+        lines.push("    </image:image>");
+      }
+    }
+    lines.push("  </url>");
+  }
+  lines.push("</urlset>");
+  return lines.join("\n");
+}
+function escapeXml(str) {
+  return str.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&apos;");
+}
+
+// src/generate/rss.ts
+function generateRss(entries, config) {
+  const siteUrl = config.site.url.replace(/\/$/, "");
+  const limit = config.rss?.limit ?? 20;
+  const sorted = [...entries].sort(
+    (a, b) => b.publishDate.getTime() - a.publishDate.getTime()
+  );
+  const limited = sorted.slice(0, limit);
+  const items = [];
+  for (const [, collection] of Object.entries(config.collections)) {
+    const basePath = collection.basePath.replace(/\/$/, "");
+    for (const entry of limited) {
+      const link = `${siteUrl}${basePath}/${entry.slug}`;
+      items.push({
+        title: entry.title,
+        link,
+        description: entry.description || entry.excerpt,
+        pubDate: entry.publishDate.toUTCString(),
+        guid: link,
+        author: entry.author?.name
+      });
+    }
+  }
+  return items;
+}
+function renderRssXml(items, config) {
+  const siteUrl = config.site.url.replace(/\/$/, "");
+  const lines = [
+    '<?xml version="1.0" encoding="UTF-8"?>',
+    '<rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom">',
+    "  <channel>",
+    `    <title>${escapeXml2(config.site.name)}</title>`,
+    `    <link>${escapeXml2(siteUrl)}</link>`,
+    `    <description>${escapeXml2(config.site.description ?? "")}</description>`,
+    `    <language>${config.site.language ?? "en"}</language>`,
+    `    <lastBuildDate>${(/* @__PURE__ */ new Date()).toUTCString()}</lastBuildDate>`
+  ];
+  if (config.rss?.path) {
+    lines.push(
+      `    <atom:link href="${escapeXml2(siteUrl + config.rss.path)}" rel="self" type="application/rss+xml" />`
+    );
+  }
+  for (const item of items) {
+    lines.push("    <item>");
+    lines.push(`      <title>${escapeXml2(item.title)}</title>`);
+    lines.push(`      <link>${escapeXml2(item.link)}</link>`);
+    lines.push(
+      `      <description>${escapeXml2(item.description)}</description>`
+    );
+    lines.push(`      <pubDate>${item.pubDate}</pubDate>`);
+    lines.push(`      <guid isPermaLink="true">${escapeXml2(item.guid)}</guid>`);
+    if (item.author) {
+      lines.push(`      <author>${escapeXml2(item.author)}</author>`);
+    }
+    lines.push("    </item>");
+  }
+  lines.push("  </channel>");
+  lines.push("</rss>");
+  return lines.join("\n");
+}
+function escapeXml2(str) {
+  return str.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&apos;");
+}
+
+// src/generate/json-ld/article.ts
+function generateArticleSchema(entry, site) {
+  if (!entry.title || !entry.publishDate || !entry.author) {
+    return null;
+  }
+  const schema = {
+    "@context": "https://schema.org",
+    "@type": entry.jsonLdType === "Article" ? "Article" : "BlogPosting",
+    headline: entry.title,
+    description: entry.description || entry.excerpt,
+    datePublished: entry.publishDate.toISOString(),
+    author: {
+      "@type": "Person",
+      name: entry.author.name,
+      ...entry.author.url && { url: entry.author.url }
+    },
+    publisher: {
+      "@type": "Organization",
+      name: site.name,
+      ...site.url && { url: site.url }
+    }
+  };
+  if (entry.updateDate) {
+    schema.dateModified = entry.updateDate.toISOString();
+  }
+  if (entry.image) {
+    schema.image = {
+      "@type": "ImageObject",
+      url: entry.image.src.startsWith("http") ? entry.image.src : `${site.url.replace(/\/$/, "")}${entry.image.src}`,
+      ...entry.image.width && { width: entry.image.width },
+      ...entry.image.height && { height: entry.image.height }
+    };
+  }
+  if (entry.wordCount) {
+    schema.wordCount = entry.wordCount;
+  }
+  return schema;
+}
+
+// src/generate/json-ld/faq.ts
+function generateFaqSchema(entry, _site) {
+  if (!entry.faqs || entry.faqs.length === 0) {
+    return null;
+  }
+  return {
+    "@context": "https://schema.org",
+    "@type": "FAQPage",
+    mainEntity: entry.faqs.map((faq) => ({
+      "@type": "Question",
+      name: faq.question,
+      acceptedAnswer: {
+        "@type": "Answer",
+        text: faq.answer
+      }
+    }))
+  };
+}
+
+// src/generate/breadcrumbs.ts
+function generateBreadcrumbs(slug, title, siteUrl, basePath) {
+  const url = siteUrl.replace(/\/$/, "");
+  const path = basePath.replace(/\/$/, "");
+  const items = [{ name: "Home", url: `${url}/` }];
+  if (path) {
+    const pathSegments = path.split("/").filter(Boolean);
+    let accumulated = url;
+    for (const segment of pathSegments) {
+      accumulated += `/${segment}`;
+      items.push({
+        name: segment.charAt(0).toUpperCase() + segment.slice(1),
+        url: `${accumulated}/`
+      });
+    }
+  }
+  const slugSegments = slug.split("/").filter(Boolean);
+  if (slugSegments.length > 1) {
+    let accumulated = `${url}${path}`;
+    for (let i = 0; i < slugSegments.length - 1; i++) {
+      accumulated += `/${slugSegments[i]}`;
+      const segmentName = slugSegments[i].replace(/-/g, " ").replace(/\b\w/g, (c) => c.toUpperCase());
+      items.push({
+        name: segmentName,
+        url: `${accumulated}/`
+      });
+    }
+  }
+  items.push({
+    name: title,
+    url: `${url}${path}/${slug}`
+  });
+  return items;
+}
+
+// src/generate/json-ld/breadcrumb.ts
+function generateBreadcrumbSchema(entry, site, basePath) {
+  const siteUrl = site.url.replace(/\/$/, "");
+  const crumbs = generateBreadcrumbs(entry.slug, entry.title, siteUrl, basePath);
+  return {
+    "@context": "https://schema.org",
+    "@type": "BreadcrumbList",
+    itemListElement: crumbs.map((crumb, index) => ({
+      "@type": "ListItem",
+      position: index + 1,
+      name: crumb.name,
+      item: crumb.url
+    }))
+  };
+}
+
+// src/generate/json-ld/how-to.ts
+function generateHowToSchema(entry, _site) {
+  if (!entry.steps || entry.steps.length === 0) {
+    return null;
+  }
+  return {
+    "@context": "https://schema.org",
+    "@type": "HowTo",
+    name: entry.title,
+    description: entry.description || entry.excerpt,
+    step: entry.steps.map((step, index) => ({
+      "@type": "HowToStep",
+      position: index + 1,
+      name: step.name,
+      text: step.text
+    }))
+  };
+}
+
+// src/generate/json-ld/product.ts
+function generateProductSchema(entry, site) {
+  if (!entry.price) {
+    return null;
+  }
+  const schema = {
+    "@context": "https://schema.org",
+    "@type": "Product",
+    name: entry.title,
+    description: entry.description || entry.excerpt,
+    offers: {
+      "@type": "Offer",
+      price: entry.price.amount,
+      priceCurrency: entry.price.currency,
+      availability: "https://schema.org/InStock"
+    }
+  };
+  if (entry.image) {
+    schema.image = entry.image.src.startsWith("http") ? entry.image.src : `${site.url.replace(/\/$/, "")}${entry.image.src}`;
+  }
+  return schema;
+}
+
+// src/generate/json-ld/recipe.ts
+function generateRecipeSchema(entry, _site) {
+  if (!entry.ingredients || entry.ingredients.length === 0) {
+    return null;
+  }
+  const schema = {
+    "@context": "https://schema.org",
+    "@type": "Recipe",
+    name: entry.title,
+    description: entry.description || entry.excerpt,
+    recipeIngredient: entry.ingredients
+  };
+  if (entry.cookTime) {
+    schema.cookTime = entry.cookTime;
+  }
+  if (entry.author) {
+    schema.author = {
+      "@type": "Person",
+      name: entry.author.name
+    };
+  }
+  if (entry.image) {
+    schema.image = entry.image.src;
+  }
+  return schema;
+}
+
+// src/generate/json-ld/event.ts
+function generateEventSchema(entry, site) {
+  if (!entry.eventDate) {
+    return null;
+  }
+  const schema = {
+    "@context": "https://schema.org",
+    "@type": "Event",
+    name: entry.title,
+    description: entry.description || entry.excerpt,
+    startDate: entry.eventDate.toISOString(),
+    organizer: {
+      "@type": "Organization",
+      name: site.name,
+      url: site.url
+    }
+  };
+  if (entry.eventLocation) {
+    schema.location = {
+      "@type": "Place",
+      name: entry.eventLocation
+    };
+  }
+  if (entry.image) {
+    schema.image = entry.image.src.startsWith("http") ? entry.image.src : `${site.url.replace(/\/$/, "")}${entry.image.src}`;
+  }
+  return schema;
+}
+
+// src/generate/json-ld/index.ts
+var builtinGenerators = [
+  (entry, site) => generateArticleSchema(entry, site),
+  (entry, site) => generateFaqSchema(entry, site),
+  (entry, site, basePath) => generateBreadcrumbSchema(entry, site, basePath),
+  (entry, site) => generateHowToSchema(entry, site),
+  (entry, site) => generateProductSchema(entry, site),
+  (entry, site) => generateRecipeSchema(entry, site),
+  (entry, site) => generateEventSchema(entry, site)
+];
+function generateJsonLd(entries, config) {
+  const result = {};
+  const site = config.site;
+  const collectionKeys = Object.keys(config.collections);
+  const basePath = collectionKeys.length > 0 ? config.collections[collectionKeys[0]].basePath : "";
+  const customGenerators = [];
+  if (config.jsonLd?.customSchemas) {
+    for (const [, generator] of Object.entries(config.jsonLd.customSchemas)) {
+      customGenerators.push((entry, s) => generator(entry, s));
+    }
+  }
+  const allGenerators = [...builtinGenerators, ...customGenerators];
+  for (const entry of entries) {
+    const schemas = [];
+    for (const generator of allGenerators) {
+      const schema = generator(entry, site, basePath);
+      if (schema) {
+        schemas.push(schema);
+      }
+    }
+    if (schemas.length > 0) {
+      result[entry.slug] = schemas;
+    }
+  }
+  return result;
+}
+
+// src/generate/og-images.ts
+import { writeFileSync, existsSync, mkdirSync, statSync } from "fs";
+import { join } from "path";
+async function generateOgImages(entries, config) {
+  const ogConfig = config.ogImages;
+  if (!ogConfig?.enabled) return {};
+  const outputDir = ogConfig.outputDir ?? join(process.cwd(), "public", "og");
+  const template = ogConfig.template ?? "minimal";
+  if (!existsSync(outputDir)) {
+    mkdirSync(outputDir, { recursive: true });
+  }
+  const satori = await import("satori").then((m) => m.default ?? m);
+  const { Resvg } = await import("@resvg/resvg-js");
+  const templateRenderer = ogConfig.render ?? await loadTemplate(template);
+  const results = {};
+  for (const entry of entries) {
+    const outputPath = join(outputDir, `${entry.slug}.png`);
+    if (existsSync(outputPath)) {
+      const stat = statSync(outputPath);
+      const entryDate = entry.updateDate ?? entry.publishDate;
+      if (stat.mtime >= entryDate) {
+        results[entry.slug] = outputPath;
+        continue;
+      }
+    }
+    const element = templateRenderer(entry, ogConfig);
+    const svg = await satori(element, {
+      width: 1200,
+      height: 630,
+      fonts: [
+        {
+          name: "sans-serif",
+          data: new ArrayBuffer(0),
+          weight: 400,
+          style: "normal"
+        }
+      ]
+    });
+    const resvg = new Resvg(svg, {
+      fitTo: { mode: "width", value: 1200 }
+    });
+    const pngData = resvg.render();
+    const pngBuffer = pngData.asPng();
+    const parentDir = join(outputPath, "..");
+    if (!existsSync(parentDir)) {
+      mkdirSync(parentDir, { recursive: true });
+    }
+    writeFileSync(outputPath, pngBuffer);
+    results[entry.slug] = outputPath;
+  }
+  return results;
+}
+async function loadTemplate(template) {
+  switch (template) {
+    case "blog": {
+      const mod = await import("./blog-7EEJJG26.js");
+      return mod.blogTemplate;
+    }
+    case "product": {
+      const mod = await import("./product-NCUW3U72.js");
+      return mod.productTemplate;
+    }
+    case "dark": {
+      const mod = await import("./dark-6E36AKLN.js");
+      return mod.darkTemplate;
+    }
+    case "minimal":
+    default: {
+      const mod = await import("./minimal-D2PRAVG6.js");
+      return mod.minimalTemplate;
+    }
+  }
+}
+
+// src/generate/taxonomy.ts
+function generateTaxonomy(entries, _config) {
+  const tags = {};
+  const categories = {};
+  for (const entry of entries) {
+    if (entry.tags) {
+      for (const tag of entry.tags) {
+        const normalized = tag.toLowerCase().trim();
+        if (!tags[normalized]) {
+          tags[normalized] = [];
+        }
+        tags[normalized].push(entry.slug);
+      }
+    }
+    if (entry.category) {
+      const normalized = entry.category.toLowerCase().trim();
+      if (!categories[normalized]) {
+        categories[normalized] = [];
+      }
+      categories[normalized].push(entry.slug);
+    }
+  }
+  return { tags, categories };
+}
+
+// src/generate/redirects.ts
+import { execSync } from "child_process";
+import { readFileSync, writeFileSync as writeFileSync2, mkdirSync as mkdirSync2, existsSync as existsSync2 } from "fs";
+import { join as join2, dirname } from "path";
+var MANIFEST_DIR = ".vaza-content";
+var MANIFEST_FILE = "slugs.json";
+async function detectRedirects(entries, config) {
+  const strategy = config.redirects?.strategy ?? "both";
+  const redirects = [];
+  if (strategy === "git" || strategy === "both") {
+    const gitRedirects = detectGitRenames();
+    redirects.push(...gitRedirects);
+  }
+  if (strategy === "manifest" || strategy === "both") {
+    const manifestRedirects = detectManifestChanges(entries);
+    redirects.push(...manifestRedirects);
+  }
+  const seen = /* @__PURE__ */ new Set();
+  const unique = [];
+  for (const r of redirects) {
+    if (!seen.has(r.from)) {
+      seen.add(r.from);
+      unique.push(r);
+    }
+  }
+  return unique;
+}
+function detectGitRenames() {
+  const redirects = [];
+  try {
+    const output = execSync(
+      "git log --all --diff-filter=R --summary --format=",
+      {
+        encoding: "utf-8",
+        timeout: 1e4
+      }
+    );
+    const renameRegex = /rename\s+(.+?)\{(.+?)\s*=>\s*(.+?)\}\s*\((\d+)%\)/g;
+    const simpleRenameRegex = /rename\s+(.+?)\s+=>\s+(.+?)\s+\((\d+)%\)/g;
+    let match;
+    match = renameRegex.exec(output);
+    while (match) {
+      const prefix = match[1];
+      const oldPart = match[2].trim();
+      const newPart = match[3].trim();
+      const oldPath = `${prefix}${oldPart}`;
+      const newPath = `${prefix}${newPart}`;
+      const oldSlug = extractSlug(oldPath);
+      const newSlug = extractSlug(newPath);
+      if (oldSlug && newSlug && oldSlug !== newSlug) {
+        redirects.push({
+          from: oldSlug,
+          to: newSlug,
+          status: 301
+        });
+      }
+      match = renameRegex.exec(output);
+    }
+    match = simpleRenameRegex.exec(output);
+    while (match) {
+      const oldPath = match[1].trim();
+      const newPath = match[2].trim();
+      const oldSlug = extractSlug(oldPath);
+      const newSlug = extractSlug(newPath);
+      if (oldSlug && newSlug && oldSlug !== newSlug) {
+        redirects.push({
+          from: oldSlug,
+          to: newSlug,
+          status: 301
+        });
+      }
+      match = simpleRenameRegex.exec(output);
+    }
+  } catch {
+  }
+  return redirects;
+}
+function detectManifestChanges(entries) {
+  const redirects = [];
+  const manifestPath = join2(process.cwd(), MANIFEST_DIR, MANIFEST_FILE);
+  const currentSlugs = entries.map((e) => e.slug).sort();
+  if (existsSync2(manifestPath)) {
+    try {
+      const raw = readFileSync(manifestPath, "utf-8");
+      const previousSlugs = JSON.parse(raw);
+      const currentSet = new Set(currentSlugs);
+      const removedSlugs = previousSlugs.filter((s) => !currentSet.has(s));
+      const previousSet = new Set(previousSlugs);
+      const addedSlugs = currentSlugs.filter((s) => !previousSet.has(s));
+      if (removedSlugs.length === 1 && addedSlugs.length === 1) {
+        redirects.push({
+          from: removedSlugs[0],
+          to: addedSlugs[0],
+          status: 301
+        });
+      }
+    } catch {
+    }
+  }
+  const dir = dirname(manifestPath);
+  if (!existsSync2(dir)) {
+    mkdirSync2(dir, { recursive: true });
+  }
+  writeFileSync2(manifestPath, JSON.stringify(currentSlugs, null, 2));
+  return redirects;
+}
+function extractSlug(filePath) {
+  const name = filePath.split("/").pop();
+  if (!name) return null;
+  return name.replace(/\.(mdx?|tsx?|jsx?)$/, "");
+}
+
+// src/integrity/alt-text.ts
+function checkAltText(entries, severity = "warn") {
+  const issues = [];
+  const emptyAltRegex = /!\[\s*\]\([^)]+\)/g;
+  for (const entry of entries) {
+    if (entry.image && !entry.image.alt?.trim()) {
+      issues.push({
+        type: "missing-alt-text",
+        severity,
+        message: `Featured image is missing alt text (src: "${entry.image.src}")`,
+        slug: entry.slug
+      });
+    }
+    emptyAltRegex.lastIndex = 0;
+    let match;
+    while ((match = emptyAltRegex.exec(entry.body)) !== null) {
+      issues.push({
+        type: "missing-alt-text",
+        severity,
+        message: `Markdown image with empty alt text: ${match[0]}`,
+        slug: entry.slug
+      });
+    }
+  }
+  return issues;
+}
+
+// src/integrity/broken-links.ts
+function checkBrokenLinks(entries, severity = "warn") {
+  const slugs = new Set(entries.map((e) => e.slug));
+  const issues = [];
+  const linkRegex = /\[([^\]]*)\]\(\/([^)]*)\)/g;
+  for (const entry of entries) {
+    let match;
+    linkRegex.lastIndex = 0;
+    while ((match = linkRegex.exec(entry.body)) !== null) {
+      const rawPath = match[2];
+      const cleanPath = rawPath.split(/[?#]/)[0].replace(/\/$/, "");
+      const segments = cleanPath.split("/").filter(Boolean);
+      const lastSegment = segments[segments.length - 1];
+      const found = slugs.has(cleanPath) || lastSegment !== void 0 && slugs.has(lastSegment);
+      if (!found) {
+        issues.push({
+          type: "broken-link",
+          severity,
+          message: `Broken internal link to "/${rawPath}"`,
+          slug: entry.slug
+        });
+      }
+    }
+  }
+  return issues;
+}
+
+// src/integrity/duplicate-content.ts
+function normalize2(title) {
+  return title.toLowerCase().replace(/[^\w\s]/g, "").replace(/\s+/g, " ").trim();
+}
+function checkDuplicateContent(entries, severity = "warn") {
+  const issues = [];
+  const seen = /* @__PURE__ */ new Map();
+  for (const entry of entries) {
+    const key = normalize2(entry.title);
+    if (!key) continue;
+    const existing = seen.get(key);
+    if (existing) {
+      existing.push(entry.slug);
+    } else {
+      seen.set(key, [entry.slug]);
+    }
+  }
+  for (const [, slugs] of seen) {
+    if (slugs.length > 1) {
+      issues.push({
+        type: "duplicate-content",
+        severity,
+        message: `Entries have near-identical titles: ${slugs.join(", ")}`,
+        slug: slugs[0]
+      });
+    }
+  }
+  return issues;
+}
+
+// src/integrity/duplicate-slugs.ts
+function checkDuplicateSlugs(entries, severity = "error") {
+  const issues = [];
+  const seen = /* @__PURE__ */ new Map();
+  for (const entry of entries) {
+    const count = seen.get(entry.slug) ?? 0;
+    seen.set(entry.slug, count + 1);
+  }
+  for (const [slug, count] of seen) {
+    if (count > 1) {
+      issues.push({
+        type: "duplicate-slug",
+        severity,
+        message: `Slug "${slug}" is used by ${count} entries`,
+        slug
+      });
+    }
+  }
+  return issues;
+}
+
+// src/integrity/freshness.ts
+function parseMaxAge(maxAge) {
+  const match = maxAge.match(/^(\d+)(d|m|y)$/);
+  if (!match) {
+    throw new Error(
+      `Invalid maxAge format: "${maxAge}". Use "90d", "6m", or "1y".`
+    );
+  }
+  const value = Number.parseInt(match[1], 10);
+  const unit = match[2];
+  const MS_PER_DAY = 864e5;
+  switch (unit) {
+    case "d":
+      return value * MS_PER_DAY;
+    case "m":
+      return value * 30 * MS_PER_DAY;
+    case "y":
+      return value * 365 * MS_PER_DAY;
+    default:
+      return value * MS_PER_DAY;
+  }
+}
+function checkFreshness(entries, config) {
+  const issues = [];
+  const maxAgeStr = config.freshness?.maxAge ?? "6m";
+  const severity = config.freshness?.severity ?? "warn";
+  if (severity === "off") return issues;
+  const maxAgeMs = parseMaxAge(maxAgeStr);
+  const now = Date.now();
+  for (const entry of entries) {
+    const lastDate = entry.updateDate ?? entry.publishDate;
+    const age = now - lastDate.getTime();
+    if (age > maxAgeMs) {
+      const daysOld = Math.floor(age / 864e5);
+      issues.push({
+        type: "stale-content",
+        severity,
+        message: `Content is ${daysOld} days old (max age: ${maxAgeStr})`,
+        slug: entry.slug
+      });
+    }
+  }
+  return issues;
+}
+
+// src/integrity/meta-length.ts
+function checkMetaLength(entries, config) {
+  const issues = [];
+  const titleMax = config.metaTitleLength?.max ?? 60;
+  const titleSeverity = config.metaTitleLength?.severity ?? "warn";
+  const descMax = config.metaDescriptionLength?.max ?? 120;
+  const descSeverity = config.metaDescriptionLength?.severity ?? "warn";
+  for (const entry of entries) {
+    if (titleSeverity !== "off" && entry.title.length > titleMax) {
+      issues.push({
+        type: "meta-title-length",
+        severity: titleSeverity,
+        message: `Title is ${entry.title.length} chars (max ${titleMax}): "${entry.title}"`,
+        slug: entry.slug
+      });
+    }
+    if (descSeverity !== "off" && entry.description.length > descMax) {
+      issues.push({
+        type: "meta-description-length",
+        severity: descSeverity,
+        message: `Description is ${entry.description.length} chars (max ${descMax})`,
+        slug: entry.slug
+      });
+    }
+  }
+  return issues;
+}
+
+// src/integrity/orphan-pages.ts
+function checkOrphanPages(entries, severity = "warn") {
+  const issues = [];
+  const linkedSlugs = /* @__PURE__ */ new Set();
+  const linkRegex = /\[([^\]]*)\]\(\/([^)]*)\)/g;
+  for (const entry of entries) {
+    linkRegex.lastIndex = 0;
+    let match;
+    while ((match = linkRegex.exec(entry.body)) !== null) {
+      const rawPath = match[2];
+      const cleanPath = rawPath.split(/[?#]/)[0].replace(/\/$/, "");
+      const segments = cleanPath.split("/").filter(Boolean);
+      const lastSegment = segments[segments.length - 1];
+      linkedSlugs.add(cleanPath);
+      if (lastSegment !== void 0) {
+        linkedSlugs.add(lastSegment);
+      }
+    }
+  }
+  for (const entry of entries) {
+    if (!linkedSlugs.has(entry.slug)) {
+      issues.push({
+        type: "orphan-page",
+        severity,
+        message: `No other entry links to "${entry.slug}"`,
+        slug: entry.slug
+      });
+    }
+  }
+  return issues;
+}
+
+// src/integrity/index.ts
+function checkIntegrity(entries, config) {
+  const ic = config.integrity ?? {};
+  const issues = [];
+  if (ic.brokenLinks !== "off") {
+    issues.push(...checkBrokenLinks(entries, ic.brokenLinks ?? "warn"));
+  }
+  const titleOff = ic.metaTitleLength?.severity === "off";
+  const descOff = ic.metaDescriptionLength?.severity === "off";
+  if (!titleOff || !descOff) {
+    issues.push(...checkMetaLength(entries, ic));
+  }
+  if (ic.altText !== "off") {
+    issues.push(...checkAltText(entries, ic.altText ?? "warn"));
+  }
+  if (ic.duplicateSlugs !== "off") {
+    issues.push(...checkDuplicateSlugs(entries, ic.duplicateSlugs ?? "error"));
+  }
+  if (ic.duplicateContent !== "off") {
+    issues.push(
+      ...checkDuplicateContent(entries, ic.duplicateContent ?? "warn")
+    );
+  }
+  if (ic.orphanPages !== "off") {
+    issues.push(...checkOrphanPages(entries, ic.orphanPages ?? "warn"));
+  }
+  if (ic.freshness?.severity !== "off") {
+    issues.push(...checkFreshness(entries, ic));
+  }
+  let errors = 0;
+  let warnings = 0;
+  for (const issue of issues) {
+    if (issue.severity === "error") errors++;
+    else if (issue.severity === "warn") warnings++;
+  }
+  return { issues, summary: { errors, warnings } };
+}
+
+// src/process.ts
+async function processCollections(config) {
+  const allEntries = [];
+  for (const [name, collection] of Object.entries(config.collections)) {
+    const rawEntries = await collection.entries();
+    const partialEntries = rawEntries.map(collection.map);
+    for (const partial of partialEntries) {
+      const normalized = await normalize(partial);
+      allEntries.push(normalized);
+    }
+  }
+  const [sitemap, rss, jsonLd, ogImagePaths, taxonomy, redirects, integrity] = await Promise.all([
+    config.sitemap?.enabled !== false ? generateSitemap(allEntries, config) : Promise.resolve([]),
+    config.rss?.enabled !== false ? generateRss(allEntries, config) : Promise.resolve([]),
+    config.jsonLd?.enabled !== false ? generateJsonLd(allEntries, config) : Promise.resolve({}),
+    config.ogImages?.enabled !== false ? generateOgImages(allEntries, config) : Promise.resolve({}),
+    config.taxonomy?.enabled !== false ? generateTaxonomy(allEntries, config) : Promise.resolve({ tags: {}, categories: {} }),
+    config.redirects?.enabled !== false ? detectRedirects(allEntries, config) : Promise.resolve([]),
+    checkIntegrity(allEntries, config)
+  ]);
+  if (integrity.summary.errors > 0 || integrity.summary.warnings > 0) {
+    printIntegrityReport(integrity);
+  }
+  return {
+    entries: allEntries,
+    sitemap,
+    rss,
+    jsonLd,
+    ogImagePaths,
+    taxonomy,
+    redirects,
+    integrity
+  };
+}
+function printIntegrityReport(report) {
+  const { issues, summary } = report;
+  console.log("\n[vaza-content] Integrity Report");
+  console.log("\u2500".repeat(50));
+  for (const issue of issues) {
+    const icon = issue.severity === "error" ? "\u2716" : "\u26A0";
+    const prefix = issue.severity === "error" ? "ERROR" : "WARN";
+    const location = issue.slug ? ` (${issue.slug})` : "";
+    console.log(`  ${icon} [${prefix}] ${issue.message}${location}`);
+  }
+  console.log("\u2500".repeat(50));
+  console.log(
+    `  ${summary.errors} error(s), ${summary.warnings} warning(s)
+`
+  );
+  if (summary.errors > 0) {
+    throw new Error(
+      `[vaza-content] Build failed: ${summary.errors} integrity error(s) found.`
+    );
+  }
+}
+
+export {
+  normalize,
+  generateSitemap,
+  renderSitemapXml,
+  generateRss,
+  renderRssXml,
+  generateBreadcrumbs,
+  generateJsonLd,
+  generateOgImages,
+  generateTaxonomy,
+  detectRedirects,
+  checkIntegrity,
+  processCollections
+};
+//# sourceMappingURL=chunk-L4VH2NSA.js.map