@marvalt/digivalt-core 0.2.30 → 0.2.33

package/dist/index.cjs

@@ -9,6 +9,7 @@ var sadapter = require('@marvalt/sadapter');
 var promises = require('fs/promises');
 var fs = require('fs');
 
+var _documentCurrentScript = typeof document !== 'undefined' ? document.currentScript : null;
 const DEFAULT_ENABLED_POST_TYPES = 'posts,pages';
 /** Integration tokens in VITE_ENABLED_POST_TYPES that are not WordPress CPTs. */
 const PSEUDO_POST_TYPES = new Set(['google_reviews']);
@@ -363,21 +364,6 @@ async function generateGoogleReviewsData(options) {
     }
 }
 
-const SITEMAP_SKIP_TOP_LEVEL_KEYS = new Set([
-    'config',
-    'site_settings',
-    'header',
-    'footer',
-    'theme_styles',
-    'navigation_menu',
-    'menus',
-    'categories',
-    'tags',
-    'generated_at',
-    'frontend_id',
-    'frontend_name',
-    'front_page',
-]);
 function normalizePathname(pathname) {
     const decoded = decodeURIComponent(pathname);
     if (!decoded || decoded === '/')
@@ -385,43 +371,265 @@ function normalizePathname(pathname) {
     const stripped = decoded.replace(/\/+$/, '');
     return stripped === '' ? '/' : stripped;
 }
-function getAllowedHosts() {
-    const hosts = new Set();
-    const api = process.env.VITE_WORDPRESS_API_URL || process.env.WORDPRESS_API_URL;
-    if (api) {
-        try {
-            hosts.add(new URL(api).hostname);
+function joinPath(prefix, slug) {
+    const p = prefix.replace(/\/+$/, '');
+    const s = slug.replace(/^\/+/, '');
+    if (!p || p === '/')
+        return normalizePathname(`/${s}`);
+    return normalizePathname(`${p.startsWith('/') ? p : `/${p}`}/${s}`);
+}
+function stripHtml(html) {
+    return html
+        .replace(/<script[\s\S]*?<\/script>/gi, ' ')
+        .replace(/<style[\s\S]*?<\/style>/gi, ' ')
+        .replace(/<[^>]+>/g, ' ')
+        .replace(/\s+/g, ' ')
+        .trim();
+}
+function sanitizeBodyHtml(html) {
+    return html
+        .replace(/<script[\s\S]*?<\/script>/gi, '')
+        .replace(/<style[\s\S]*?<\/style>/gi, '')
+        .replace(/\son\w+\s*=\s*("[^"]*"|'[^']*'|[^\s>]+)/gi, '');
+}
+function renderedText(value) {
+    if (typeof value === 'string')
+        return stripHtml(value);
+    if (value && typeof value === 'object' && 'rendered' in value) {
+        const r = value.rendered;
+        if (typeof r === 'string')
+            return stripHtml(r);
+    }
+    return '';
+}
+function renderedHtml(value) {
+    if (typeof value === 'string')
+        return value;
+    if (value && typeof value === 'object' && 'rendered' in value) {
+        const r = value.rendered;
+        if (typeof r === 'string')
+            return r;
+    }
+    return '';
+}
+function escapeHtml(s) {
+    return s
+        .replace(/&/g, '&amp;')
+        .replace(/</g, '&lt;')
+        .replace(/>/g, '&gt;')
+        .replace(/"/g, '&quot;');
+}
+function escapeAttr(s) {
+    return escapeHtml(s).replace(/'/g, '&#39;');
+}
+
+const SITEMAP_URL_SHARD_SIZE = 45000;
+function parseRoutePrefixes(raw) {
+    const out = {};
+    const src = (raw ?? process.env.VITE_SEO_ROUTE_PREFIXES ?? '').trim();
+    if (!src)
+        return out;
+    for (const part of src.split(',')) {
+        const trimmed = part.trim();
+        if (!trimmed)
+            continue;
+        const idx = trimmed.indexOf(':');
+        if (idx <= 0)
+            continue;
+        const key = trimmed.slice(0, idx).trim();
+        const prefix = trimmed.slice(idx + 1).trim();
+        if (key)
+            out[key] = prefix || '/';
+    }
+    return out;
+}
+function isPublishedEntity(item) {
+    const s = item.status;
+    if (s === undefined || s === null || s === '')
+        return true;
+    return s === 'publish';
+}
+function isNoindexEntity(item) {
+    return item.digivalt_seo?.robots_index === false;
+}
+function entityLastmod(item) {
+    const v = item.modified_gmt || item.modified || item.date_gmt || item.date;
+    return typeof v === 'string' && v.trim() ? v.trim() : undefined;
+}
+function entityImage(item) {
+    const v = item.digivalt_seo?.og_image ||
+        item.featured_media_cloudflare_url ||
+        item.featured_media_url;
+    return typeof v === 'string' && v.trim() ? v.trim() : undefined;
+}
+function getFrontPageRef(data) {
+    const fp = data.front_page;
+    const envSlug = (process.env.VITE_SEO_FRONT_PAGE_SLUG || '').trim();
+    let slug;
+    let id;
+    if (fp && typeof fp === 'object') {
+        const rec = fp;
+        if (typeof rec.slug === 'string' && rec.slug.trim())
+            slug = rec.slug.trim();
+        if (typeof rec.id === 'number')
+            id = rec.id;
+        else if (typeof rec.id === 'string')
+            id = Number(rec.id) || undefined;
+    }
+    if (envSlug)
+        slug = envSlug;
+    return { slug, id };
+}
+function getFrontPageSlug(data) {
+    return getFrontPageRef(data).slug;
+}
+function asRecord(item) {
+    if (!item || typeof item !== 'object')
+        return null;
+    return item;
+}
+function newsletterRouteBase() {
+    const raw = process.env.VITE_PHPLIST_NEWSLETTER_ROUTE_BASE || '/newsletters';
+    return normalizePathname(raw.startsWith('/') ? raw : `/${raw}`);
+}
+function collectSitemapUrls(args) {
+    const prefixes = args.prefixes ?? parseRoutePrefixes();
+    const front = args.wpData ? getFrontPageRef(args.wpData) : {};
+    const byPath = new Map();
+    const add = (entry) => {
+        const path = normalizePathname(entry.path);
+        if (!path)
+            return;
+        const prev = byPath.get(path);
+        if (!prev) {
+            byPath.set(path, { ...entry, path });
+            return;
         }
-        catch {
-            /* ignore */
+        byPath.set(path, {
+            path,
+            lastmod: entry.lastmod || prev.lastmod,
+            image: entry.image || prev.image,
+        });
+    };
+    add({ path: '/' });
+    for (const p of args.staticPaths) {
+        add({ path: p });
+    }
+    const pages = args.wpData && Array.isArray(args.wpData.pages) ? args.wpData.pages : [];
+    for (const raw of pages) {
+        const item = asRecord(raw);
+        if (!item || !isPublishedEntity(item) || isNoindexEntity(item))
+            continue;
+        const slug = typeof item.slug === 'string' ? item.slug.trim() : '';
+        if (!slug)
+            continue;
+        const isFront = (front.slug && slug === front.slug) ||
+            (typeof front.id === 'number' && typeof item.id === 'number' && item.id === front.id);
+        const path = isFront ? '/' : joinPath('/', slug);
+        add({
+            path,
+            lastmod: entityLastmod(item),
+            image: entityImage(item),
+        });
+    }
+    if (args.wpData) {
+        for (const [type, prefix] of Object.entries(prefixes)) {
+            if (type === 'pages' || type === 'page')
+                continue;
+            const arr = args.wpData[type];
+            if (!Array.isArray(arr))
+                continue;
+            for (const raw of arr) {
+                const item = asRecord(raw);
+                if (!item || !isPublishedEntity(item) || isNoindexEntity(item))
+                    continue;
+                const slug = typeof item.slug === 'string' ? item.slug.trim() : '';
+                if (!slug)
+                    continue;
+                add({
+                    path: joinPath(prefix, slug),
+                    lastmod: entityLastmod(item),
+                    image: entityImage(item),
+                });
+            }
+        }
+    }
+    const newsletters = args.phplistData && Array.isArray(args.phplistData.newsletters)
+        ? args.phplistData.newsletters
+        : [];
+    const nBase = newsletterRouteBase();
+    for (const raw of newsletters) {
+        if (!raw || typeof raw !== 'object')
+            continue;
+        const rec = raw;
+        if (typeof rec.slug !== 'string' || !rec.slug.trim())
+            continue;
+        add({
+            path: joinPath(nBase, rec.slug.trim()),
+            lastmod: typeof rec.sent_at === 'string' ? rec.sent_at : undefined,
+        });
+    }
+    const known = new Set(byPath.keys());
+    const considerMenu = (items) => {
+        if (!Array.isArray(items))
+            return;
+        for (const item of items) {
+            if (!item || typeof item !== 'object')
+                continue;
+            const rec = item;
+            if (typeof rec.url === 'string') {
+                const path = menuUrlToFrontendPath(rec.url, front.slug);
+                if (path && known.has(path)) {
+                    add({ path });
+                }
+            }
+            considerMenu(rec.children);
         }
+    };
+    if (args.wpData) {
+        const header = args.wpData.navigation_menu;
+        const footer = args.wpData.footer_navigation_menu;
+        considerMenu(header?.items);
+        considerMenu(footer?.items);
     }
-    return hosts;
+    const sorted = [...byPath.values()].sort((a, b) => {
+        if (a.path === '/')
+            return -1;
+        if (b.path === '/')
+            return 1;
+        return a.path.localeCompare(b.path);
+    });
+    return sorted;
 }
-/**
- * When CMS host is unknown, accept any http(s) URL so local/offline merges still produce paths.
- */
-function urlToPath(urlStr, allowedHosts) {
+function menuUrlToFrontendPath(urlStr, frontSlug) {
     const t = urlStr.trim();
     if (!t || t === '#' || t.toLowerCase().startsWith('mailto:') || t.toLowerCase().startsWith('tel:')) {
         return null;
     }
-    if (!/^https?:\/\//i.test(t)) {
-        return null;
-    }
-    let u;
-    try {
-        u = new URL(t);
+    let pathname;
+    if (t.startsWith('/')) {
+        pathname = normalizePathname(t.split('?')[0]);
     }
-    catch {
-        return null;
+    else if (/^https?:\/\//i.test(t)) {
+        try {
+            pathname = normalizePathname(new URL(t).pathname);
+        }
+        catch {
+            return null;
+        }
     }
-    if (allowedHosts.size > 0 && !allowedHosts.has(u.hostname)) {
+    else {
         return null;
     }
-    return normalizePathname(u.pathname);
+    if (pathname === '/')
+        return '/';
+    const slug = pathname.replace(/^\//, '');
+    if (frontSlug && slug === frontSlug)
+        return '/';
+    return pathname;
 }
-function parsePathsJson(raw) {
+
+function parseStaticPathsJson(raw) {
     try {
         const data = JSON.parse(raw);
         if (Array.isArray(data)) {
@@ -436,130 +644,70 @@ function parsePathsJson(raw) {
     }
     return [];
 }
-function loadStaticPaths(cwd, staticInputPath, allowedHosts) {
-    const full = path.join(cwd, staticInputPath);
-    if (!fs.existsSync(full)) {
-        return [];
-    }
-    const raw = fs.readFileSync(full, 'utf8');
-    const paths = parsePathsJson(raw);
-    const out = [];
-    for (const p of paths) {
-        if (p.startsWith('http://') || p.startsWith('https://')) {
-            const normalized = urlToPath(p, allowedHosts);
-            if (normalized)
-                out.push(normalized);
-        }
-        else {
-            out.push(normalizePathname(p));
-        }
-    }
-    return out;
-}
-function walkMenuItems(items, allowedHosts, out) {
-    if (!Array.isArray(items))
-        return;
-    for (const item of items) {
-        if (!item || typeof item !== 'object')
-            continue;
-        const rec = item;
-        if (typeof rec.url === 'string') {
-            const p = urlToPath(rec.url, allowedHosts);
-            if (p)
-                out.add(p);
-        }
-        if (Array.isArray(rec.children)) {
-            walkMenuItems(rec.children, allowedHosts, out);
+function loadJson$1(full) {
+    if (!fs.existsSync(full))
+        return undefined;
+    try {
+        const data = JSON.parse(fs.readFileSync(full, 'utf8'));
+        if (data && typeof data === 'object' && !Array.isArray(data)) {
+            return data;
         }
     }
-}
-function collectLinksFromArray(arr, allowedHosts, out) {
-    for (const item of arr) {
-        if (!item || typeof item !== 'object')
-            continue;
-        const link = item.link;
-        if (typeof link === 'string') {
-            const p = urlToPath(link, allowedHosts);
-            if (p)
-                out.add(p);
-        }
+    catch (e) {
+        console.warn('⚠️  Could not parse JSON for sitemap:', full, e.message);
     }
+    return undefined;
 }
-function collectPathsFromWpData(data, allowedHosts) {
-    const out = new Set();
-    const menu = data.navigation_menu;
-    if (menu?.items) {
-        walkMenuItems(menu.items, allowedHosts, out);
-    }
-    const config = data.config;
-    const postTypeKeys = config?.post_types && typeof config.post_types === 'object'
-        ? Object.keys(config.post_types)
-        : null;
-    if (postTypeKeys && postTypeKeys.length > 0) {
-        for (const key of postTypeKeys) {
-            const arr = data[key];
-            if (Array.isArray(arr)) {
-                collectLinksFromArray(arr, allowedHosts, out);
-            }
-        }
-    }
-    else {
-        for (const [key, value] of Object.entries(data)) {
-            if (SITEMAP_SKIP_TOP_LEVEL_KEYS.has(key))
-                continue;
-            if (Array.isArray(value)) {
-                collectLinksFromArray(value, allowedHosts, out);
-            }
-        }
-    }
-    return out;
+function loadStaticPaths(cwd, staticInputPath) {
+    const full = path.join(cwd, staticInputPath);
+    if (!fs.existsSync(full))
+        return [];
+    return parseStaticPathsJson(fs.readFileSync(full, 'utf8')).map((p) => normalizePathname(p));
 }
 function writeFallback(cwd, outputPath) {
     const full = path.join(cwd, outputPath);
     fs.mkdirSync(path.dirname(full), { recursive: true });
-    fs.writeFileSync(full, `${JSON.stringify({ paths: ['/'] }, null, 2)}\n`, 'utf8');
+    const payload = { urls: [{ path: '/' }], paths: ['/'] };
+    fs.writeFileSync(full, `${JSON.stringify(payload, null, 2)}\n`, 'utf8');
+}
+function writeShard(full, urls) {
+    const paths = urls.map((u) => u.path);
+    fs.writeFileSync(full, `${JSON.stringify({ urls, paths }, null, 2)}\n`, 'utf8');
 }
 /**
- * Merge sitemap-static-paths.json, navigation_menu URLs, and CPT/post links from wordpress-data.json.
+ * Merge static app routes, WP pages (frontend paths), opt-in CPT prefixes, and PHPList issues.
  */
 async function generateSitemapPaths(options = {}) {
     dotenv.config();
     dotenv.config({ path: '.env.local' });
     const cwd = options.cwd ?? process.cwd();
     const wpDataPath = options.wpDataPath ?? 'public/wordpress-data.json';
+    const phplistDataPath = options.phplistDataPath ?? 'public/phplist-data.json';
     const staticInputPath = options.staticInputPath ?? 'public/sitemap-static-paths.json';
     const outputPath = options.outputPath ?? 'public/sitemap-paths.json';
-    const allowedHosts = getAllowedHosts();
-    const merged = new Set();
-    for (const p of loadStaticPaths(cwd, staticInputPath, allowedHosts)) {
-        merged.add(normalizePathname(p));
-    }
-    const wpFull = path.join(cwd, wpDataPath);
-    if (fs.existsSync(wpFull)) {
-        try {
-            const raw = fs.readFileSync(wpFull, 'utf8');
-            const data = JSON.parse(raw);
-            const fromWp = collectPathsFromWpData(data, allowedHosts);
-            for (const p of fromWp) {
-                merged.add(p);
-            }
-        }
-        catch (e) {
-            console.warn('⚠️  Could not parse wordpress-data.json for sitemap paths:', e.message);
-        }
-    }
-    merged.add('/');
-    const sorted = [...merged].sort((a, b) => {
-        if (a === '/')
-            return -1;
-        if (b === '/')
-            return 1;
-        return a.localeCompare(b);
+    const urls = collectSitemapUrls({
+        wpData: loadJson$1(path.join(cwd, wpDataPath)),
+        phplistData: loadJson$1(path.join(cwd, phplistDataPath)),
+        staticPaths: loadStaticPaths(cwd, staticInputPath),
+        prefixes: parseRoutePrefixes(),
     });
     const outFull = path.join(cwd, outputPath);
     fs.mkdirSync(path.dirname(outFull), { recursive: true });
-    fs.writeFileSync(outFull, `${JSON.stringify({ paths: sorted }, null, 2)}\n`, 'utf8');
-    console.log(`📍 Sitemap paths written (${sorted.length} URLs): ${outFull}`);
+    if (urls.length <= SITEMAP_URL_SHARD_SIZE) {
+        writeShard(outFull, urls);
+        console.log(`📍 Sitemap paths written (${urls.length} URLs): ${outFull}`);
+        return;
+    }
+    const parts = Math.ceil(urls.length / SITEMAP_URL_SHARD_SIZE);
+    const dir = path.dirname(outFull);
+    const base = path.basename(outFull, path.extname(outFull));
+    const ext = path.extname(outFull) || '.json';
+    for (let i = 0; i < parts; i++) {
+        const slice = urls.slice(i * SITEMAP_URL_SHARD_SIZE, (i + 1) * SITEMAP_URL_SHARD_SIZE);
+        writeShard(path.join(dir, `${base}-${i}${ext}`), slice);
+    }
+    fs.writeFileSync(outFull, `${JSON.stringify({ index: true, parts }, null, 2)}\n`, 'utf8');
+    console.log(`📍 Sitemap index written (${urls.length} URLs, ${parts} parts): ${outFull}`);
 }
 async function generateSitemapPathsSafe(options = {}) {
     try {
@@ -573,45 +721,747 @@ async function generateSitemapPathsSafe(options = {}) {
     }
 }
 
+const getImportMetaEnv = () => {
+    try {
+        return typeof ({ url: (typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('index.cjs', document.baseURI).href)) }) !== 'undefined' ? undefined : undefined;
+    }
+    catch {
+        return undefined;
+    }
+};
+const getEnv = (key) => {
+    const viteEnv = getImportMetaEnv();
+    if (viteEnv && key in viteEnv) {
+        const value = viteEnv[key];
+        return value == null ? undefined : String(value);
+    }
+    if (typeof process !== 'undefined' && process.env && key in process.env) {
+        const value = process.env[key];
+        return value == null ? undefined : String(value);
+    }
+    return undefined;
+};
+const isDevEnvironment = () => {
+    const viteEnv = getImportMetaEnv();
+    if (viteEnv && 'DEV' in viteEnv) {
+        return Boolean(viteEnv.DEV);
+    }
+    return typeof process !== 'undefined' && process.env?.NODE_ENV === 'development';
+};
+
+/**
+ * Integration Configuration
+ * Centralized configuration for all third-party integrations
+ */
+function envBool(key, defaultValue) {
+    const v = getEnv(key);
+    if (v === undefined || v === '')
+        return defaultValue;
+    const lower = v.toLowerCase();
+    if (lower === 'false' || lower === '0' || lower === 'no')
+        return false;
+    if (lower === 'true' || lower === '1' || lower === 'yes')
+        return true;
+    return defaultValue;
+}
+/**
+ * Get integration configuration with environment variable fallbacks
+ */
+function getIntegrationConfig() {
+    isDevEnvironment();
+    return {
+        wordpress: {
+            enabled: true,
+            apiUrl: getEnv('VITE_WORDPRESS_API_URL') || '',
+            authMode: getEnv('VITE_AUTH_MODE') || 'direct',
+        },
+        supabase: {
+            enabled: getEnv('VITE_AUTH_MODE') === 'supabase_proxy',
+            url: getEnv('VITE_SUPABASE_URL') || '',
+            anonKey: getEnv('VITE_SUPABASE_ANON_KEY') || '',
+            serviceRoleKey: getEnv('VITE_SUPABASE_SERVICE_ROLE_KEY'),
+        },
+        gravityForms: {
+            enabled: !!(getEnv('VITE_CLOUDFLARE_WORKER_URL') || getEnv('VITE_WORDPRESS_API_URL')),
+            url: getEnv('VITE_WORDPRESS_API_URL'),
+            proxyUrl: getEnv('VITE_CLOUDFLARE_WORKER_URL'),
+            consumerKey: getEnv('VITE_GF_CONSUMER_KEY'),
+            consumerSecret: getEnv('VITE_GF_CONSUMER_SECRET'),
+            forms: {
+                'contact': {
+                    name: 'Contact Form',
+                    type: 'contact',
+                    successMessage: 'Thank you for your message. We\'ll get back to you soon!',
+                },
+                'newsletter': {
+                    name: 'Newsletter Signup',
+                    type: 'newsletter',
+                    successMessage: 'Thank you for subscribing to our newsletter!',
+                },
+                'support': {
+                    name: 'Support Request',
+                    type: 'support',
+                    successMessage: 'Your support request has been submitted successfully.',
+                },
+            },
+        },
+        mautic: {
+            enabled: !!(getEnv('VITE_MAUTIC_PROXY_URL') || getEnv('VITE_MAUTIC_URL')),
+            url: getEnv('VITE_MAUTIC_URL') || '',
+            proxyUrl: getEnv('VITE_MAUTIC_PROXY_URL'),
+            forms: {
+                '1': {
+                    name: 'Newsletter Signup',
+                    type: 'newsletter',
+                    successMessage: 'Thank you for subscribing to our newsletter!',
+                    postAction: 'message',
+                    postActionProperty: 'Thank you for your submission!'
+                },
+                '2': {
+                    name: 'Contact Form',
+                    type: 'contact',
+                    successMessage: 'Thank you for contacting us! We\'ll get back to you soon.',
+                    postAction: 'message',
+                    postActionProperty: 'Thank you for your message!'
+                },
+                '3': {
+                    name: 'Lead Capture',
+                    type: 'lead',
+                    successMessage: 'Thank you for your interest! We\'ll be in touch.',
+                    postAction: 'message',
+                    postActionProperty: 'Thank you for your submission!'
+                }
+            }
+        },
+        phplist: {
+            enabled: !!(getEnv('VITE_PHPLIST_URL') || getEnv('PHPLIST_URL')),
+            url: getEnv('VITE_PHPLIST_URL') || getEnv('PHPLIST_URL'),
+            proxyUrl: getEnv('VITE_PHPLIST_PROXY_URL') || getEnv('PHPLIST_PROXY_URL'),
+            listId: parseInt(getEnv('VITE_PHPLIST_LIST_ID') || getEnv('PHPLIST_LIST_ID') || '0', 10) || undefined,
+            subscribePageIds: (getEnv('VITE_PHPLIST_SUBSCRIBE_PAGE_IDS') || getEnv('PHPLIST_SUBSCRIBE_PAGE_IDS') || '')
+                .split(',')
+                .map((s) => parseInt(s.trim(), 10))
+                .filter((n) => !Number.isNaN(n)),
+            newsletterRouteBase: getEnv('VITE_PHPLIST_NEWSLETTER_ROUTE_BASE') || '/newsletters',
+        },
+        suiteCRM: {
+            enabled: !!(getEnv('VITE_SUITECRM_URL') && getEnv('VITE_SUITECRM_CLIENT_ID') && getEnv('VITE_SUITECRM_CLIENT_SECRET')),
+            url: getEnv('VITE_SUITECRM_URL'),
+            proxyUrl: getEnv('VITE_SUITECRM_PROXY_URL'),
+            appId: undefined,
+            workerSecret: undefined,
+            oauth2: {
+                clientId: getEnv('VITE_SUITECRM_CLIENT_ID'),
+                clientSecret: getEnv('VITE_SUITECRM_CLIENT_SECRET'),
+                username: getEnv('VITE_SUITECRM_USERNAME'),
+                password: getEnv('VITE_SUITECRM_PASSWORD'),
+            },
+        },
+        chatwoot: {
+            enabled: !!(getEnv('VITE_CHATWOOT_WEBSITE_TOKEN') && getEnv('VITE_CHATWOOT_BASE_URL')),
+            websiteToken: getEnv('VITE_CHATWOOT_WEBSITE_TOKEN') || '',
+            baseUrl: getEnv('VITE_CHATWOOT_BASE_URL') || '',
+            locale: 'en',
+            type: 'standard',
+            launcherTitle: 'Chat',
+            hideMessageBubble: false,
+            position: 'right',
+            showPopoutButton: false,
+        },
+        analytics: {
+            googleAnalytics: { enabled: false },
+            googleTagManager: { enabled: false },
+            facebookPixel: { enabled: false },
+            linkedinInsight: { enabled: false },
+        },
+        seo: (() => {
+            const opt = (key) => {
+                const v = getEnv(key);
+                if (v === undefined || v === '')
+                    return undefined;
+                const t = v.trim();
+                return t || undefined;
+            };
+            const siteUrl = (getEnv('VITE_SEO_SITE_URL') || '').replace(/\/+$/, '').trim();
+            const siteName = (getEnv('VITE_SEO_SITE_NAME') || '').trim();
+            const defaultTitle = (getEnv('VITE_SEO_DEFAULT_TITLE') || '').trim() || siteName || '';
+            return {
+                defaultTitle,
+                defaultDescription: (getEnv('VITE_SEO_DEFAULT_DESCRIPTION') || '').trim(),
+                defaultKeywords: opt('VITE_SEO_DEFAULT_KEYWORDS'),
+                defaultImage: (getEnv('VITE_SEO_DEFAULT_OG_IMAGE') || '').trim(),
+                siteName,
+                siteUrl,
+                twitterHandle: opt('VITE_SEO_TWITTER_SITE'),
+                facebookAppId: opt('VITE_SEO_FACEBOOK_APP_ID'),
+                googleSiteVerification: opt('VITE_SEO_GOOGLE_SITE_VERIFICATION'),
+                bingSiteVerification: opt('VITE_SEO_BING_SITE_VERIFICATION'),
+            };
+        })(),
+        performance: {
+            enableLazyLoading: envBool('VITE_PERF_LAZY_LOADING', true),
+            enableImageOptimization: envBool('VITE_PERF_IMAGE_OPTIMIZATION', true),
+            enableCodeSplitting: envBool('VITE_PERF_CODE_SPLITTING', true),
+            enableServiceWorker: envBool('VITE_PERF_SERVICE_WORKER', false),
+            enableCaching: envBool('VITE_PERF_CACHING', true),
+        }
+    };
+}
+function getSEOConfig() {
+    return getIntegrationConfig().seo;
+}
+
+/**
+ * SEO defaults from env-backed integration config (see `VITE_SEO_*` in docs).
+ */
+function getSeoDefaultsFromEnv() {
+    const seo = getSEOConfig();
+    return {
+        siteUrl: seo.siteUrl,
+        siteName: seo.siteName,
+        defaultTitle: seo.defaultTitle,
+        defaultDescription: seo.defaultDescription,
+        defaultKeywords: seo.defaultKeywords,
+        defaultImage: seo.defaultImage,
+        twitterHandle: seo.twitterHandle,
+        facebookAppId: seo.facebookAppId,
+        googleSiteVerification: seo.googleSiteVerification,
+        bingSiteVerification: seo.bingSiteVerification,
+    };
+}
+
+function firstNonEmpty(...values) {
+    for (const v of values) {
+        if (typeof v === 'string' && v.trim())
+            return v.trim();
+    }
+    return '';
+}
+function resolvePageSeo(entity, pathname, overrides) {
+    const d = getSeoDefaultsFromEnv();
+    const seo = entity?.digivalt_seo;
+    const title = firstNonEmpty(overrides?.title, seo?.title, renderedText(entity?.title), d.defaultTitle, d.siteName);
+    const description = firstNonEmpty(overrides?.description, seo?.description, renderedText(entity?.excerpt), d.defaultDescription);
+    const imageUrl = firstNonEmpty(overrides?.imageUrl, seo?.og_image, entity?.featured_media_cloudflare_url, entity?.featured_media_url, d.defaultImage);
+    const noindex = overrides?.noindex ?? seo?.robots_index === false;
+    const ogType = overrides?.ogType || seo?.og_type || 'website';
+    const canonicalUrl = firstNonEmpty(overrides?.canonicalUrl, seo?.canonical) || undefined;
+    const robotsFollow = seo?.robots_follow !== false;
+    let robots;
+    if (noindex && robotsFollow)
+        robots = 'noindex, follow';
+    else if (noindex)
+        robots = 'noindex, nofollow';
+    else if (!robotsFollow)
+        robots = 'index, nofollow';
+    return {
+        entity,
+        noindex,
+        head: {
+            pathname,
+            title: title || undefined,
+            description: description || undefined,
+            imageUrl: imageUrl || undefined,
+            canonicalUrl,
+            ogType,
+            noindex,
+            robots,
+        },
+    };
+}
+
+const createOrganizationSchema = (data) => ({
+    '@context': 'https://schema.org',
+    '@type': 'Organization',
+    name: data.name,
+    url: data.url,
+    ...(data.logo && { logo: data.logo }),
+    ...(data.description && { description: data.description }),
+    ...(data.address && {
+        address: {
+            '@type': 'PostalAddress',
+            ...data.address,
+        },
+    }),
+    ...(data.contactPoint && {
+        contactPoint: {
+            '@type': 'ContactPoint',
+            ...data.contactPoint,
+        },
+    }),
+});
+const createWebSiteSchema = (data) => ({
+    '@context': 'https://schema.org',
+    '@type': 'WebSite',
+    name: data.name,
+    url: data.url,
+    ...(data.description && { description: data.description }),
+    ...(data.publisher && { publisher: data.publisher }),
+});
+const createArticleSchema = (data) => ({
+    '@context': 'https://schema.org',
+    '@type': 'Article',
+    headline: data.headline,
+    description: data.description,
+    ...(data.image && { image: data.image }),
+    author: {
+        '@type': 'Person',
+        name: data.author,
+    },
+    publisher: {
+        '@type': 'Organization',
+        name: data.publisher,
+    },
+    datePublished: data.datePublished,
+    ...(data.dateModified && { dateModified: data.dateModified }),
+    url: data.url,
+});
+const createServiceSchema = (data) => ({
+    '@context': 'https://schema.org',
+    '@type': 'Service',
+    name: data.name,
+    description: data.description,
+    provider: {
+        '@type': 'Organization',
+        name: data.provider,
+    },
+    url: data.url,
+    ...(data.areaServed && { areaServed: data.areaServed }),
+    ...(data.serviceType && { serviceType: data.serviceType }),
+});
+const createFAQSchema = (faqs) => ({
+    '@context': 'https://schema.org',
+    '@type': 'FAQPage',
+    mainEntity: faqs.map(faq => ({
+        '@type': 'Question',
+        name: faq.question,
+        acceptedAnswer: {
+            '@type': 'Answer',
+            text: faq.answer,
+        },
+    })),
+});
+
+function joinAbsoluteUrl(siteUrl, pathname) {
+    const base = siteUrl.replace(/\/+$/, '');
+    if (pathname === '/')
+        return base || pathname;
+    const p = pathname.startsWith('/') ? pathname : `/${pathname}`;
+    return base ? `${base}${p}` : p;
+}
+function extraToList(extra) {
+    if (!extra)
+        return [];
+    if (Array.isArray(extra)) {
+        return extra.filter((x) => !!x && typeof x === 'object');
+    }
+    if (typeof extra === 'object')
+        return [extra];
+    return [];
+}
+/**
+ * JSON-LD for a route: WebSite + Organization (from env) plus page schema from DigiValt SEO fields.
+ */
+function buildPageJsonLd(entity, pathname, options) {
+    const d = getSeoDefaultsFromEnv();
+    const seo = entity?.digivalt_seo;
+    const title = options?.title ||
+        seo?.title ||
+        renderedText(entity?.title) ||
+        d.defaultTitle ||
+        d.siteName;
+    const description = options?.description ||
+        seo?.description ||
+        renderedText(entity?.excerpt) ||
+        d.defaultDescription;
+    const image = options?.imageUrl ||
+        seo?.og_image ||
+        entity?.featured_media_cloudflare_url ||
+        entity?.featured_media_url ||
+        d.defaultImage;
+    const url = options?.canonicalUrl ||
+        seo?.canonical ||
+        (d.siteUrl ? joinAbsoluteUrl(d.siteUrl, pathname || '/') : pathname);
+    const out = [];
+    if (d.siteName && d.siteUrl) {
+        out.push(createWebSiteSchema({
+            name: d.siteName,
+            url: d.siteUrl,
+            description: d.defaultDescription || undefined,
+        }));
+        out.push(createOrganizationSchema({
+            name: d.siteName,
+            url: d.siteUrl,
+            logo: d.defaultImage || undefined,
+            description: d.defaultDescription || undefined,
+        }));
+    }
+    const schemaType = seo?.schema_type || 'WebPage';
+    if (schemaType === 'Article') {
+        out.push(createArticleSchema({
+            headline: title,
+            description: description || title,
+            image: image || undefined,
+            author: d.siteName || 'Publisher',
+            publisher: d.siteName || 'Publisher',
+            datePublished: entity?.date_gmt || entity?.date || new Date().toISOString(),
+            dateModified: entity?.modified_gmt || entity?.modified,
+            url,
+        }));
+    }
+    else if (schemaType === 'Service') {
+        out.push(createServiceSchema({
+            name: title,
+            description: description || title,
+            provider: d.siteName || title,
+            url,
+        }));
+    }
+    else if (schemaType === 'FAQPage' || (seo?.faq && seo.faq.length > 0)) {
+        const faqs = (seo?.faq || []).filter((f) => f.question && f.answer);
+        if (faqs.length) {
+            out.push(createFAQSchema(faqs));
+        }
+        else {
+            out.push({
+                '@context': 'https://schema.org',
+                '@type': 'WebPage',
+                name: title,
+                description: description || undefined,
+                url,
+            });
+        }
+    }
+    else {
+        out.push({
+            '@context': 'https://schema.org',
+            '@type': 'WebPage',
+            name: title,
+            description: description || undefined,
+            url,
+        });
+    }
+    out.push(...extraToList(seo?.extra_json_ld));
+    return out;
+}
+
+function loadJson(full) {
+    if (!fs.existsSync(full))
+        return undefined;
+    try {
+        const data = JSON.parse(fs.readFileSync(full, 'utf8'));
+        if (data && typeof data === 'object' && !Array.isArray(data)) {
+            return data;
+        }
+    }
+    catch {
+        /* ignore */
+    }
+    return undefined;
+}
+function parseStaticPaths(full) {
+    if (!fs.existsSync(full))
+        return [];
+    try {
+        const data = JSON.parse(fs.readFileSync(full, 'utf8'));
+        const list = Array.isArray(data)
+            ? data
+            : data && typeof data === 'object' && Array.isArray(data.paths)
+                ? data.paths
+                : [];
+        return list.filter((p) => typeof p === 'string' && p.startsWith('/')).map(normalizePathname);
+    }
+    catch {
+        return [];
+    }
+}
+function asEntity(item) {
+    if (!item || typeof item !== 'object')
+        return undefined;
+    return item;
+}
+function findEntityForPath(pathname, wpData, phplistData) {
+    const front = wpData ? getFrontPageRef(wpData) : {};
+    const pages = wpData && Array.isArray(wpData.pages) ? wpData.pages : [];
+    if (pathname === '/') {
+        const hit = pages.find((p) => {
+            const ent = asEntity(p);
+            if (!ent)
+                return false;
+            if (front.slug && ent.slug === front.slug)
+                return true;
+            if (typeof front.id === 'number' && typeof p.id === 'number') {
+                return p.id === front.id;
+            }
+            return false;
+        });
+        return asEntity(hit);
+    }
+    const pageSlug = pathname.replace(/^\//, '');
+    const pageHit = pages.find((p) => asEntity(p)?.slug === pageSlug);
+    if (pageHit)
+        return asEntity(pageHit);
+    const prefixes = parseRoutePrefixes();
+    for (const [type, prefix] of Object.entries(prefixes)) {
+        const normalizedPrefix = normalizePathname(prefix.startsWith('/') ? prefix : `/${prefix}`);
+        if (pathname === normalizedPrefix)
+            continue;
+        if (!pathname.startsWith(`${normalizedPrefix}/`))
+            continue;
+        const slug = pathname.slice(normalizedPrefix.length).replace(/^\//, '');
+        const arr = wpData?.[type];
+        if (!Array.isArray(arr))
+            continue;
+        const hit = arr.find((p) => asEntity(p)?.slug === slug);
+        if (hit)
+            return asEntity(hit);
+    }
+    const nBase = newsletterRouteBase();
+    if (pathname.startsWith(`${nBase}/`) || (nBase !== '/' && pathname.startsWith(`${nBase}/`))) {
+        const slug = nBase === '/' ? pathname.replace(/^\//, '') : pathname.slice(nBase.length).replace(/^\//, '');
+        const newsletters = phplistData && Array.isArray(phplistData.newsletters) ? phplistData.newsletters : [];
+        const hit = newsletters.find((n) => n && typeof n === 'object' && n.slug === slug);
+        if (hit && typeof hit === 'object') {
+            const rec = hit;
+            return {
+                slug: rec.slug,
+                title: { rendered: rec.subject || '' },
+                excerpt: { rendered: rec.excerpt || '' },
+                content: { rendered: rec.html || '' },
+                date: rec.sent_at,
+                modified: rec.sent_at,
+            };
+        }
+    }
+    return undefined;
+}
+async function generateSeoManifest(options = {}) {
+    dotenv.config();
+    dotenv.config({ path: '.env.local' });
+    const cwd = options.cwd ?? process.cwd();
+    const wpDataPath = options.wpDataPath ?? 'public/wordpress-data.json';
+    const phplistDataPath = options.phplistDataPath ?? 'public/phplist-data.json';
+    const staticInputPath = options.staticInputPath ?? 'public/sitemap-static-paths.json';
+    const manifestOutputPath = options.manifestOutputPath ?? 'public/seo-manifest.json';
+    const wpData = loadJson(path.join(cwd, wpDataPath));
+    const phplistData = loadJson(path.join(cwd, phplistDataPath));
+    const staticPaths = parseStaticPaths(path.join(cwd, staticInputPath));
+    const urls = collectSitemapUrls({
+        wpData,
+        phplistData,
+        staticPaths,
+        prefixes: parseRoutePrefixes(),
+    });
+    const defaults = getSeoDefaultsFromEnv();
+    const entries = urls.map((u) => {
+        const entity = findEntityForPath(u.path, wpData, phplistData);
+        const resolved = resolvePageSeo(entity, u.path);
+        const jsonLd = buildPageJsonLd(entity, u.path, {
+            title: resolved.head.title,
+            description: resolved.head.description,
+            imageUrl: resolved.head.imageUrl,
+            canonicalUrl: resolved.head.canonicalUrl,
+        });
+        const bodySource = (typeof entity?.content_cloudflare === 'string' && entity.content_cloudflare) ||
+            renderedHtml(entity?.content);
+        return {
+            path: u.path,
+            title: resolved.head.title || defaults.defaultTitle || defaults.siteName || '',
+            description: resolved.head.description || defaults.defaultDescription || '',
+            canonical: resolved.head.canonicalUrl,
+            image: resolved.head.imageUrl || u.image,
+            noindex: resolved.noindex,
+            ogType: resolved.head.ogType,
+            jsonLd,
+            bodyHtml: bodySource ? sanitizeBodyHtml(bodySource) : '',
+        };
+    });
+    const full = path.join(cwd, manifestOutputPath);
+    fs.mkdirSync(path.dirname(full), { recursive: true });
+    fs.writeFileSync(full, `${JSON.stringify({ generated_at: new Date().toISOString(), urls: entries }, null, 2)}\n`, 'utf8');
+    console.log(`📍 SEO manifest written (${entries.length} URLs): ${full}`);
+}
+async function generateSeoManifestSafe(options = {}) {
+    try {
+        await generateSeoManifest(options);
+    }
+    catch (e) {
+        console.error('❌ SEO manifest generation failed:', e.message);
+        const cwd = options.cwd ?? process.cwd();
+        const manifestOutputPath = options.manifestOutputPath ?? 'public/seo-manifest.json';
+        const full = path.join(cwd, manifestOutputPath);
+        fs.mkdirSync(path.dirname(full), { recursive: true });
+        fs.writeFileSync(full, `${JSON.stringify({ urls: [] }, null, 2)}\n`, 'utf8');
+    }
+}
+
+function upsertMeta(html, attrName, attrValue, content) {
+    const re = new RegExp(`<meta\\s+[^>]*${attrName}=["']${attrValue.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}["'][^>]*>`, 'i');
+    const tag = `<meta ${attrName}="${escapeAttr(attrValue)}" content="${escapeAttr(content)}" />`;
+    if (re.test(html))
+        return html.replace(re, tag);
+    return html.replace(/<\/head>/i, `    ${tag}\n  </head>`);
+}
+function upsertLink(html, rel, href) {
+    const re = new RegExp(`<link\\s+[^>]*rel=["']${rel}["'][^>]*>`, 'i');
+    const tag = `<link rel="${escapeAttr(rel)}" href="${escapeAttr(href)}" />`;
+    if (re.test(html))
+        return html.replace(re, tag);
+    return html.replace(/<\/head>/i, `    ${tag}\n  </head>`);
+}
+function injectJsonLd(html, blocks) {
+    if (!blocks?.length)
+        return html;
+    const scripts = blocks
+        .map((b) => `<script type="application/ld+json">${JSON.stringify(b).replace(/</g, '\\u003c')}</script>`)
+        .join('\n    ');
+    return html.replace(/<\/head>/i, `    ${scripts}\n  </head>`);
+}
+function applyEntry(html, entry) {
+    let out = html;
+    if (entry.title) {
+        out = out.replace(/<title>[\s\S]*?<\/title>/i, `<title>${escapeHtml(entry.title)}</title>`);
+    }
+    if (entry.description) {
+        out = upsertMeta(out, 'name', 'description', entry.description);
+        out = upsertMeta(out, 'property', 'og:description', entry.description);
+    }
+    if (entry.title) {
+        out = upsertMeta(out, 'property', 'og:title', entry.title);
+        out = upsertMeta(out, 'name', 'twitter:title', entry.title);
+    }
+    if (entry.canonical) {
+        out = upsertLink(out, 'canonical', entry.canonical);
+        out = upsertMeta(out, 'property', 'og:url', entry.canonical);
+    }
+    if (entry.image) {
+        out = upsertMeta(out, 'property', 'og:image', entry.image);
+        out = upsertMeta(out, 'name', 'twitter:image', entry.image);
+    }
+    if (entry.ogType) {
+        out = upsertMeta(out, 'property', 'og:type', entry.ogType);
+    }
+    if (entry.noindex) {
+        out = upsertMeta(out, 'name', 'robots', 'noindex, nofollow');
+    }
+    out = injectJsonLd(out, entry.jsonLd);
+    const snapshot = `<article data-digivalt-prerender><h1>${escapeHtml(entry.title || '')}</h1>${entry.description ? `<p>${escapeHtml(entry.description)}</p>` : ''}${entry.bodyHtml || ''}</article>`;
+    if (/<div id="root"><\/div>/i.test(out)) {
+        out = out.replace(/<div id="root"><\/div>/i, `<div id="root">${snapshot}</div>`);
+    }
+    else if (/<div id="root">[\s\S]*?<\/div>/i.test(out)) {
+        out = out.replace(/<div id="root">[\s\S]*?<\/div>/i, `<div id="root">${snapshot}</div>`);
+    }
+    return out;
+}
+function distFileForPath(distAbs, urlPath) {
+    if (urlPath === '/')
+        return path.join(distAbs, 'index.html');
+    const rel = urlPath.replace(/^\//, '');
+    return path.join(distAbs, rel, 'index.html');
+}
+async function prerenderSeoHtml(options = {}) {
+    dotenv.config();
+    dotenv.config({ path: '.env.local' });
+    const cwd = options.cwd ?? process.cwd();
+    const distDir = options.distDir ?? 'dist';
+    const distAbs = path.join(cwd, distDir);
+    const indexFile = path.join(distAbs, 'index.html');
+    if (!fs.existsSync(indexFile)) {
+        console.warn('⚠️  prerenderSeoHtml: dist/index.html missing; skip.');
+        return;
+    }
+    const manifestCandidates = [
+        options.manifestPath ? path.join(cwd, options.manifestPath) : '',
+        path.join(distAbs, 'seo-manifest.json'),
+        path.join(cwd, 'public', 'seo-manifest.json'),
+    ].filter(Boolean);
+    let manifestRaw;
+    for (const p of manifestCandidates) {
+        if (fs.existsSync(p)) {
+            manifestRaw = fs.readFileSync(p, 'utf8');
+            break;
+        }
+    }
+    if (!manifestRaw) {
+        console.warn('⚠️  prerenderSeoHtml: seo-manifest.json missing; skip.');
+        return;
+    }
+    let urls = [];
+    try {
+        const data = JSON.parse(manifestRaw);
+        urls = Array.isArray(data.urls) ? data.urls : [];
+    }
+    catch (e) {
+        console.warn('⚠️  prerenderSeoHtml: invalid manifest:', e.message);
+        return;
+    }
+    const template = fs.readFileSync(indexFile, 'utf8');
+    let written = 0;
+    for (const entry of urls) {
+        if (!entry?.path)
+            continue;
+        const html = applyEntry(template, entry);
+        const dest = distFileForPath(distAbs, entry.path);
+        fs.mkdirSync(path.dirname(dest), { recursive: true });
+        fs.writeFileSync(dest, html, 'utf8');
+        written += 1;
+    }
+    console.log(`📍 Prerendered ${written} HTML snapshots into ${distAbs}`);
+}
+
 async function generateAllData() {
-    // Load .env files if they exist (for local development)
     dotenv.config();
     dotenv.config({ path: '.env.local' });
     console.log('🚀 Starting DigiVAlt static data generation...');
     if (process.env.VITE_IS_LOVABLE === 'true') {
-        console.log('⚡ Lovable Environment Detected (VITE_IS_LOVABLE). Skipping static data generation to use GitHub synced static files.');
-        return;
+        console.log('⚡ Fixture mode (`VITE_IS_LOVABLE`) enabled. Skipping remote fetch; refreshing sitemap and SEO manifest from committed JSON.');
     }
-    const wpSuccess = await generateWordPressData();
-    const gfSuccess = await generateGravityFormsData();
-    // Optional integrations — warn-only (same as PHPList); do not block deploy
-    await generateMauticData();
-    await generatePhplistData();
-    await generateSuiteCRMData();
-    await generateGoogleReviewsData();
-    if (!wpSuccess || !gfSuccess) {
-        console.error('❌ Required generation failed (WordPress or Gravity Forms). See above for details.');
-        process.exit(1);
+    else {
+        const wpSuccess = await generateWordPressData();
+        const gfSuccess = await generateGravityFormsData();
+        await generateMauticData();
+        await generatePhplistData();
+        await generateSuiteCRMData();
+        await generateGoogleReviewsData();
+        if (!wpSuccess || !gfSuccess) {
+            console.error('❌ Required generation failed (WordPress or Gravity Forms). See above for details.');
+            process.exit(1);
+        }
     }
     await generateSitemapPathsSafe();
+    await generateSeoManifestSafe();
     console.log('✅ Generation complete!');
 }
 
 var index = /*#__PURE__*/Object.freeze({
     __proto__: null,
     PSEUDO_POST_TYPES: PSEUDO_POST_TYPES,
+    SITEMAP_URL_SHARD_SIZE: SITEMAP_URL_SHARD_SIZE,
+    collectSitemapUrls: collectSitemapUrls,
+    entityImage: entityImage,
+    entityLastmod: entityLastmod,
     generateAllData: generateAllData,
     generateGoogleReviewsData: generateGoogleReviewsData,
     generateGravityFormsData: generateGravityFormsData,
     generateMauticData: generateMauticData,
     generatePhplistData: generatePhplistData,
+    generateSeoManifest: generateSeoManifest,
+    generateSeoManifestSafe: generateSeoManifestSafe,
     generateSitemapPaths: generateSitemapPaths,
     generateSitemapPathsSafe: generateSitemapPathsSafe,
     generateSuiteCRMData: generateSuiteCRMData,
     generateWordPressData: generateWordPressData,
+    getFrontPageRef: getFrontPageRef,
+    getFrontPageSlug: getFrontPageSlug,
     getWordPressPostTypes: getWordPressPostTypes,
     isGoogleReviewsEnabled: isGoogleReviewsEnabled,
-    parseEnabledPostTypes: parseEnabledPostTypes
+    isNoindexEntity: isNoindexEntity,
+    isPublishedEntity: isPublishedEntity,
+    newsletterRouteBase: newsletterRouteBase,
+    parseEnabledPostTypes: parseEnabledPostTypes,
+    parseRoutePrefixes: parseRoutePrefixes,
+    prerenderSeoHtml: prerenderSeoHtml
 });
 
 /**
@@ -623,18 +1473,31 @@ const getDigiValtVersion = () => {
 };
 
 exports.PSEUDO_POST_TYPES = PSEUDO_POST_TYPES;
+exports.SITEMAP_URL_SHARD_SIZE = SITEMAP_URL_SHARD_SIZE;
+exports.collectSitemapUrls = collectSitemapUrls;
+exports.entityImage = entityImage;
+exports.entityLastmod = entityLastmod;
 exports.generateAllData = generateAllData;
 exports.generateGoogleReviewsData = generateGoogleReviewsData;
 exports.generateGravityFormsData = generateGravityFormsData;
 exports.generateMauticData = generateMauticData;
 exports.generatePhplistData = generatePhplistData;
+exports.generateSeoManifest = generateSeoManifest;
+exports.generateSeoManifestSafe = generateSeoManifestSafe;
 exports.generateSitemapPaths = generateSitemapPaths;
 exports.generateSitemapPathsSafe = generateSitemapPathsSafe;
 exports.generateSuiteCRMData = generateSuiteCRMData;
 exports.generateWordPressData = generateWordPressData;
 exports.generators = index;
 exports.getDigiValtVersion = getDigiValtVersion;
+exports.getFrontPageRef = getFrontPageRef;
+exports.getFrontPageSlug = getFrontPageSlug;
 exports.getWordPressPostTypes = getWordPressPostTypes;
 exports.isGoogleReviewsEnabled = isGoogleReviewsEnabled;
+exports.isNoindexEntity = isNoindexEntity;
+exports.isPublishedEntity = isPublishedEntity;
+exports.newsletterRouteBase = newsletterRouteBase;
 exports.parseEnabledPostTypes = parseEnabledPostTypes;
+exports.parseRoutePrefixes = parseRoutePrefixes;
+exports.prerenderSeoHtml = prerenderSeoHtml;
 //# sourceMappingURL=index.cjs.map