@pas7/llm-seo 0.1.6

package/dist/index.js

@@ -0,0 +1,1909 @@
+import * as fs from 'fs/promises';
+import { readFile, readdir } from 'fs/promises';
+import { z } from 'zod';
+import { existsSync } from 'fs';
+import { join } from 'path';
+
+// src/core/normalize/url.ts
+function normalizePath(path, preserveTrailingSlash = false) {
+  if (!path || path === "/") {
+    return "/";
+  }
+  const hadTrailingSlash = path.endsWith("/") && path !== "/";
+  let normalized = path.startsWith("/") ? path : `/${path}`;
+  normalized = normalized.replace(/\/{2,}/g, "/");
+  const segments = [];
+  const parts = normalized.split("/");
+  for (const part of parts) {
+    if (part === "." || part === "") {
+      continue;
+    } else if (part === "..") {
+      if (segments.length > 0) {
+        segments.pop();
+      }
+    } else {
+      segments.push(part);
+    }
+  }
+  let result = "/" + segments.join("/");
+  if (preserveTrailingSlash && hadTrailingSlash && result !== "/") {
+    result += "/";
+  }
+  return result;
+}
+function joinUrlParts(...parts) {
+  if (parts.length === 0) {
+    return "/";
+  }
+  const filteredParts = parts.filter((part) => part.length > 0);
+  if (filteredParts.length === 0) {
+    return "/";
+  }
+  const joined = filteredParts.map((part) => {
+    let p = part.replace(/^\/+/, "");
+    p = p.replace(/\/+$/, "");
+    return p;
+  }).filter((p) => p.length > 0).join("/");
+  return joined.length > 0 ? `/${joined}` : "/";
+}
+function normalizeUrl(options) {
+  const { baseUrl, path, trailingSlash, stripQuery = true, stripHash = true } = options;
+  let parsedBase;
+  try {
+    parsedBase = new URL(baseUrl);
+  } catch {
+    throw new TypeError(`Invalid baseUrl: ${baseUrl}`);
+  }
+  const shouldPreserveTrailingSlash = trailingSlash === "preserve";
+  const normalizedPath = normalizePath(path, shouldPreserveTrailingSlash);
+  let finalPath = normalizedPath;
+  if (trailingSlash === "always") {
+    if (!finalPath.endsWith("/")) {
+      finalPath = `${finalPath}/`;
+    }
+  } else if (trailingSlash === "never") {
+    if (finalPath !== "/" && finalPath.endsWith("/")) {
+      finalPath = finalPath.slice(0, -1);
+    }
+  }
+  const protocol = parsedBase.protocol.toLowerCase();
+  let hostname = parsedBase.hostname.toLowerCase();
+  let port = parsedBase.port;
+  if (port) {
+    const isDefaultPort = protocol === "http:" && port === "80" || protocol === "https:" && port === "443";
+    if (!isDefaultPort) {
+      hostname = `${hostname}:${port}`;
+    }
+  }
+  let fullUrl = `${protocol}//${hostname}${finalPath}`;
+  if (!stripQuery && parsedBase.search) {
+    fullUrl += parsedBase.search;
+  }
+  if (!stripHash && parsedBase.hash) {
+    fullUrl += parsedBase.hash;
+  }
+  return fullUrl;
+}
+function sortUrls(urls) {
+  return [...urls].sort((a, b) => a.localeCompare(b));
+}
+
+// src/core/normalize/sort.ts
+function compareStrings(a, b) {
+  return a.localeCompare(b, "en", { sensitivity: "case", numeric: true });
+}
+function sortStrings(items) {
+  return [...items].sort(compareStrings);
+}
+function sortBy(items, keyFn) {
+  return [...items].sort((a, b) => compareStrings(keyFn(a), keyFn(b)));
+}
+function stableSortStrings(items) {
+  return [...items].sort((a, b) => a.localeCompare(b, "en", { sensitivity: "case", numeric: true }));
+}
+function countPathSegments(url) {
+  try {
+    const parsed = new URL(url);
+    const path = parsed.pathname.replace(/^\/+/, "").replace(/\/+$/, "");
+    if (!path) return 0;
+    return path.split("/").length;
+  } catch {
+    const cleaned = url.replace(/^\/+/, "").replace(/\/+$/, "");
+    if (!cleaned) return 0;
+    return cleaned.split("/").length;
+  }
+}
+function sortUrlsByPath(urls) {
+  return [...urls].sort((a, b) => {
+    const segmentsA = countPathSegments(a);
+    const segmentsB = countPathSegments(b);
+    if (segmentsA !== segmentsB) {
+      return segmentsA - segmentsB;
+    }
+    return a.localeCompare(b, "en", { sensitivity: "case", numeric: true });
+  });
+}
+
+// src/core/normalize/text.ts
+function normalizeWhitespace(text) {
+  return text.replace(/\s+/g, " ").trim();
+}
+function normalizeLineEndings(text, lineEndings) {
+  const normalized = text.replace(/\r\n/g, "\n").replace(/\r/g, "\n");
+  return lineEndings === "crlf" ? normalized.replace(/\n/g, "\r\n") : normalized;
+}
+function normalizeLineWhitespace(text) {
+  const lines = text.split(/\r?\n/);
+  return lines.map((line) => line.trimEnd().replace(/[ \t]+/g, (match) => " ".repeat(match.length === 0 ? 0 : match.length))).map((line) => line.replace(/  +/g, " ")).join("\n");
+}
+function normalizeSeoText(text, maxLength) {
+  const normalized = normalizeWhitespace(text);
+  if (normalized.length <= maxLength) {
+    return normalized;
+  }
+  const truncated = normalized.slice(0, maxLength);
+  const lastSpace = truncated.lastIndexOf(" ");
+  return lastSpace > 0 ? `${truncated.slice(0, lastSpace)}\u2026` : `${truncated.slice(0, -1)}\u2026`;
+}
+
+// src/core/canonical/locale.ts
+function selectCanonicalLocale(options) {
+  const { defaultLocale, availableLocales } = options;
+  if (!availableLocales || availableLocales.length === 0) {
+    return null;
+  }
+  const validLocales = availableLocales.filter(
+    (locale) => typeof locale === "string" && locale.length > 0
+  );
+  if (validLocales.length === 0) {
+    return null;
+  }
+  if (defaultLocale && validLocales.includes(defaultLocale)) {
+    return defaultLocale;
+  }
+  const sorted = stableSortStrings(validLocales);
+  return sorted[0] ?? null;
+}
+function localizePath(path, locale, config) {
+  const normalizedPath = path.startsWith("/") ? path : `/${path}`;
+  if (locale === config.default && config.strategy === "subdirectory") {
+    return normalizedPath;
+  }
+  if (config.strategy === "subdirectory") {
+    return `/${locale}${normalizedPath === "/" ? "" : normalizedPath}`;
+  }
+  return normalizedPath;
+}
+function extractLocaleFromPath(path, config) {
+  if (config.strategy !== "subdirectory") {
+    return [config.default, path];
+  }
+  const match = path.match(/^\/([a-z]{2}(?:-[A-Z]{2})?)(\/|$)/);
+  if (match?.[1] && config.supported.includes(match[1])) {
+    const locale = match[1];
+    const remainingPath = path.slice(locale.length + 1) || "/";
+    return [locale, remainingPath];
+  }
+  return [config.default, path];
+}
+function generateAlternateUrls(baseUrl, path, config) {
+  const urlMap = /* @__PURE__ */ new Map();
+  for (const locale of config.supported) {
+    const localePath = localizePath(path, locale, config);
+    const fullUrl = `${baseUrl}${localePath}`;
+    urlMap.set(locale, fullUrl);
+  }
+  return urlMap;
+}
+
+// src/core/canonical/canonical-from-manifest.ts
+function generateCanonicalUrl(manifest, path, options = {}) {
+  const { trailingSlash = false, lowercase = true } = options;
+  const basePath = path.startsWith("/") ? path : `/${path}`;
+  const normalizedPath = trailingSlash ? `${basePath}${basePath.endsWith("/") ? "" : "/"}` : basePath.replace(/\/+$/, "") || "/";
+  const fullUrl = `${manifest.baseUrl}${normalizedPath}`;
+  return lowercase ? fullUrl.toLowerCase() : fullUrl;
+}
+function extractCanonicalUrls(manifest, options = {}) {
+  return manifest.pages.map((page) => generateCanonicalUrl(manifest, page.path, options));
+}
+function dedupeUrls(urls) {
+  return [...new Set(urls)];
+}
+function buildLocalePrefix(locale, strategy, defaultLocale) {
+  if (strategy === "none") {
+    return "";
+  }
+  if (strategy === "subdomain") {
+    return "";
+  }
+  if (strategy === "prefix" && locale === defaultLocale) {
+    return "";
+  }
+  return `/${locale}`;
+}
+function buildBaseUrlWithSubdomain(baseUrl, locale, strategy, defaultLocale) {
+  if (strategy !== "subdomain" || locale === defaultLocale) {
+    return baseUrl;
+  }
+  try {
+    const parsed = new URL(baseUrl);
+    return `${parsed.protocol}//${locale}.${parsed.host}`;
+  } catch {
+    return baseUrl;
+  }
+}
+function createCanonicalUrlForItem(item, options) {
+  const { baseUrl, routePrefix, defaultLocale, trailingSlash, localeStrategy } = options;
+  if (item.canonicalOverride && typeof item.canonicalOverride === "string") {
+    return item.canonicalOverride;
+  }
+  const availableLocales = item.locales ?? [defaultLocale];
+  const canonicalLocale = selectCanonicalLocale({
+    defaultLocale,
+    availableLocales
+  });
+  const locale = canonicalLocale ?? defaultLocale;
+  const localePrefix = buildLocalePrefix(locale, localeStrategy, defaultLocale);
+  const effectiveBaseUrl = buildBaseUrlWithSubdomain(baseUrl, locale, localeStrategy, defaultLocale);
+  const parts = [];
+  if (localePrefix) {
+    parts.push(localePrefix);
+  }
+  if (routePrefix) {
+    parts.push(routePrefix);
+  }
+  parts.push(item.slug);
+  const fullPath = joinUrlParts(...parts);
+  return normalizeUrl({
+    baseUrl: effectiveBaseUrl,
+    path: fullPath,
+    trailingSlash,
+    stripQuery: true,
+    stripHash: true
+  });
+}
+function createCanonicalUrlsFromManifest(options) {
+  const { items } = options;
+  if (!items || items.length === 0) {
+    return [];
+  }
+  const urls = items.map((item) => createCanonicalUrlForItem(item, options));
+  const deduped = dedupeUrls(urls);
+  return sortUrlsByPath(deduped);
+}
+
+// src/core/generate/llms-txt.ts
+function createLlmsTxt(options) {
+  const { config, canonicalUrls } = options;
+  const lineEndings = config.format?.lineEndings ?? "lf";
+  const lines = [];
+  lines.push(`# ${config.brand.name}`);
+  lines.push("");
+  if (config.brand.tagline) {
+    lines.push(`> ${config.brand.tagline}`);
+    lines.push("");
+  }
+  if (config.brand.description) {
+    lines.push(config.brand.description);
+    lines.push("");
+  }
+  const hubs = config.sections?.hubs ?? [];
+  if (hubs.length > 0) {
+    lines.push("## Sections");
+    lines.push("");
+    const sortedHubs = sortStrings(hubs);
+    for (const hub of sortedHubs) {
+      const hubLabel = getHubLabel(hub);
+      lines.push(`- [${hub}](${hub}) - ${hubLabel}`);
+    }
+    lines.push("");
+  }
+  if (canonicalUrls.length > 0) {
+    lines.push("## URLs");
+    lines.push("");
+    const sortedUrls = sortStrings(canonicalUrls);
+    for (const url of sortedUrls) {
+      lines.push(`- ${url}`);
+    }
+    lines.push("");
+  }
+  const hasPolicies = config.policy?.geoPolicy || config.policy?.citationRules || config.policy?.restrictedClaims;
+  if (hasPolicies) {
+    lines.push("## Policies");
+    lines.push("");
+    if (config.policy?.geoPolicy) {
+      lines.push(`- GEO: ${config.policy.geoPolicy}`);
+    }
+    if (config.policy?.citationRules) {
+      lines.push(`- Citations: ${config.policy.citationRules}`);
+    }
+    if (config.policy?.restrictedClaims) {
+      const status = config.policy.restrictedClaims.enable ? "Enabled" : "Disabled";
+      lines.push(`- Restricted Claims: ${status}`);
+    }
+    lines.push("");
+  }
+  const hasContact = config.contact?.email || config.contact?.social || config.contact?.phone;
+  const hasBooking = config.booking?.url;
+  if (hasContact || hasBooking) {
+    lines.push("## Contact");
+    lines.push("");
+    if (config.contact?.email) {
+      lines.push(`- Email: ${config.contact.email}`);
+    }
+    if (config.contact?.phone) {
+      lines.push(`- Phone: ${config.contact.phone}`);
+    }
+    if (config.contact?.social) {
+      if (config.contact.social.twitter) {
+        lines.push(`- Twitter: ${config.contact.social.twitter}`);
+      }
+      if (config.contact.social.linkedin) {
+        lines.push(`- LinkedIn: ${config.contact.social.linkedin}`);
+      }
+      if (config.contact.social.github) {
+        lines.push(`- GitHub: ${config.contact.social.github}`);
+      }
+    }
+    if (config.booking?.url) {
+      const label = config.booking.label ?? "Book consultation";
+      lines.push(`- Booking: ${config.booking.url} (${label})`);
+    }
+    lines.push("");
+  }
+  const hasMachineHints = config.machineHints?.robots || config.machineHints?.sitemap || config.machineHints?.llmsTxt || config.machineHints?.llmsFullTxt;
+  if (hasMachineHints) {
+    lines.push("## Machine Hints");
+    lines.push("");
+    if (config.machineHints?.robots) {
+      lines.push(`- robots.txt: ${config.machineHints.robots}`);
+    }
+    if (config.machineHints?.sitemap) {
+      lines.push(`- sitemap.xml: ${config.machineHints.sitemap}`);
+    }
+    if (config.machineHints?.llmsTxt) {
+      lines.push(`- llms.txt: ${config.machineHints.llmsTxt}`);
+    }
+    if (config.machineHints?.llmsFullTxt) {
+      lines.push(`- llms-full.txt: ${config.machineHints.llmsFullTxt}`);
+    }
+    lines.push("");
+  }
+  let content = lines.join("\n");
+  content = normalizeLineWhitespace(content);
+  content = normalizeLineEndings(content, lineEndings);
+  const finalLines = content.split(lineEndings === "crlf" ? "\r\n" : "\n");
+  return {
+    content,
+    byteSize: Buffer.byteLength(content, "utf-8"),
+    lineCount: finalLines.length
+  };
+}
+function getHubLabel(hub) {
+  const labels = {
+    "/services": "Services overview",
+    "/blog": "Blog posts",
+    "/projects": "Our projects",
+    "/cases": "Case studies",
+    "/contact": "Contact us",
+    "/about": "About us",
+    "/products": "Products",
+    "/docs": "Documentation",
+    "/faq": "Frequently asked questions",
+    "/pricing": "Pricing information",
+    "/team": "Our team",
+    "/careers": "Career opportunities",
+    "/news": "News and updates",
+    "/resources": "Resources",
+    "/support": "Support center"
+  };
+  return labels[hub] ?? formatHubLabel(hub);
+}
+function formatHubLabel(hub) {
+  const clean = hub.replace(/^\//, "");
+  return clean.replace(/[-_]/g, " ").replace(/\b\w/g, (char) => char.toUpperCase());
+}
+function generateLlmsTxt(manifest, _options) {
+  const canonicalUrls = manifest.pages.map((page) => `${manifest.baseUrl}${page.path}`);
+  const config = {
+    site: { baseUrl: manifest.baseUrl },
+    brand: {
+      name: manifest.title,
+      locales: ["en"],
+      ...manifest.description && { description: manifest.description }
+    },
+    manifests: {},
+    output: {
+      paths: {
+        llmsTxt: "public/llms.txt",
+        llmsFullTxt: "public/llms-full.txt"
+      }
+    }
+  };
+  return createLlmsTxt({ config, canonicalUrls }).content;
+}
+
+// src/core/generate/llms-full-txt.ts
+function createLlmsFullTxt(options) {
+  const { config, canonicalUrls, manifestItems } = options;
+  const lineEndings = config.format?.lineEndings ?? "lf";
+  const lines = [];
+  lines.push(`# ${config.brand.name} - Full LLM Context`);
+  lines.push("");
+  if (config.brand.tagline) {
+    lines.push(`> ${config.brand.tagline}`);
+    lines.push("");
+  }
+  if (config.brand.description) {
+    lines.push(config.brand.description);
+    lines.push("");
+  }
+  if (config.brand.org) {
+    lines.push(`Organization: ${config.brand.org}`);
+  }
+  lines.push(`Locales: ${config.brand.locales.join(", ")}`);
+  lines.push("");
+  if (canonicalUrls.length > 0) {
+    lines.push("## All Canonical URLs");
+    lines.push("");
+    const sortedUrls = sortStrings(canonicalUrls);
+    for (const url of sortedUrls) {
+      lines.push(`- ${url}`);
+    }
+    lines.push("");
+  }
+  const hasPolicies = config.policy?.geoPolicy || config.policy?.citationRules || config.policy?.restrictedClaims;
+  if (hasPolicies) {
+    lines.push("## Policies");
+    lines.push("");
+    if (config.policy?.geoPolicy) {
+      lines.push("### GEO Policy");
+      lines.push(config.policy.geoPolicy);
+      lines.push("");
+    }
+    if (config.policy?.citationRules) {
+      lines.push("### Citation Rules");
+      lines.push(config.policy.citationRules);
+      lines.push("");
+    }
+    if (config.policy?.restrictedClaims) {
+      lines.push("### Restricted Claims");
+      const status = config.policy.restrictedClaims.enable ? "Enabled" : "Disabled";
+      lines.push(`Status: ${status}`);
+      if (config.policy.restrictedClaims.forbidden && config.policy.restrictedClaims.forbidden.length > 0) {
+        lines.push(`Forbidden terms: ${config.policy.restrictedClaims.forbidden.join(", ")}`);
+      }
+      if (config.policy.restrictedClaims.whitelist && config.policy.restrictedClaims.whitelist.length > 0) {
+        lines.push(`Exceptions: ${config.policy.restrictedClaims.whitelist.join(", ")}`);
+      }
+      lines.push("");
+    }
+  }
+  const hasSocial = config.contact?.social?.twitter || config.contact?.social?.linkedin || config.contact?.social?.github;
+  const hasBooking = config.booking?.url;
+  if (hasSocial || hasBooking) {
+    lines.push("## Social & Booking");
+    lines.push("");
+    if (config.contact?.social?.twitter) {
+      lines.push(`- Twitter: ${config.contact.social.twitter}`);
+    }
+    if (config.contact?.social?.linkedin) {
+      lines.push(`- LinkedIn: ${config.contact.social.linkedin}`);
+    }
+    if (config.contact?.social?.github) {
+      lines.push(`- GitHub: ${config.contact.social.github}`);
+    }
+    if (config.booking?.url) {
+      const label = config.booking.label ?? "Book consultation";
+      lines.push(`- Booking: ${config.booking.url} (${label})`);
+    }
+    lines.push("");
+  }
+  const hasMachineHints = config.machineHints?.robots || config.machineHints?.sitemap || config.machineHints?.llmsTxt || config.machineHints?.llmsFullTxt;
+  if (hasMachineHints) {
+    lines.push("## Machine Hints");
+    lines.push("");
+    if (config.machineHints?.robots) {
+      lines.push(`- robots.txt: ${config.machineHints.robots}`);
+    }
+    if (config.machineHints?.sitemap) {
+      lines.push(`- sitemap.xml: ${config.machineHints.sitemap}`);
+    }
+    if (config.machineHints?.llmsTxt) {
+      lines.push(`- llms.txt: ${config.machineHints.llmsTxt}`);
+    }
+    if (config.machineHints?.llmsFullTxt) {
+      lines.push(`- llms-full.txt: ${config.machineHints.llmsFullTxt}`);
+    }
+    lines.push("");
+  }
+  const hubs = config.sections?.hubs ?? [];
+  if (hubs.length > 0 || manifestItems.length > 0) {
+    lines.push("## Sitemap");
+    lines.push("");
+    if (hubs.length > 0) {
+      const sortedHubs = sortStrings(hubs);
+      for (const hub of sortedHubs) {
+        lines.push(`- [${hub}](${hub}) - ${getHubLabel2(hub)}`);
+      }
+    }
+    if (manifestItems.length > 0) {
+      const sortedItems = sortBy(manifestItems, (item) => item.slug);
+      for (const item of sortedItems) {
+        const url = item.canonicalOverride ?? `${config.site.baseUrl}${item.slug}`;
+        const title = item.title ?? item.slug;
+        const locales = item.locales?.join(", ") ?? config.brand.locales[0] ?? "en";
+        lines.push(`- [${title}](${url}) (${locales})`);
+      }
+    }
+    lines.push("");
+  }
+  let content = lines.join("\n");
+  content = normalizeLineWhitespace(content);
+  content = normalizeLineEndings(content, lineEndings);
+  const finalLines = content.split(lineEndings === "crlf" ? "\r\n" : "\n");
+  return {
+    content,
+    byteSize: Buffer.byteLength(content, "utf-8"),
+    lineCount: finalLines.length
+  };
+}
+function getHubLabel2(hub) {
+  const labels = {
+    "/services": "Services overview",
+    "/blog": "Blog posts",
+    "/projects": "Our projects",
+    "/cases": "Case studies",
+    "/contact": "Contact us",
+    "/about": "About us",
+    "/products": "Products",
+    "/docs": "Documentation",
+    "/faq": "Frequently asked questions",
+    "/pricing": "Pricing information",
+    "/team": "Our team",
+    "/careers": "Career opportunities",
+    "/news": "News and updates",
+    "/resources": "Resources",
+    "/support": "Support center"
+  };
+  return labels[hub] ?? formatHubLabel2(hub);
+}
+function formatHubLabel2(hub) {
+  const clean = hub.replace(/^\//, "");
+  return clean.replace(/[-_]/g, " ").replace(/\b\w/g, (char) => char.toUpperCase());
+}
+function generatePageContent(page, manifest, _options) {
+  const maxContentLength = _options?.maxContentLength ?? 0;
+  const lines = [];
+  const url = `${manifest.baseUrl}${page.path}`;
+  lines.push(`## ${page.title ?? page.path}`);
+  lines.push(`URL: ${url}`);
+  lines.push("");
+  if (page.description) {
+    lines.push(page.description);
+    lines.push("");
+  }
+  if (page.content) {
+    let content = page.content;
+    if (maxContentLength > 0 && content.length > maxContentLength) {
+      content = `${content.slice(0, maxContentLength)}...`;
+    }
+    lines.push(content);
+    lines.push("");
+  }
+  return lines.join("\n");
+}
+function generateLlmsFullTxt(manifest, _options) {
+  const canonicalUrls = manifest.pages.map((page) => `${manifest.baseUrl}${page.path}`);
+  const manifestItems = manifest.pages.map((page) => ({
+    slug: page.path,
+    title: page.title,
+    description: page.description
+  }));
+  const config = {
+    site: { baseUrl: manifest.baseUrl },
+    brand: {
+      name: manifest.title,
+      locales: ["en"],
+      ...manifest.description && { description: manifest.description }
+    },
+    manifests: {},
+    output: {
+      paths: {
+        llmsTxt: "public/llms.txt",
+        llmsFullTxt: "public/llms-full.txt"
+      }
+    }
+  };
+  return createLlmsFullTxt({ config, canonicalUrls, manifestItems }).content;
+}
+
+// src/core/generate/citations.ts
+function createCitationsJson(options) {
+  const { config, manifestItems, sectionName, fixedTimestamp } = options;
+  const sources = manifestItems.map((item) => {
+    const url = item.canonicalOverride ?? `${config.site.baseUrl}${item.slug}`;
+    const defaultLocale = config.site.defaultLocale ?? config.brand.locales[0] ?? "en";
+    return {
+      url,
+      priority: item.priority ?? 50,
+      section: sectionName,
+      locale: item.locales?.[0] ?? defaultLocale,
+      ...item.publishedAt && { publishedAt: item.publishedAt },
+      ...item.updatedAt && { updatedAt: item.updatedAt },
+      ...item.title && { title: item.title }
+    };
+  });
+  const sortedSources = sources.sort((a, b) => {
+    if (a.priority !== b.priority) {
+      return b.priority - a.priority;
+    }
+    return a.url.localeCompare(b.url, "en", { sensitivity: "case", numeric: true });
+  });
+  const policy = {
+    restrictedClaimsEnabled: config.policy?.restrictedClaims?.enable ?? false,
+    ...config.policy?.geoPolicy && { geoPolicy: config.policy.geoPolicy },
+    ...config.policy?.citationRules && { citationRules: config.policy.citationRules }
+  };
+  return {
+    version: "1.0",
+    generated: fixedTimestamp ?? (/* @__PURE__ */ new Date()).toISOString(),
+    site: {
+      baseUrl: config.site.baseUrl,
+      name: config.brand.name
+    },
+    sources: sortedSources,
+    policy
+  };
+}
+function createCitationsJsonString(options) {
+  const citations = createCitationsJson(options);
+  return JSON.stringify(citations, null, 2);
+}
+function createCitation(page, manifest) {
+  const citation = {
+    url: `${manifest.baseUrl}${page.path}`,
+    title: page.title ?? page.path
+  };
+  if (page.description) {
+    citation.description = page.description;
+  }
+  return citation;
+}
+function citationToMarkdown(citation) {
+  if (citation.description) {
+    return `[${citation.title}](${citation.url}) - ${citation.description}`;
+  }
+  return `[${citation.title}](${citation.url})`;
+}
+function citationToJsonLd(citation) {
+  const jsonLd = {
+    "@type": "WebPage",
+    name: citation.title,
+    url: citation.url
+  };
+  if (citation.description) {
+    jsonLd.description = citation.description;
+  }
+  return jsonLd;
+}
+function generateReferenceList(citations) {
+  const lines = ["## References", ""];
+  for (let i = 0; i < citations.length; i++) {
+    const citation = citations[i];
+    if (citation) {
+      const num = i + 1;
+      lines.push(`${num}. ${citationToMarkdown(citation)}`);
+    }
+  }
+  lines.push("");
+  return lines.join("\n");
+}
+
+// src/core/check/issues.ts
+function createCheckIssue(severity, code, message, path = "", context) {
+  const issue = {
+    path,
+    code,
+    message,
+    severity
+  };
+  if (context !== void 0) {
+    issue.context = context;
+  }
+  return issue;
+}
+function createIssue(overrides) {
+  return {
+    category: "content",
+    ...overrides
+  };
+}
+function groupBySeverity(issues) {
+  const grouped = /* @__PURE__ */ new Map();
+  for (const issue of issues) {
+    const existing = grouped.get(issue.severity) ?? [];
+    existing.push(issue);
+    grouped.set(issue.severity, existing);
+  }
+  return grouped;
+}
+function groupByPage(issues) {
+  const grouped = /* @__PURE__ */ new Map();
+  for (const issue of issues) {
+    const existing = grouped.get(issue.pageId) ?? [];
+    existing.push(issue);
+    grouped.set(issue.pageId, existing);
+  }
+  return grouped;
+}
+function filterBySeverity(issues, minSeverity) {
+  const severityOrder = ["error", "warning", "info"];
+  const minIndex = severityOrder.indexOf(minSeverity);
+  return issues.filter((issue) => {
+    const issueIndex = severityOrder.indexOf(issue.severity);
+    return issueIndex <= minIndex;
+  });
+}
+function countSeverities(issues) {
+  const counts = {
+    error: 0,
+    warning: 0,
+    info: 0
+  };
+  for (const issue of issues) {
+    counts[issue.severity]++;
+  }
+  return counts;
+}
+
+// src/core/check/rules-linter.ts
+var LINT_RULES = [
+  {
+    id: "heading-structure",
+    description: "Ensures proper heading structure (h1 -> h2 -> h3)",
+    enabled: true,
+    lint: lintHeadingStructure
+  },
+  {
+    id: "url-format",
+    description: "Validates URL format in links",
+    enabled: true,
+    lint: lintUrlFormat
+  },
+  {
+    id: "trailing-whitespace",
+    description: "Checks for trailing whitespace on lines",
+    enabled: true,
+    lint: lintTrailingWhitespace
+  },
+  {
+    id: "consistent-list-markers",
+    description: "Ensures consistent list marker usage",
+    enabled: true,
+    lint: lintListMarkers
+  }
+];
+function lintContent(content, filePath, rules = LINT_RULES.filter((r) => r.enabled)) {
+  const issues = [];
+  for (const rule of rules) {
+    const ruleIssues = rule.lint(content, filePath);
+    issues.push(...ruleIssues);
+  }
+  return {
+    filePath,
+    issues,
+    passed: issues.filter((i) => i.severity === "error").length === 0
+  };
+}
+function checkForbiddenTerms(content, forbidden, whitelist = []) {
+  const issues = [];
+  const lines = content.split("\n");
+  const whitelistLower = whitelist.map((w) => w.toLowerCase());
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    if (line === void 0) continue;
+    const trimmed = line.trim();
+    const loweredTrimmed = trimmed.toLowerCase();
+    if (loweredTrimmed.startsWith("forbidden terms:") || loweredTrimmed.startsWith("exceptions:")) {
+      continue;
+    }
+    for (const term of forbidden) {
+      const termLower = term.toLowerCase();
+      const lineLower = line.toLowerCase();
+      if (lineLower.includes(termLower)) {
+        const isWhitelisted = whitelistLower.some(
+          (w) => lineLower.includes(w) && w.includes(termLower)
+        );
+        if (!isWhitelisted) {
+          issues.push({
+            path: "",
+            code: "forbidden_term",
+            message: `Term "${term}" is forbidden by policy`,
+            severity: "warning",
+            line: i + 1,
+            context: trimmed.substring(0, 100)
+          });
+        }
+      }
+    }
+  }
+  return issues;
+}
+function checkEmptySections(content) {
+  const issues = [];
+  const lines = content.split("\n");
+  let currentSection = null;
+  let sectionStartLine = 0;
+  let sectionHeadingLevel = 0;
+  let sectionHasContent = false;
+  let sectionWasFirst = false;
+  let isFirstHeading = true;
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    if (line === void 0) continue;
+    const headingMatch = line.match(/^(#{1,6})\s+(.+)$/);
+    if (headingMatch?.[2]) {
+      const nextHeadingLevel = headingMatch[1]?.length ?? 0;
+      if (currentSection !== null && nextHeadingLevel > sectionHeadingLevel) {
+        sectionHasContent = true;
+      }
+      if (currentSection !== null && !sectionHasContent && !sectionWasFirst) {
+        issues.push({
+          path: "",
+          code: "empty_section",
+          message: `Section "${currentSection}" has no content`,
+          severity: "info",
+          line: sectionStartLine
+        });
+      }
+      currentSection = headingMatch[2].trim();
+      sectionStartLine = i + 1;
+      sectionHeadingLevel = nextHeadingLevel;
+      sectionHasContent = false;
+      sectionWasFirst = isFirstHeading;
+      isFirstHeading = false;
+    } else if (currentSection !== null) {
+      if (line.trim().length > 0) {
+        sectionHasContent = true;
+      }
+    }
+  }
+  if (currentSection !== null && !sectionHasContent && !sectionWasFirst) {
+    issues.push({
+      path: "",
+      code: "empty_section",
+      message: `Section "${currentSection}" has no content`,
+      severity: "info",
+      line: sectionStartLine
+    });
+  }
+  return issues;
+}
+function checkDuplicateUrls(content) {
+  const issues = [];
+  const lines = content.split("\n");
+  const seenUrls = /* @__PURE__ */ new Map();
+  const urlPattern = /\[([^\]]*)\]\(([^)]+)\)/g;
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    if (line === void 0) continue;
+    let match = urlPattern.exec(line);
+    while (match !== null) {
+      const url = match[2];
+      if (url !== void 0) {
+        const firstOccurrence = seenUrls.get(url);
+        if (firstOccurrence !== void 0) {
+          issues.push({
+            path: "",
+            code: "duplicate_url",
+            message: `URL "${url}" appears multiple times (first at line ${firstOccurrence})`,
+            severity: "warning",
+            line: i + 1,
+            context: url
+          });
+        } else {
+          seenUrls.set(url, i + 1);
+        }
+      }
+      match = urlPattern.exec(line);
+    }
+    urlPattern.lastIndex = 0;
+  }
+  return issues;
+}
+function lintHeadingStructure(content, filePath) {
+  const issues = [];
+  const lines = content.split("\n");
+  let prevLevel = 0;
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    if (line === void 0) continue;
+    const match = line.match(/^(#{1,6})\s/);
+    if (match?.[1]) {
+      const level = match[1].length;
+      if (level > prevLevel + 1 && prevLevel > 0) {
+        issues.push(createIssue({
+          id: "heading-skip",
+          pageId: filePath,
+          severity: "warning",
+          message: `Heading level skipped: h${prevLevel} to h${level}`,
+          line: i + 1
+        }));
+      }
+      prevLevel = level;
+    }
+  }
+  return issues;
+}
+function lintUrlFormat(content, filePath) {
+  const issues = [];
+  const lines = content.split("\n");
+  const urlPattern = /\[([^\]]*)\]\(([^)]+)\)/g;
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    if (line === void 0) continue;
+    let match = urlPattern.exec(line);
+    while (match !== null) {
+      const url = match[2];
+      if (url && !url.startsWith("/") && !url.startsWith("http") && !url.startsWith("#")) {
+        issues.push(createIssue({
+          id: "invalid-url",
+          pageId: filePath,
+          severity: "warning",
+          message: `Invalid URL format: ${url}`,
+          line: i + 1,
+          column: match.index + 1
+        }));
+      }
+      match = urlPattern.exec(line);
+    }
+  }
+  return issues;
+}
+function lintTrailingWhitespace(content, filePath) {
+  const issues = [];
+  const lines = content.split("\n");
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    if (line !== void 0 && line.endsWith(" ")) {
+      issues.push(createIssue({
+        id: "trailing-whitespace",
+        pageId: filePath,
+        severity: "info",
+        message: "Line has trailing whitespace",
+        line: i + 1
+      }));
+    }
+  }
+  return issues;
+}
+function lintListMarkers(content, filePath) {
+  const issues = [];
+  const lines = content.split("\n");
+  const dashCount = lines.filter((l) => /^\s*-\s/.test(l)).length;
+  const asteriskCount = lines.filter((l) => /^\s*\*\s/.test(l)).length;
+  if (dashCount > 0 && asteriskCount > 0) {
+    issues.push(createIssue({
+      id: "inconsistent-list-markers",
+      pageId: filePath,
+      severity: "info",
+      message: "Mix of - and * list markers detected"
+    }));
+  }
+  return issues;
+}
+
+// src/core/check/checker.ts
+var DEFAULT_CHECKER_CONFIG = {
+  strict: false,
+  maxTitleLength: 60,
+  maxDescriptionLength: 160
+};
+function checkManifest(manifest, config = {}) {
+  const fullConfig = { ...DEFAULT_CHECKER_CONFIG, ...config };
+  const issues = [];
+  for (const page of manifest.pages) {
+    const pageIssues = checkPage(page, fullConfig);
+    issues.push(...pageIssues);
+  }
+  const summary = {
+    error: 0,
+    warning: 0,
+    info: 0
+  };
+  for (const issue of issues) {
+    summary[issue.severity]++;
+  }
+  return {
+    passed: summary.error === 0,
+    issues,
+    pagesChecked: manifest.pages.length,
+    summary
+  };
+}
+function checkPage(page, config) {
+  const issues = [];
+  const pageId = page.path;
+  if (!page.title) {
+    issues.push({
+      id: "missing-title",
+      pageId,
+      severity: "warning",
+      message: "Page is missing a title"
+    });
+  } else if (page.title.length > config.maxTitleLength) {
+    issues.push({
+      id: "title-too-long",
+      pageId,
+      severity: "warning",
+      message: `Title exceeds ${config.maxTitleLength} characters (${page.title.length})`
+    });
+  }
+  if (!page.description) {
+    issues.push({
+      id: "missing-description",
+      pageId,
+      severity: "warning",
+      message: "Page is missing a description"
+    });
+  } else if (page.description.length > config.maxDescriptionLength) {
+    issues.push({
+      id: "description-too-long",
+      pageId,
+      severity: "info",
+      message: `Description exceeds ${config.maxDescriptionLength} characters (${page.description.length})`
+    });
+  }
+  return issues;
+}
+async function checkGeneratedFiles(options) {
+  const issues = [];
+  let filesChecked = 0;
+  let filesMissing = 0;
+  let filesMismatch = 0;
+  const { config, failOn } = options;
+  const llmsTxtPath = options.llmsTxtPath ?? config.output.paths.llmsTxt;
+  const llmsFullTxtPath = options.llmsFullTxtPath ?? config.output.paths.llmsFullTxt;
+  const citationsPath = options.citationsPath ?? config.output.paths.citations;
+  const llmsTxtResult = await checkFile(llmsTxtPath);
+  if (!llmsTxtResult.exists) {
+    issues.push(createCheckIssue(
+      "error",
+      "file_missing",
+      `Required file does not exist: ${llmsTxtPath}`,
+      llmsTxtPath
+    ));
+    filesMissing++;
+  } else if (llmsTxtResult.content === "") {
+    issues.push(createCheckIssue(
+      "warning",
+      "file_empty",
+      `File is empty: ${llmsTxtPath}`,
+      llmsTxtPath
+    ));
+    filesChecked++;
+  } else {
+    filesChecked++;
+    const lintIssues = await lintFile(llmsTxtPath, llmsTxtResult.content, config);
+    issues.push(...lintIssues);
+  }
+  const llmsFullTxtResult = await checkFile(llmsFullTxtPath);
+  if (!llmsFullTxtResult.exists) {
+    issues.push(createCheckIssue(
+      "error",
+      "file_missing",
+      `Required file does not exist: ${llmsFullTxtPath}`,
+      llmsFullTxtPath
+    ));
+    filesMissing++;
+  } else if (llmsFullTxtResult.content === "") {
+    issues.push(createCheckIssue(
+      "warning",
+      "file_empty",
+      `File is empty: ${llmsFullTxtPath}`,
+      llmsFullTxtPath
+    ));
+    filesChecked++;
+  } else {
+    filesChecked++;
+    const lintIssues = await lintFile(llmsFullTxtPath, llmsFullTxtResult.content, config);
+    issues.push(...lintIssues);
+  }
+  if (citationsPath) {
+    const citationsResult = await checkFile(citationsPath);
+    if (!citationsResult.exists) {
+      issues.push(createCheckIssue(
+        "warning",
+        "file_missing",
+        `Optional citations file does not exist: ${citationsPath}`,
+        citationsPath
+      ));
+      filesMissing++;
+    } else {
+      filesChecked++;
+    }
+  }
+  const severityCounts = countSeverities(issues);
+  let exitCode;
+  if (severityCounts.error > 0) {
+    exitCode = 2;
+  } else if (failOn === "warn" && severityCounts.warning > 0) {
+    exitCode = 1;
+  } else {
+    exitCode = 0;
+  }
+  return {
+    issues,
+    summary: {
+      errors: severityCounts.error,
+      warnings: severityCounts.warning,
+      info: severityCounts.info,
+      filesChecked,
+      filesMissing,
+      filesMismatch
+    },
+    exitCode
+  };
+}
+async function checkFileExists(filePath) {
+  try {
+    await fs.access(filePath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function checkFile(filePath) {
+  try {
+    const content = await fs.readFile(filePath, "utf-8");
+    return { exists: true, content };
+  } catch {
+    return { exists: false, content: "" };
+  }
+}
+async function readFileContent(filePath) {
+  try {
+    return await fs.readFile(filePath, "utf-8");
+  } catch {
+    return null;
+  }
+}
+function compareContent(expected, actual, maxContextLines = 5) {
+  if (expected === actual) {
+    return { match: true, context: "" };
+  }
+  const expectedLines = expected.split("\n");
+  const actualLines = actual.split("\n");
+  const contextLines = [];
+  let diffCount = 0;
+  const maxLines = Math.max(expectedLines.length, actualLines.length);
+  for (let i = 0; i < maxLines && diffCount < maxContextLines; i++) {
+    const expectedLine = expectedLines[i];
+    const actualLine = actualLines[i];
+    if (expectedLine !== actualLine) {
+      diffCount++;
+      const lineNum = i + 1;
+      if (expectedLine !== void 0) {
+        contextLines.push(`Expected line ${lineNum}: "${expectedLine}"`);
+      }
+      if (actualLine !== void 0) {
+        contextLines.push(`Actual line ${lineNum}: "${actualLine}"`);
+      }
+    }
+  }
+  return {
+    match: false,
+    context: contextLines.join("\n")
+  };
+}
+async function lintFile(filePath, content, config) {
+  const issues = [];
+  const lintResult = lintContent(content, filePath);
+  for (const issue of lintResult.issues) {
+    const checkIssue = {
+      path: filePath,
+      code: issue.id,
+      message: issue.message,
+      severity: issue.severity
+    };
+    if (issue.line !== void 0) {
+      checkIssue.line = issue.line;
+    }
+    if (issue.suggestion !== void 0) {
+      checkIssue.context = issue.suggestion;
+    }
+    issues.push(checkIssue);
+  }
+  if (config.policy?.restrictedClaims?.enable) {
+    const forbidden = config.policy.restrictedClaims.forbidden ?? [];
+    const whitelist = config.policy.restrictedClaims.whitelist ?? [];
+    const forbiddenIssues = checkForbiddenTerms(content, forbidden, whitelist);
+    for (const issue of forbiddenIssues) {
+      const checkIssue = {
+        path: filePath,
+        code: "forbidden_term",
+        message: issue.message,
+        severity: issue.severity
+      };
+      if (issue.line !== void 0) {
+        checkIssue.line = issue.line;
+      }
+      if (issue.context !== void 0) {
+        checkIssue.context = issue.context;
+      }
+      issues.push(checkIssue);
+    }
+  }
+  const emptySectionIssues = checkEmptySections(content);
+  for (const issue of emptySectionIssues) {
+    const checkIssue = {
+      path: filePath,
+      code: "empty_section",
+      message: issue.message,
+      severity: issue.severity
+    };
+    if (issue.line !== void 0) {
+      checkIssue.line = issue.line;
+    }
+    if (issue.context !== void 0) {
+      checkIssue.context = issue.context;
+    }
+    issues.push(checkIssue);
+  }
+  const duplicateUrlIssues = checkDuplicateUrls(content);
+  for (const issue of duplicateUrlIssues) {
+    const checkIssue = {
+      path: filePath,
+      code: "duplicate_url",
+      message: issue.message,
+      severity: issue.severity
+    };
+    if (issue.line !== void 0) {
+      checkIssue.line = issue.line;
+    }
+    if (issue.context !== void 0) {
+      checkIssue.context = issue.context;
+    }
+    issues.push(checkIssue);
+  }
+  return issues;
+}
+async function checkFilesAgainstExpected(llmsTxtPath, expectedLlmsTxt, llmsFullTxtPath, expectedLlmsFullTxt, maxContextLines = 5) {
+  const issues = [];
+  const llmsTxtContent = await readFileContent(llmsTxtPath);
+  if (llmsTxtContent === null) {
+    issues.push(createCheckIssue(
+      "error",
+      "file_missing",
+      `Required file does not exist: ${llmsTxtPath}`,
+      llmsTxtPath
+    ));
+  } else if (llmsTxtContent === "") {
+    issues.push(createCheckIssue(
+      "warning",
+      "file_empty",
+      `File is empty: ${llmsTxtPath}`,
+      llmsTxtPath
+    ));
+  } else {
+    const compareResult = compareContent(expectedLlmsTxt, llmsTxtContent, maxContextLines);
+    if (!compareResult.match) {
+      issues.push(createCheckIssue(
+        "error",
+        "file_mismatch",
+        `Content differs from expected output`,
+        llmsTxtPath,
+        compareResult.context
+      ));
+    }
+  }
+  const llmsFullTxtContent = await readFileContent(llmsFullTxtPath);
+  if (llmsFullTxtContent === null) {
+    issues.push(createCheckIssue(
+      "error",
+      "file_missing",
+      `Required file does not exist: ${llmsFullTxtPath}`,
+      llmsFullTxtPath
+    ));
+  } else if (llmsFullTxtContent === "") {
+    issues.push(createCheckIssue(
+      "warning",
+      "file_empty",
+      `File is empty: ${llmsFullTxtPath}`,
+      llmsFullTxtPath
+    ));
+  } else {
+    const compareResult = compareContent(expectedLlmsFullTxt, llmsFullTxtContent, maxContextLines);
+    if (!compareResult.match) {
+      issues.push(createCheckIssue(
+        "error",
+        "file_mismatch",
+        `Content differs from expected output`,
+        llmsFullTxtPath,
+        compareResult.context
+      ));
+    }
+  }
+  return issues;
+}
+var SiteConfigSchema = z.object({
+  /** Site base URL - must be valid URL with http/https, no trailing slash */
+  baseUrl: z.string().url({ message: "Must be a valid URL with http or https protocol" }).refine(
+    (url) => !url.endsWith("/"),
+    { message: "Base URL must not have a trailing slash" }
+  ),
+  /** Default locale - must be in locales if provided */
+  defaultLocale: z.string().min(2).optional()
+});
+var BrandConfigSchema = z.object({
+  /** Brand name - required */
+  name: z.string().min(1, { message: "Brand name is required" }),
+  /** Optional tagline */
+  tagline: z.string().optional(),
+  /** Optional description */
+  description: z.string().optional(),
+  /** Optional organization name */
+  org: z.string().optional(),
+  /** Supported locales - e.g., ["en", "uk", "de"] */
+  locales: z.array(z.string().min(2)).min(1, { message: "At least one locale is required" })
+});
+var SectionsConfigSchema = z.object({
+  /** Hub paths - e.g., ["/services", "/blog", "/projects"] */
+  hubs: z.array(z.string()).default([])
+});
+var SocialConfigSchema = z.object({
+  /** Twitter handle or URL */
+  twitter: z.string().optional(),
+  /** LinkedIn URL */
+  linkedin: z.string().optional(),
+  /** GitHub URL */
+  github: z.string().optional()
+});
+var ContactConfigSchema = z.object({
+  /** Contact email */
+  email: z.string().email().optional(),
+  /** Social links */
+  social: SocialConfigSchema.optional(),
+  /** Phone number */
+  phone: z.string().optional()
+});
+var RestrictedClaimsConfigSchema = z.object({
+  /** Enable restricted claims checking */
+  enable: z.boolean(),
+  /** Forbidden words/phrases - e.g., ["best", "#1", "guaranteed"] */
+  forbidden: z.array(z.string()).optional(),
+  /** Allowlisted phrases */
+  whitelist: z.array(z.string()).optional()
+});
+var PolicyConfigSchema = z.object({
+  /** Geographic policy statement */
+  geoPolicy: z.string().optional(),
+  /** Citation rules */
+  citationRules: z.string().optional(),
+  /** Restricted claims configuration */
+  restrictedClaims: RestrictedClaimsConfigSchema.optional()
+});
+var BookingConfigSchema = z.object({
+  /** Booking URL - e.g., Cal.com link */
+  url: z.string().url().optional(),
+  /** Booking label - e.g., "Book a consultation" */
+  label: z.string().optional()
+});
+var MachineHintsConfigSchema = z.object({
+  /** URL to robots.txt */
+  robots: z.string().url().optional(),
+  /** URL to sitemap.xml */
+  sitemap: z.string().url().optional(),
+  /** URL to llms.txt */
+  llmsTxt: z.string().url().optional(),
+  /** URL to llms-full.txt */
+  llmsFullTxt: z.string().url().optional()
+});
+var OutputPathsConfigSchema = z.object({
+  /** Path to llms.txt output - e.g., "public/llms.txt" */
+  llmsTxt: z.string().min(1, { message: "llmsTxt output path is required" }),
+  /** Path to llms-full.txt output - e.g., "public/llms-full.txt" */
+  llmsFullTxt: z.string().min(1, { message: "llmsFullTxt output path is required" }),
+  /** Path to citations.json output - e.g., "public/citations.json" */
+  citations: z.string().optional()
+});
+var OutputConfigSchema = z.object({
+  /** Output paths */
+  paths: OutputPathsConfigSchema
+});
+var FormatConfigSchema = z.object({
+  /** Trailing slash handling */
+  trailingSlash: z.enum(["always", "never", "preserve"]).default("never"),
+  /** Line endings format */
+  lineEndings: z.enum(["lf", "crlf"]).default("lf"),
+  /** Locale URL strategy */
+  localeStrategy: z.enum(["prefix", "subdomain", "none"]).optional()
+});
+z.object({
+  /** Site configuration */
+  site: SiteConfigSchema,
+  /** Brand configuration */
+  brand: BrandConfigSchema,
+  /** Sections configuration */
+  sections: SectionsConfigSchema.optional(),
+  /** Manifests configuration */
+  manifests: z.record(z.unknown()).default({}),
+  /** Contact configuration */
+  contact: ContactConfigSchema.optional(),
+  /** Policy configuration */
+  policy: PolicyConfigSchema.optional(),
+  /** Booking configuration */
+  booking: BookingConfigSchema.optional(),
+  /** Machine hints configuration */
+  machineHints: MachineHintsConfigSchema.optional(),
+  /** Output configuration */
+  output: OutputConfigSchema,
+  /** Format configuration */
+  format: FormatConfigSchema.optional()
+});
+var ConfigSchema = z.object({
+  baseUrl: z.string().url(),
+  title: z.string().min(1),
+  description: z.string().optional(),
+  outputDir: z.string().default("./public"),
+  includeOptionalSections: z.boolean().default(false),
+  maxContentLength: z.number().int().nonnegative().default(0)
+});
+var LocaleConfigSchema = z.object({
+  default: z.string().min(2),
+  supported: z.array(z.string().min(2)).min(1),
+  strategy: z.enum(["subdirectory", "subdomain", "domain"])
+});
+var CheckConfigSchema = z.object({
+  strict: z.boolean().default(false),
+  maxTitleLength: z.number().int().positive().default(60),
+  maxDescriptionLength: z.number().int().positive().default(160),
+  enableLint: z.boolean().default(true)
+});
+var FullConfigSchema = z.object({
+  site: ConfigSchema,
+  locale: LocaleConfigSchema.optional(),
+  check: CheckConfigSchema.optional()
+});
+var ManifestItemSchema = z.object({
+  /** URL path slug - required */
+  slug: z.string().min(1, { message: "Slug is required and cannot be empty" }),
+  /** Available locales for this page */
+  locales: z.array(z.string().min(2)).optional(),
+  /** Publication date (ISO 8601) */
+  publishedAt: z.string().datetime({ message: "publishedAt must be a valid ISO 8601 date" }).optional(),
+  /** Last update date (ISO 8601) */
+  updatedAt: z.string().datetime({ message: "updatedAt must be a valid ISO 8601 date" }).optional(),
+  /** Override canonical URL */
+  canonicalOverride: z.string().url().optional(),
+  /** Priority for citations (0-100) */
+  priority: z.number().int().min(0).max(100).optional(),
+  /** Title for display */
+  title: z.string().optional(),
+  /** Description for display */
+  description: z.string().optional()
+});
+var ManifestSourceSchema = z.object({
+  /** Source type */
+  type: z.enum(["file", "url", "module"]),
+  /** Source location */
+  source: z.string(),
+  /** Optional transform function */
+  transform: z.string().optional()
+});
+var ManifestValueSchema = z.union([
+  z.array(ManifestItemSchema),
+  ManifestSourceSchema
+]);
+z.record(z.string(), ManifestValueSchema);
+var OptionalSectionSchema = z.object({
+  /** Section title */
+  title: z.string().min(1),
+  /** Section content */
+  content: z.string().optional()
+});
+var PageManifestSchema = z.object({
+  /** Page path (e.g., /about) */
+  path: z.string().startsWith("/"),
+  /** Page title */
+  title: z.string().optional(),
+  /** Page description */
+  description: z.string().optional(),
+  /** Page content for llms-full.txt */
+  content: z.string().optional(),
+  /** Whether page is optional (included only in full) */
+  optional: z.boolean().default(false),
+  /** Last modified timestamp (ISO 8601) */
+  lastModified: z.string().datetime().optional()
+});
+var SiteManifestSchema = z.object({
+  /** Site base URL */
+  baseUrl: z.string().url(),
+  /** Site title */
+  title: z.string().min(1),
+  /** Site description */
+  description: z.string().optional(),
+  /** List of pages */
+  pages: z.array(PageManifestSchema).min(1),
+  /** Optional sections for llms.txt */
+  optionalSections: z.array(OptionalSectionSchema).optional(),
+  /** Site version */
+  version: z.string().optional(),
+  /** Generation timestamp (ISO 8601) */
+  generatedAt: z.string().datetime().optional()
+});
+var BuildManifestSchema = z.object({
+  /** Build ID */
+  buildId: z.string(),
+  /** List of static pages */
+  pages: z.record(z.string(), z.array(z.string())),
+  /** Dynamic routes */
+  dynamicRoutes: z.record(z.string(), z.object({
+    routeRegex: z.string(),
+    dataRoute: z.string(),
+    dataRouteRegex: z.string()
+  })).optional()
+});
+
+// src/schema/validate.ts
+function validate(schema, data) {
+  const result = schema.safeParse(data);
+  if (result.success) {
+    return {
+      success: true,
+      data: result.data,
+      issues: []
+    };
+  }
+  return {
+    success: false,
+    issues: formatZodErrors(result.error)
+  };
+}
+function formatZodErrors(error) {
+  return error.issues.map((issue) => ({
+    path: issue.path.join("."),
+    message: issue.message,
+    code: issue.code,
+    severity: "error"
+  }));
+}
+function validateOrThrow(schema, data) {
+  const result = validate(schema, data);
+  if (!result.success || !result.data) {
+    const messages = result.issues?.map((e) => `${e.path}: ${e.message}`).join("; ") ?? "Unknown validation error";
+    throw new Error(`Validation failed: ${messages}`);
+  }
+  return result.data;
+}
+function formatValidationErrors(issues) {
+  const lines = ["Validation failed:", ""];
+  for (const issue of issues) {
+    lines.push(`  - ${issue.path || "(root)"}: ${issue.message}`);
+  }
+  return lines.join("\n");
+}
+function fromNextContentManifest(manifest, options = {}) {
+  const { slugPrefix = "", defaultLocale } = options;
+  return manifest.items.map((item) => {
+    const result = {
+      slug: slugPrefix + item.slug
+    };
+    if (item.locales !== void 0) {
+      result.locales = item.locales;
+    } else if (defaultLocale !== void 0) {
+      result.locales = [defaultLocale];
+    }
+    if (item.publishedAt !== void 0) {
+      result.publishedAt = item.publishedAt;
+    }
+    if (item.updatedAt !== void 0) {
+      result.updatedAt = item.updatedAt;
+    }
+    if (item.title !== void 0) {
+      result.title = item.title;
+    }
+    if (item.description !== void 0) {
+      result.description = item.description;
+    }
+    if (item.priority !== void 0) {
+      result.priority = item.priority;
+    }
+    if (item.canonicalOverride !== void 0) {
+      result.canonicalOverride = item.canonicalOverride;
+    }
+    return result;
+  });
+}
+function parseFrontmatter(content) {
+  const frontmatterRegex = /^---\s*\n([\s\S]*?)\n---\s*\n([\s\S]*)$/;
+  const match = content.match(frontmatterRegex);
+  if (!match) {
+    return { frontmatter: {}, body: content };
+  }
+  const frontmatterText = match[1] ?? "";
+  const body = match[2] ?? content;
+  const frontmatter = {};
+  const lines = frontmatterText.split("\n");
+  for (const line of lines) {
+    const colonIndex = line.indexOf(":");
+    if (colonIndex === -1) continue;
+    const key = line.slice(0, colonIndex).trim();
+    let value = line.slice(colonIndex + 1).trim();
+    if (value.startsWith("[") && value.endsWith("]")) {
+      value = value.slice(1, -1).split(",").map((item) => item.trim().replace(/^['"]|['"]$/g, "")).filter((item) => item.length > 0);
+    } else {
+      value = value.replace(/^['"]|['"]$/g, "");
+    }
+    if (key === "title") frontmatter.title = value;
+    else if (key === "description") frontmatter.description = value;
+    else if (key === "date" || key === "publishedAt") frontmatter.date = value;
+    else if (key === "updated" || key === "updatedAt") frontmatter.updated = value;
+    else if (key === "locale") frontmatter.locale = value;
+    else if (key === "locales") frontmatter.locales = value;
+    else if (key === "priority") frontmatter.priority = parseInt(value, 10);
+    else frontmatter[key] = value;
+  }
+  return { frontmatter, body };
+}
+function filePathToSlug(filePath, extensions) {
+  let slug = filePath;
+  for (const ext of extensions) {
+    if (slug.endsWith(ext)) {
+      slug = slug.slice(0, -ext.length);
+      break;
+    }
+  }
+  if (slug.endsWith("/index")) {
+    slug = slug.slice(0, -6);
+  }
+  if (slug === "index") {
+    slug = "";
+  }
+  if (!slug.startsWith("/")) {
+    slug = "/" + slug;
+  }
+  return slug || "/";
+}
+async function scanDirectory(dir, extensions, basePath = "") {
+  const files = [];
+  if (!existsSync(dir)) {
+    return files;
+  }
+  const entries = await readdir(dir, { withFileTypes: true });
+  for (const entry of entries) {
+    const fullPath = join(dir, entry.name);
+    const relativePath = basePath ? join(basePath, entry.name) : entry.name;
+    if (entry.isDirectory()) {
+      const subFiles = await scanDirectory(fullPath, extensions, relativePath);
+      files.push(...subFiles);
+    } else if (entry.isFile()) {
+      const hasValidExtension = extensions.some((ext) => entry.name.endsWith(ext));
+      if (hasValidExtension) {
+        files.push(relativePath);
+      }
+    }
+  }
+  return files;
+}
+async function createManifestFromPagesDir(options) {
+  const {
+    pagesDir,
+    routePrefix = "",
+    defaultLocale,
+    extensions = [".mdx", ".md"]
+  } = options;
+  const files = await scanDirectory(pagesDir, extensions);
+  const items = [];
+  for (const file of files) {
+    const fullPath = join(pagesDir, file);
+    const content = await readFile(fullPath, "utf-8");
+    const { frontmatter } = parseFrontmatter(content);
+    const slug = routePrefix + filePathToSlug(file, extensions);
+    const item = {
+      slug
+    };
+    if (frontmatter.locales !== void 0) {
+      item.locales = frontmatter.locales;
+    } else if (frontmatter.locale !== void 0) {
+      item.locales = [frontmatter.locale];
+    } else if (defaultLocale !== void 0) {
+      item.locales = [defaultLocale];
+    }
+    if (frontmatter.date !== void 0) {
+      item.publishedAt = frontmatter.date;
+    }
+    if (frontmatter.updated !== void 0) {
+      item.updatedAt = frontmatter.updated;
+    }
+    if (frontmatter.title !== void 0) {
+      item.title = frontmatter.title;
+    }
+    if (frontmatter.description !== void 0) {
+      item.description = frontmatter.description;
+    }
+    if (frontmatter.priority !== void 0) {
+      item.priority = frontmatter.priority;
+    }
+    items.push(item);
+  }
+  return items.sort((a, b) => a.slug.localeCompare(b.slug));
+}
+function createManifestFromData(items, options = {}) {
+  const { slugPrefix = "", defaultLocale } = options;
+  return items.map((item) => {
+    const slugPath = Array.isArray(item.params.slug) ? "/" + item.params.slug.join("/") : item.params.slug.startsWith("/") ? item.params.slug : "/" + item.params.slug;
+    const result = {
+      slug: slugPrefix + slugPath
+    };
+    if (item.locale !== void 0) {
+      result.locales = [item.locale];
+    } else if (defaultLocale !== void 0) {
+      result.locales = [defaultLocale];
+    }
+    if (item.publishedAt !== void 0) {
+      result.publishedAt = item.publishedAt;
+    }
+    if (item.updatedAt !== void 0) {
+      result.updatedAt = item.updatedAt;
+    }
+    if (item.title !== void 0) {
+      result.title = item.title;
+    }
+    if (item.description !== void 0) {
+      result.description = item.description;
+    }
+    if (item.priority !== void 0) {
+      result.priority = item.priority;
+    }
+    return result;
+  });
+}
+function extractPagePaths(buildManifest) {
+  const pages = [];
+  for (const pagePath of Object.keys(buildManifest.pages)) {
+    if (pagePath.startsWith("/_")) {
+      continue;
+    }
+    const normalizedPath = normalizeNextPath(pagePath);
+    pages.push(normalizedPath);
+  }
+  return pages.sort((a, b) => a.localeCompare(b));
+}
+function normalizeNextPath(path) {
+  let normalized = path.replace(/\.(html|json)$/, "");
+  if (normalized === "/index" || normalized === "") {
+    normalized = "/";
+  }
+  if (!normalized.startsWith("/")) {
+    normalized = `/${normalized}`;
+  }
+  return normalized;
+}
+function generateNextManifest(options, buildManifest) {
+  const pages = [];
+  if (buildManifest) {
+    const pagePaths = extractPagePaths(buildManifest);
+    for (const path of pagePaths) {
+      pages.push({
+        path,
+        title: void 0,
+        // Will be filled by crawler or manually
+        description: void 0,
+        optional: false
+      });
+    }
+  }
+  return {
+    baseUrl: options.baseUrl,
+    title: options.title,
+    description: options.description,
+    pages
+  };
+}
+
+// src/adapters/next/build-hooks.ts
+function generateBuildScripts(options = {}) {
+  const {
+    configPath = "llm-seo.config.ts",
+    emitCitations = false,
+    packageManager = "pnpm"
+  } = options;
+  const configFlag = `--config ${configPath}`;
+  const citationsFlag = emitCitations ? " --emit-citations" : "";
+  const runCommand = packageManager === "npm" ? "npm run" : packageManager;
+  return {
+    "build:seo": `llm-seo generate ${configFlag}${citationsFlag}`,
+    postbuild: `${runCommand} build:seo && llm-seo check --fail-on error`,
+    "check:seo": "llm-seo check --fail-on warn"
+  };
+}
+function createRobotsLlmsPolicySnippet(options) {
+  const {
+    baseUrl,
+    allowLlmsTxt = true,
+    allowLlmsFullTxt = true,
+    allowSitemap = true,
+    additionalPaths = [],
+    userAgent = "*"
+  } = options;
+  const lines = ["# LLM SEO"];
+  try {
+    const url = new URL(baseUrl);
+    lines.push(`Host: ${url.host}`);
+  } catch {
+  }
+  lines.push(`User-agent: ${userAgent}`);
+  if (allowLlmsTxt) {
+    lines.push("Allow: /llms.txt");
+  }
+  if (allowLlmsFullTxt) {
+    lines.push("Allow: /llms-full.txt");
+  }
+  if (allowSitemap) {
+    lines.push("Allow: /sitemap.xml");
+  }
+  for (const path of additionalPaths) {
+    lines.push(`Allow: ${path}`);
+  }
+  return lines.join("\n");
+}
+function createNextConfig(options) {
+  const {
+    locales = [],
+    defaultLocale = "en",
+    trailingSlash = false,
+    unoptimizedImages = true
+  } = options;
+  const config = {
+    output: "export",
+    trailingSlash,
+    images: {
+      unoptimized: unoptimizedImages
+    }
+  };
+  if (locales.length > 0) {
+    config.i18n = {
+      locales,
+      defaultLocale
+    };
+  }
+  return config;
+}
+async function postBuildHook(options) {
+  const { outputDir, manifest, generateFull = false } = options;
+  const files = [];
+  try {
+    generateLlmsTxt(manifest);
+    const llmsTxtPath = `${outputDir}/llms.txt`;
+    files.push(llmsTxtPath);
+    if (generateFull) {
+      generateLlmsFullTxt(manifest);
+      const llmsFullTxtPath = `${outputDir}/llms-full.txt`;
+      files.push(llmsFullTxtPath);
+    }
+    return {
+      files,
+      success: true
+    };
+  } catch (error) {
+    const message = error instanceof Error ? error.message : "Unknown error";
+    return {
+      files,
+      success: false,
+      error: message
+    };
+  }
+}
+function createNextPlugin() {
+  return {
+    name: "llm-seo",
+    postBuild: postBuildHook
+  };
+}
+
+export { BuildManifestSchema, CheckConfigSchema, ConfigSchema, DEFAULT_CHECKER_CONFIG, FullConfigSchema, LINT_RULES, OptionalSectionSchema, PageManifestSchema, SiteManifestSchema, checkFileExists, checkFilesAgainstExpected, checkGeneratedFiles, checkManifest, citationToJsonLd, citationToMarkdown, compareContent, compareStrings, createCanonicalUrlForItem, createCanonicalUrlsFromManifest, createCitation, createCitationsJson, createCitationsJsonString, createIssue, createLlmsFullTxt, createLlmsTxt, createManifestFromData, createManifestFromPagesDir, createNextConfig, createNextPlugin, createRobotsLlmsPolicySnippet, dedupeUrls, extractCanonicalUrls, extractLocaleFromPath, extractPagePaths, filterBySeverity, formatValidationErrors, fromNextContentManifest, generateAlternateUrls, generateBuildScripts, generateCanonicalUrl, generateLlmsFullTxt, generateLlmsTxt, generateNextManifest, generatePageContent, generateReferenceList, groupByPage, groupBySeverity, lintContent, localizePath, normalizeLineEndings, normalizeLineWhitespace, normalizeSeoText, normalizeUrl, normalizeWhitespace, postBuildHook, readFileContent, sortBy, sortStrings, sortUrls, validate, validateOrThrow };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map