@marvalt/digivalt-core 0.2.24 → 0.2.25

package/dist/index.esm.js

@@ -1,1828 +1,11 @@
 import dotenv from 'dotenv';
-import path, { join, dirname } from 'path';
-import fs, { writeFileSync } from 'fs';
+import path from 'path';
+import { generateWordPressData as generateWordPressData$1, generateGravityFormsData as generateGravityFormsData$1 } from '@marvalt/wadapter/generators';
+import { generateMauticData as generateMauticData$1 } from '@marvalt/madapter/generators';
+import { generatePhplistData as generatePhplistData$1 } from '@marvalt/plister/generators';
 import { generateSuiteCRMData as generateSuiteCRMData$1 } from '@marvalt/sadapter';
 import { mkdir, writeFile } from 'fs/promises';
-
-/**
- * @license GPL-3.0-or-later
- *
- * This file is part of the MarVAlt Open SDK.
- * Copyright (c) 2025 Vibune Pty Ltd.
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
- * See the GNU General Public License for more details.
- */
-class WordPressClient {
-    constructor(config) {
-        this.config = config;
-    }
-    async makeRequest(endpoint, params = {}, options = {}) {
-        const baseUrl = this.getBaseUrl();
-        const queryString = new URLSearchParams();
-        Object.entries(params).forEach(([key, value]) => {
-            if (value !== undefined && value !== null) {
-                if (Array.isArray(value)) {
-                    value.forEach(v => queryString.append(key, v.toString()));
-                }
-                else {
-                    queryString.append(key, value.toString());
-                }
-            }
-        });
-        // Construct URL based on auth mode
-        let url;
-        if (this.config.authMode === 'cloudflare_proxy') {
-            // For proxy modes, pass the full REST path including /wp-json as query parameter
-            const fullEndpoint = `/wp-json${endpoint}?${queryString.toString()}`;
-            url = `${baseUrl}?endpoint=${encodeURIComponent(fullEndpoint)}`;
-        }
-        else {
-            // For direct mode, construct the full WordPress API URL
-            url = `${baseUrl}/wp-json${endpoint}?${queryString.toString()}`;
-        }
-        const headers = {
-            'Content-Type': 'application/json',
-        };
-        // Add authentication based on mode
-        if (this.config.authMode === 'cloudflare_proxy') ;
-        else {
-            // Direct mode - use basic auth
-            if (this.config.username && this.config.password) {
-                const credentials = btoa(`${this.config.username}:${this.config.password}`);
-                headers.Authorization = `Basic ${credentials}`;
-            }
-            // Add Cloudflare Access Service Token headers if provided (for CF Access protected APIs)
-            if (this.config.cfAccessClientId && this.config.cfAccessClientSecret) {
-                headers['CF-Access-Client-Id'] = this.config.cfAccessClientId;
-                headers['CF-Access-Client-Secret'] = this.config.cfAccessClientSecret;
-                console.log('🔐 Added CF Access Service Token headers to WordPress request');
-                console.log('🔐 CF-Access-Client-Id:', this.config.cfAccessClientId.substring(0, 8) + '...');
-                console.log('🔐 CF-Access-Client-Secret:', this.config.cfAccessClientSecret.substring(0, 8) + '... (hidden)');
-            }
-            else {
-                console.log('⚠️  CF Access Service Token NOT provided - requests may be blocked by Zero Trust');
-                console.log('   cfAccessClientId present:', !!this.config.cfAccessClientId);
-                console.log('   cfAccessClientSecret present:', !!this.config.cfAccessClientSecret);
-            }
-        }
-        console.log('🔍 WordPress API Request Debug:', {
-            url,
-            method: options.method || 'GET',
-            authMode: this.config.authMode,
-            headers: Object.keys(headers),
-            hasBasicAuth: !!headers.Authorization,
-            hasCfAccess: !!(headers['CF-Access-Client-Id'] && headers['CF-Access-Client-Secret']),
-        });
-        const response = await fetch(url, {
-            method: options.method || 'GET',
-            headers,
-            body: options.body,
-            signal: AbortSignal.timeout(this.config.timeout || 30000),
-            ...options,
-        });
-        if (!response.ok) {
-            console.error('❌ WordPress API Error:', {
-                status: response.status,
-                statusText: response.statusText,
-                url,
-                headers: Object.fromEntries(response.headers.entries()),
-            });
-            throw new Error(`WordPress API request failed: ${response.status} ${response.statusText}`);
-        }
-        const responseText = await response.text();
-        console.log('🔍 WordPress API Response:', {
-            status: response.status,
-            responseLength: responseText.length,
-            responsePreview: responseText.substring(0, 200),
-        });
-        if (!responseText) {
-            // Return empty array for empty responses (common for endpoints with no data)
-            return [];
-        }
-        try {
-            return JSON.parse(responseText);
-        }
-        catch (error) {
-            const message = error instanceof Error ? error.message : String(error);
-            console.error('❌ JSON Parse Error:', {
-                error: message,
-                responseText: responseText.substring(0, 500),
-            });
-            throw new Error(`Failed to parse JSON response: ${message}`);
-        }
-    }
-    getBaseUrl() {
-        switch (this.config.authMode) {
-            case 'cloudflare_proxy':
-                return this.config.cloudflareWorkerUrl || '';
-            default:
-                return this.config.apiUrl || '';
-        }
-    }
-    /**
-     * Fetch posts with automatic pagination support
-     * @param params Query parameters including per_page for total items to fetch
-     * @returns All posts up to the limit, fetched across multiple pages if needed
-     */
-    async getPosts(params = {}) {
-        return this.fetchPaginated('/wp/v2/posts', params);
-    }
-    async getPost(id) {
-        return this.makeRequest(`/wp/v2/posts/${id}`);
-    }
-    /**
-     * Fetch pages with automatic pagination support
-     * @param params Query parameters including per_page for total items to fetch
-     * @returns All pages up to the limit, fetched across multiple pages if needed
-     */
-    async getPages(params = {}) {
-        return this.fetchPaginated('/wp/v2/pages', params);
-    }
-    async getPage(id) {
-        return this.makeRequest(`/wp/v2/pages/${id}`);
-    }
-    /**
-     * Fetch media with automatic pagination support
-     * @param params Query parameters including per_page for total items to fetch
-     * @returns All media items up to the limit, fetched across multiple pages if needed
-     */
-    async getMedia(params = {}) {
-        return this.fetchPaginated('/wp/v2/media', params);
-    }
-    async getMediaItem(id) {
-        return this.makeRequest(`/wp/v2/media/${id}`);
-    }
-    /**
-     * Fetch categories with automatic pagination support
-     * @param params Query parameters including per_page for total items to fetch
-     * @returns All categories up to the limit, fetched across multiple pages if needed
-     */
-    async getCategories(params = {}) {
-        return this.fetchPaginated('/wp/v2/categories', params);
-    }
-    /**
-     * Fetch tags with automatic pagination support
-     * @param params Query parameters including per_page for total items to fetch
-     * @returns All tags up to the limit, fetched across multiple pages if needed
-     */
-    async getTags(params = {}) {
-        return this.fetchPaginated('/wp/v2/tags', params);
-    }
-    /**
-     * Fetch data with automatic pagination
-     * Handles fetching all items up to the requested limit by making multiple API calls if needed
-     * @param endpoint The API endpoint to fetch from
-     * @param params Query parameters including per_page for total items to fetch
-     * @returns Array of all items fetched across all pages
-     */
-    async fetchPaginated(endpoint, params = {}) {
-        const requestedTotal = params.per_page || 100;
-        const itemsPerPage = Math.min(requestedTotal, 100); // WordPress max is typically 100
-        const maxPages = Math.ceil(requestedTotal / itemsPerPage);
-        let allItems = [];
-        let currentPage = 1;
-        let hasMorePages = true;
-        console.log(`🔄 Fetching ${endpoint} with pagination: ${requestedTotal} items requested (${maxPages} pages of ${itemsPerPage})`);
-        while (hasMorePages && currentPage <= maxPages && allItems.length < requestedTotal) {
-            const pageParams = {
-                ...params,
-                per_page: itemsPerPage,
-                page: currentPage,
-            };
-            console.log(`📄 Fetching page ${currentPage}/${maxPages} for ${endpoint}...`);
-            try {
-                const pageData = await this.makeRequest(endpoint, pageParams);
-                if (!pageData || pageData.length === 0) {
-                    console.log(`✓ No more data on page ${currentPage}, stopping pagination`);
-                    hasMorePages = false;
-                    break;
-                }
-                allItems = allItems.concat(pageData);
-                console.log(`✓ Page ${currentPage}: fetched ${pageData.length} items (total: ${allItems.length})`);
-                // Stop if we got fewer items than requested per page (last page)
-                if (pageData.length < itemsPerPage) {
-                    console.log(`✓ Reached last page (partial results)`);
-                    hasMorePages = false;
-                }
-                currentPage++;
-            }
-            catch (error) {
-                console.error(`❌ Error fetching page ${currentPage}:`, error);
-                // Stop pagination on error but return what we have so far
-                hasMorePages = false;
-            }
-        }
-        console.log(`✅ Pagination complete for ${endpoint}: ${allItems.length} total items fetched`);
-        // Trim to exact requested amount if we fetched more
-        return allItems.slice(0, requestedTotal);
-    }
-    // Gravity Forms endpoints
-    async getGravityForms() {
-        return this.makeRequest('/gf-api/v1/forms');
-    }
-    async getGravityForm(formId) {
-        return this.makeRequest(`/gf-api/v1/forms/${formId}/config`);
-    }
-    async submitGravityForm(formId, entry) {
-        return this.makeRequest(`/gf-api/v1/forms/${formId}/submit`, {}, {
-            method: 'POST',
-            body: JSON.stringify(entry),
-        });
-    }
-    // Static data endpoints
-    async getStaticDataNonce() {
-        return this.makeRequest('/static-data/v1/nonce');
-    }
-    /**
-     * Fetch a custom post type with automatic pagination support
-     * @param postType The custom post type slug (e.g., 'chapter-member', 'events')
-     * @param params Query parameters including per_page for total items to fetch
-     * @returns All items of the custom post type up to the limit
-     */
-    async getCustomPostType(postType, params = {}) {
-        return this.fetchPaginated(`/wp/v2/${postType}`, params);
-    }
-    async getAllData(params = {}) {
-        const [posts, pages, media, categories, tags] = await Promise.all([
-            this.getPosts(params),
-            this.getPages(params),
-            this.getMedia(params),
-            this.getCategories(params),
-            this.getTags(params),
-        ]);
-        return { posts, pages, media, categories, tags };
-    }
-    /**
-     * Fetch blocks for a specific page from the custom blocks endpoint
-     * @param pageId Page ID
-     * @returns Blocks data from /wp-custom/v1/pages/{id}/blocks
-     */
-    async getPageBlocks(pageId) {
-        return this.makeRequest(`/wp-custom/v1/pages/${pageId}/blocks`);
-    }
-    /**
-     * Fetch WordPress Settings from custom endpoint
-     * @returns Settings including front page information and site branding
-     */
-    /**
-     * Fetch header template part blocks from custom endpoint
-     * @param slug Template part slug (default: 'header')
-     * @param area Template part area (default: 'header')
-     * @returns Header blocks data
-     */
-    async getHeader(slug = 'header', area = 'header') {
-        return this.makeRequest(`/wp-custom/v1/header`, { slug, area });
-    }
-    /**
-     * Fetch all navigation menus
-     * @returns Array of menu objects
-     */
-    async getMenus() {
-        return this.makeRequest('/wp-custom/v1/menus');
-    }
-    /**
-     * Fetch a specific navigation menu with its items
-     * Handles both menu term IDs and wp_navigation post IDs
-     * @param menuId Menu ID (can be menu term ID or wp_navigation post ID)
-     * @returns Menu data with hierarchical items
-     */
-    async getMenu(menuId) {
-        console.log(`🌐 [WordPressClient] Fetching menu ID ${menuId}...`);
-        try {
-            // First try the custom endpoint (handles both menu terms and wp_navigation posts)
-            console.log(`  → Trying endpoint: /wp-custom/v1/menus/${menuId}`);
-            const result = await this.makeRequest(`/wp-custom/v1/menus/${menuId}`);
-            console.log(`  ✅ Successfully fetched menu ID ${menuId} as menu term: ${result.name}`);
-            return result;
-        }
-        catch (error) {
-            const errorStatus = error.status || (error.response?.status) || 'unknown';
-            const errorMessage = error.message || 'Unknown error';
-            console.log(`  ❌ Menu term fetch failed (status: ${errorStatus}): ${errorMessage}`);
-            // If 404, try fetching as wp_navigation post
-            if (errorStatus === 404 || errorMessage?.includes('404')) {
-                console.log(`  → Menu ID ${menuId} not found as menu term, trying as wp_navigation post...`);
-                // Try custom endpoint first
-                try {
-                    console.log(`  → Trying navigation post endpoint: /wp-custom/v1/navigation/${menuId}`);
-                    const navPost = await this.makeRequest(`/wp-custom/v1/navigation/${menuId}`);
-                    console.log(`  ✅ Navigation post fetched:`, {
-                        id: navPost.id,
-                        hasMenu: !!navPost.menu,
-                        menuTermId: navPost.menu_term_id,
-                    });
-                    // If navigation post has menu data (either from menu_term_id or extracted from blocks)
-                    if (navPost.menu) {
-                        console.log(`  ✅ Returning menu from navigation post: ${navPost.menu.name} (${navPost.menu.items?.length || 0} items)`);
-                        return navPost.menu;
-                    }
-                    // If navigation post has a menu_term_id but no menu data, fetch that menu
-                    if (navPost.menu_term_id) {
-                        console.log(`  → Navigation post has menu_term_id ${navPost.menu_term_id}, fetching menu...`);
-                        const menu = await this.makeRequest(`/wp-custom/v1/menus/${navPost.menu_term_id}`);
-                        console.log(`  ✅ Fetched menu from menu_term_id ${navPost.menu_term_id}: ${menu.name}`);
-                        return menu;
-                    }
-                    else {
-                        console.warn(`  ⚠️  Navigation post ${menuId} has no menu_term_id and no menu data extracted from blocks`);
-                        throw new Error(`Navigation post ${menuId} has no menu_term_id and no menu data`);
-                    }
-                }
-                catch (navError) {
-                    const navErrorStatus = navError.status || (navError.response?.status) || 'unknown';
-                    const navErrorMessage = navError.message || 'Unknown error';
-                    console.log(`  ❌ Navigation post fetch failed (status: ${navErrorStatus}): ${navErrorMessage}`);
-                    // If custom endpoint fails, try WordPress native REST API (WordPress 6.3+)
-                    if (navErrorStatus === 404 || navErrorMessage?.includes('404')) {
-                        console.log(`  → Custom navigation endpoint not found, trying WordPress native REST API...`);
-                        try {
-                            console.log(`  → Trying WordPress native REST API: /wp/v2/navigation/${menuId}`);
-                            // WordPress 6.3+ has native REST API for wp_navigation posts
-                            const navPost = await this.makeRequest(`/wp/v2/navigation/${menuId}`);
-                            console.log(`  ✅ WordPress native navigation post fetched:`, {
-                                id: navPost.id,
-                                title: navPost.title?.rendered,
-                                hasContent: !!navPost.content?.raw,
-                            });
-                            // Parse blocks from content to find menu reference
-                            // The content.raw contains the block JSON
-                            if (navPost.content?.raw) {
-                                try {
-                                    const blocks = JSON.parse(navPost.content.raw);
-                                    console.log(`  → Parsed ${Array.isArray(blocks) ? blocks.length : 'unknown'} blocks from navigation post`);
-                                    // Look for menu reference in blocks (this would need to be done server-side)
-                                    // For now, throw error to indicate menu extraction requires server-side processing
-                                    console.log(`ℹ️  Found wp_navigation post ${menuId}, but menu extraction requires server-side processing`);
-                                    throw new Error(`Menu extraction from wp_navigation post ${menuId} requires server-side processing`);
-                                }
-                                catch (parseError) {
-                                    console.log(`⚠️  Could not parse navigation post content`);
-                                    throw new Error(`Could not parse navigation post content for menu ID ${menuId}`);
-                                }
-                            }
-                            else {
-                                throw new Error(`wp_navigation post ${menuId} has no content to parse`);
-                            }
-                        }
-                        catch (wpError) {
-                            const wpErrorStatus = wpError.status || (wpError.response?.status) || 'unknown';
-                            const wpErrorMessage = wpError.message || 'Unknown error';
-                            console.error(`  ❌ WordPress native REST API also failed (status: ${wpErrorStatus}): ${wpErrorMessage}`);
-                            console.error(`  Full WordPress API error:`, wpError);
-                            // Re-throw to ensure error is propagated
-                            throw new Error(`Could not fetch menu ID ${menuId} via any method: ${wpErrorMessage}`);
-                        }
-                    }
-                    else {
-                        console.error(`  ❌ Navigation post fetch failed with non-404 error, re-throwing...`);
-                        throw navError; // Re-throw navigation error
-                    }
-                }
-            }
-            else {
-                console.error(`  ❌ Menu term fetch failed with non-404 error (status: ${errorStatus}), re-throwing...`);
-                throw error; // Re-throw original error
-            }
-        }
-    }
-    async getFooter(slug = 'footer', area = 'footer') {
-        return this.makeRequest(`/wp-custom/v1/footer`, { slug, area });
-    }
-    async getSettings() {
-        return this.makeRequest('/wp-custom/v1/settings');
-    }
-}
-
-let document;
-let offset;
-let output;
-let stack;
-const tokenizer = /<!--\s+(\/)?wp:([a-z][a-z0-9_-]*\/)?([a-z][a-z0-9_-]*)\s+({(?:(?=([^}]+|}+(?=})|(?!}\s+\/?-->)[^])*)\5|[^]*?)}\s+)?(\/)?-->/g;
-function Block(blockName, attrs, innerBlocks, innerHTML, innerContent) {
-  return {
-    blockName,
-    attrs,
-    innerBlocks,
-    innerHTML,
-    innerContent
-  };
-}
-function Freeform(innerHTML) {
-  return Block(null, {}, [], innerHTML, [innerHTML]);
-}
-function Frame(block, tokenStart, tokenLength, prevOffset, leadingHtmlStart) {
-  return {
-    block,
-    tokenStart,
-    tokenLength,
-    prevOffset: prevOffset || tokenStart + tokenLength,
-    leadingHtmlStart
-  };
-}
-const parse = (doc) => {
-  document = doc;
-  offset = 0;
-  output = [];
-  stack = [];
-  tokenizer.lastIndex = 0;
-  do {
-  } while (proceed());
-  return output;
-};
-function proceed() {
-  const stackDepth = stack.length;
-  const next = nextToken();
-  const [tokenType, blockName, attrs, startOffset, tokenLength] = next;
-  const leadingHtmlStart = startOffset > offset ? offset : null;
-  switch (tokenType) {
-    case "no-more-tokens":
-      if (0 === stackDepth) {
-        addFreeform();
-        return false;
-      }
-      if (1 === stackDepth) {
-        addBlockFromStack();
-        return false;
-      }
-      while (0 < stack.length) {
-        addBlockFromStack();
-      }
-      return false;
-    case "void-block":
-      if (0 === stackDepth) {
-        if (null !== leadingHtmlStart) {
-          output.push(
-            Freeform(
-              document.substr(
-                leadingHtmlStart,
-                startOffset - leadingHtmlStart
-              )
-            )
-          );
-        }
-        output.push(Block(blockName, attrs, [], "", []));
-        offset = startOffset + tokenLength;
-        return true;
-      }
-      addInnerBlock(
-        Block(blockName, attrs, [], "", []),
-        startOffset,
-        tokenLength
-      );
-      offset = startOffset + tokenLength;
-      return true;
-    case "block-opener":
-      stack.push(
-        Frame(
-          Block(blockName, attrs, [], "", []),
-          startOffset,
-          tokenLength,
-          startOffset + tokenLength,
-          leadingHtmlStart
-        )
-      );
-      offset = startOffset + tokenLength;
-      return true;
-    case "block-closer":
-      if (0 === stackDepth) {
-        addFreeform();
-        return false;
-      }
-      if (1 === stackDepth) {
-        addBlockFromStack(startOffset);
-        offset = startOffset + tokenLength;
-        return true;
-      }
-      const stackTop = stack.pop();
-      const html = document.substr(
-        stackTop.prevOffset,
-        startOffset - stackTop.prevOffset
-      );
-      stackTop.block.innerHTML += html;
-      stackTop.block.innerContent.push(html);
-      stackTop.prevOffset = startOffset + tokenLength;
-      addInnerBlock(
-        stackTop.block,
-        stackTop.tokenStart,
-        stackTop.tokenLength,
-        startOffset + tokenLength
-      );
-      offset = startOffset + tokenLength;
-      return true;
-    default:
-      addFreeform();
-      return false;
-  }
-}
-function parseJSON(input) {
-  try {
-    return JSON.parse(input);
-  } catch (e) {
-    return null;
-  }
-}
-function nextToken() {
-  const matches = tokenizer.exec(document);
-  if (null === matches) {
-    return ["no-more-tokens", "", null, 0, 0];
-  }
-  const startedAt = matches.index;
-  const [
-    match,
-    closerMatch,
-    namespaceMatch,
-    nameMatch,
-    attrsMatch,
-    ,
-    voidMatch
-  ] = matches;
-  const length = match.length;
-  const isCloser = !!closerMatch;
-  const isVoid = !!voidMatch;
-  const namespace = namespaceMatch || "core/";
-  const name = namespace + nameMatch;
-  const hasAttrs = !!attrsMatch;
-  const attrs = hasAttrs ? parseJSON(attrsMatch) : {};
-  if (isVoid) {
-    return ["void-block", name, attrs, startedAt, length];
-  }
-  if (isCloser) {
-    return ["block-closer", name, null, startedAt, length];
-  }
-  return ["block-opener", name, attrs, startedAt, length];
-}
-function addFreeform(rawLength) {
-  const length = document.length - offset;
-  if (0 === length) {
-    return;
-  }
-  output.push(Freeform(document.substr(offset, length)));
-}
-function addInnerBlock(block, tokenStart, tokenLength, lastOffset) {
-  const parent = stack[stack.length - 1];
-  parent.block.innerBlocks.push(block);
-  const html = document.substr(
-    parent.prevOffset,
-    tokenStart - parent.prevOffset
-  );
-  if (html) {
-    parent.block.innerHTML += html;
-    parent.block.innerContent.push(html);
-  }
-  parent.block.innerContent.push(null);
-  parent.prevOffset = lastOffset ? lastOffset : tokenStart + tokenLength;
-}
-function addBlockFromStack(endOffset) {
-  const { block, leadingHtmlStart, prevOffset, tokenStart } = stack.pop();
-  const html = endOffset ? document.substr(prevOffset, endOffset - prevOffset) : document.substr(prevOffset);
-  if (html) {
-    block.innerHTML += html;
-    block.innerContent.push(html);
-  }
-  if (null !== leadingHtmlStart) {
-    output.push(
-      Freeform(
-        document.substr(
-          leadingHtmlStart,
-          tokenStart - leadingHtmlStart
-        )
-      )
-    );
-  }
-  output.push(block);
-}
-
-/**
- * @license GPL-3.0-or-later
- *
- * This file is part of the MarVAlt Open SDK.
- * Copyright (c) 2025 Vibune Pty Ltd.
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
- * See the GNU General Public License for more details.
- */
-// WordPress Static Data Generator
-/**
- * Extract menu items from a navigation block's innerHTML (rendered HTML)
- * WordPress renders navigation blocks, so menu items are in innerHTML as HTML
- * This function properly handles submenus by parsing the nested <ul> structure
- */
-function extractMenuFromNavigationHTML(innerHTML) {
-    if (!innerHTML)
-        return null;
-    // Find the main navigation container <ul>
-    const mainNavMatch = innerHTML.match(/<ul[^>]*class="[^"]*wp-block-navigation__container[^"]*"[^>]*>([\s\S]*?)<\/ul>/i);
-    if (!mainNavMatch) {
-        return null;
-    }
-    const mainNavContent = mainNavMatch[1];
-    const items = [];
-    let globalOrder = 0;
-    /**
-     * Parse a <li> element and extract menu item data
-     * Handles both regular links and submenus
-     */
-    function parseMenuItem(liElement, parentId = 0, order = 0) {
-        // Extract the link
-        const linkMatch = liElement.match(/<a[^>]+class="[^"]*wp-block-navigation-item__content[^"]*"[^>]+href=["']([^"']+)["'][^>]*>[\s\S]*?<span[^>]*class="[^"]*wp-block-navigation-item__label[^"]*"[^>]*>([^<]+)<\/span>[\s\S]*?<\/a>/i);
-        if (!linkMatch) {
-            return null;
-        }
-        const url = linkMatch[1].trim();
-        const title = linkMatch[2].trim();
-        if (!title) {
-            return null;
-        }
-        // Normalize URL
-        let finalUrl = url;
-        try {
-            const urlObj = new URL(url, 'http://dummy.com'); // Use dummy base for relative URLs
-            const isAbsoluteUrl = url.startsWith('http://') || url.startsWith('https://');
-            if (isAbsoluteUrl) {
-                const pathname = urlObj.pathname;
-                const isExternal = pathname === '' || pathname === '/' ||
-                    !urlObj.hostname.includes('vibunedemos.com') &&
-                        !urlObj.hostname.includes('localhost') &&
-                        !urlObj.hostname.includes('127.0.0.1');
-                if (isExternal) {
-                    finalUrl = url;
-                }
-                else {
-                    finalUrl = pathname + urlObj.search + urlObj.hash;
-                    if (!finalUrl.startsWith('/')) {
-                        finalUrl = `/${finalUrl}`;
-                    }
-                    if (finalUrl !== '/' && finalUrl.endsWith('/')) {
-                        finalUrl = finalUrl.slice(0, -1);
-                    }
-                }
-            }
-            else {
-                if (!finalUrl.startsWith('/')) {
-                    finalUrl = `/${finalUrl}`;
-                }
-                if (finalUrl !== '/' && finalUrl.endsWith('/')) {
-                    finalUrl = finalUrl.slice(0, -1);
-                }
-            }
-        }
-        catch (e) {
-            if (!finalUrl.startsWith('http://') && !finalUrl.startsWith('https://') && !finalUrl.startsWith('/')) {
-                finalUrl = `/${finalUrl}`;
-            }
-            if (finalUrl !== '/' && finalUrl.endsWith('/')) {
-                finalUrl = finalUrl.slice(0, -1);
-            }
-        }
-        const itemId = globalOrder + 1;
-        globalOrder++;
-        const menuItem = {
-            id: itemId,
-            title: title,
-            url: finalUrl,
-            type: 'custom',
-            object_id: 0,
-            object: 'custom',
-            parent: parentId,
-            menu_order: order,
-        };
-        // Check if this <li> contains a submenu (<ul class="wp-block-navigation__submenu-container">)
-        const submenuMatch = liElement.match(/<ul[^>]*class="[^"]*wp-block-navigation__submenu-container[^"]*"[^>]*>([\s\S]*?)<\/ul>/i);
-        if (submenuMatch) {
-            const submenuContent = submenuMatch[1];
-            const children = [];
-            let childOrder = 0;
-            // Extract all <li> elements from the submenu
-            const submenuLiRegex = /<li[^>]*class="[^"]*wp-block-navigation-item[^"]*"[^>]*>([\s\S]*?)<\/li>/gi;
-            let submenuLiMatch;
-            while ((submenuLiMatch = submenuLiRegex.exec(submenuContent)) !== null) {
-                const childResult = parseMenuItem(submenuLiMatch[1], itemId, childOrder++);
-                if (childResult) {
-                    children.push(childResult.item);
-                    globalOrder = childResult.nextOrder;
-                }
-            }
-            if (children.length > 0) {
-                menuItem.children = children;
-            }
-        }
-        return { item: menuItem, nextOrder: globalOrder };
-    }
-    // Extract all top-level <li> elements from the main navigation
-    // Find all <li> tags and extract complete items, filtering by position
-    const liRegex = /<li[^>]*>/gi;
-    const allLiMatches = [];
-    // First pass: find all <li> tags and their matching </li>
-    let match;
-    while ((match = liRegex.exec(mainNavContent)) !== null) {
-        const liStart = match.index;
-        let depth = 0;
-        let j = liStart;
-        while (j < mainNavContent.length) {
-            if (mainNavContent.substr(j, 3) === '<li' && /[>\s\n\t]/.test(mainNavContent[j + 3] || '')) {
-                depth++;
-            }
-            else if (mainNavContent.substr(j, 5) === '</li>') {
-                depth--;
-                if (depth === 0) {
-                    allLiMatches.push({ start: liStart, end: j + 5 });
-                    break;
-                }
-            }
-            j++;
-        }
-    }
-    // Second pass: filter to only top-level items (not inside submenu containers)
-    // Build a map of submenu container ranges
-    const submenuRanges = [];
-    const submenuContainerRegex = /<ul[^>]*class="[^"]*wp-block-navigation__submenu-container[^"]*"[^>]*>/gi;
-    let submenuMatch;
-    // Find all submenu containers and their matching </ul> tags
-    while ((submenuMatch = submenuContainerRegex.exec(mainNavContent)) !== null) {
-        const submenuStart = submenuMatch.index;
-        const submenuUlEnd = mainNavContent.indexOf('>', submenuStart);
-        if (submenuUlEnd === -1)
-            continue;
-        // Find matching </ul> by tracking depth
-        let ulDepth = 0;
-        let checkPos = submenuUlEnd + 1;
-        let submenuEnd = -1;
-        while (checkPos < mainNavContent.length) {
-            const ulOpen = mainNavContent.indexOf('<ul', checkPos);
-            const ulClose = mainNavContent.indexOf('</ul>', checkPos);
-            if (ulOpen !== -1 && (ulClose === -1 || ulOpen < ulClose)) {
-                ulDepth++;
-                checkPos = ulOpen + 3;
-            }
-            else if (ulClose !== -1) {
-                ulDepth--;
-                if (ulDepth === 0) {
-                    submenuEnd = ulClose + 5;
-                    break;
-                }
-                checkPos = ulClose + 5;
-            }
-            else {
-                break;
-            }
-        }
-        if (submenuEnd !== -1) {
-            submenuRanges.push({ start: submenuStart, end: submenuEnd });
-        }
-    }
-    // Filter <li> elements: exclude only those that are children inside submenu containers
-    // An <li> is a child (inside submenu) if: submenu's <ul> starts before <li> AND submenu's </ul> ends after <li> ends
-    // An <li> is a parent (contains submenu) if: <li> starts before submenu's <ul> (we want to include these)
-    for (const { start, end } of allLiMatches) {
-        // Check if this <li> is a child inside any submenu container
-        let isChildItem = false;
-        for (const range of submenuRanges) {
-            // If submenu <ul> starts before <li> AND submenu </ul> ends after <li> ends, then <li> is a child
-            if (range.start < start && range.end > end) {
-                isChildItem = true;
-                break;
-            }
-        }
-        // Include all items except children (children will be extracted by parseMenuItem as part of their parent)
-        if (!isChildItem) {
-            const item = mainNavContent.substring(start, end);
-            if (item.includes('wp-block-navigation-item')) {
-                const result = parseMenuItem(item, 0, items.length);
-                if (result) {
-                    items.push(result.item);
-                    globalOrder = result.nextOrder;
-                }
-            }
-        }
-    }
-    if (items.length === 0) {
-        return null;
-    }
-    return {
-        id: 0, // No menu ID for inline menus
-        name: 'Navigation Menu',
-        slug: 'navigation-menu',
-        items: items,
-    };
-}
-/**
- * Find a menu by name (checks both slug and name fields, case-insensitive)
- * @param menus Array of menu objects
- * @param menuNamePattern Name or slug pattern to match (case-insensitive)
- * @returns Menu object if found, null otherwise
- */
-async function findMenuByName(client, menuNamePattern) {
-    try {
-        console.log(`🔍 Fetching all menus to search for "${menuNamePattern}"...`);
-        const allMenus = await client.getMenus();
-        console.log(`📋 Found ${allMenus.length} menu(s):`, allMenus.map((m) => `${m.name} (slug: ${m.slug})`).join(', '));
-        const patternLower = menuNamePattern.toLowerCase();
-        // Find menu by slug or name (case-insensitive)
-        const foundMenu = allMenus.find((menu) => {
-            const slugMatch = menu.slug?.toLowerCase() === patternLower;
-            const nameMatch = menu.name?.toLowerCase() === patternLower;
-            // Also check if slug or name contains the pattern (for variations like "main-menu" vs "mainmenu")
-            const slugNormalized = menu.slug?.toLowerCase().replace(/[^a-z0-9]/g, '');
-            const nameNormalized = menu.name?.toLowerCase().replace(/[^a-z0-9]/g, '');
-            const patternNormalized = patternLower.replace(/[^a-z0-9]/g, '');
-            const slugContains = slugNormalized === patternNormalized;
-            const nameContains = nameNormalized === patternNormalized;
-            return slugMatch || nameMatch || slugContains || nameContains;
-        });
-        if (foundMenu) {
-            console.log(`✅ Found matching menu: ${foundMenu.name} (ID: ${foundMenu.id}, slug: ${foundMenu.slug})`);
-            // Fetch the full menu with items
-            const fullMenu = await client.getMenu(foundMenu.id);
-            return fullMenu;
-        }
-        console.log(`ℹ️  No menu found matching pattern "${menuNamePattern}"`);
-        return null;
-    }
-    catch (error) {
-        console.warn(`⚠️  Error finding menu by name "${menuNamePattern}":`, error);
-        return null;
-    }
-}
-/**
- * Extract menu items from a navigation block's innerBlocks
- * Navigation blocks can have menu items stored as core/navigation-link blocks
- */
-function extractMenuFromNavigationBlock(navBlock) {
-    if (!navBlock) {
-        return null;
-    }
-    // First, try to extract from innerBlocks if available
-    if (navBlock.innerBlocks && navBlock.innerBlocks.length > 0) {
-        const extractMenuItems = (blocks, parentId = 0, order = 0) => {
-            const items = [];
-            let currentOrder = order;
-            for (const block of blocks) {
-                if (block.name === 'core/navigation-link' || block.name === 'core/page-list' || block.name === 'core/navigation-submenu') {
-                    const attrs = block.attributes || {};
-                    const label = attrs.label || attrs.text || '';
-                    const url = attrs.url || attrs.href || '';
-                    const kind = attrs.kind || attrs.type || 'custom';
-                    const id = attrs.id || attrs.objectId || currentOrder;
-                    const menuItem = {
-                        id: id,
-                        title: label,
-                        url: url,
-                        type: kind,
-                        object_id: attrs.objectId || 0,
-                        object: attrs.type || 'custom',
-                        parent: parentId,
-                        menu_order: currentOrder++,
-                    };
-                    // Check for submenu items (children)
-                    if (block.innerBlocks && block.innerBlocks.length > 0) {
-                        const children = extractMenuItems(block.innerBlocks, id, 0);
-                        if (children.length > 0) {
-                            menuItem.children = children;
-                        }
-                    }
-                    items.push(menuItem);
-                }
-                else if (block.innerBlocks && block.innerBlocks.length > 0) {
-                    // Recursively search in nested blocks
-                    const nestedItems = extractMenuItems(block.innerBlocks, parentId, currentOrder);
-                    items.push(...nestedItems);
-                    currentOrder += nestedItems.length;
-                }
-            }
-            return items;
-        };
-        const items = extractMenuItems(navBlock.innerBlocks);
-        if (items.length > 0) {
-            return {
-                id: 0, // No menu ID for inline menus
-                name: 'Navigation Menu',
-                slug: 'navigation-menu',
-                items: items,
-            };
-        }
-    }
-    // Fallback: Try to extract from innerHTML if innerBlocks are empty
-    if (navBlock.innerHTML) {
-        return extractMenuFromNavigationHTML(navBlock.innerHTML);
-    }
-    return null;
-}
-class WordPressGenerator {
-    constructor(config) {
-        this.config = config;
-    }
-    async generateStaticData() {
-        const client = new WordPressClient(this.config);
-        console.log('🚀 Starting WordPress static data generation...');
-        const frontendId = this.config.frontendId ?? 'default-frontend';
-        const frontendName = this.config.frontendName || 'Default Frontend';
-        const postTypes = this.config.postTypes || ['posts', 'pages'];
-        // Use 'view' context - wp-custom-api-endpoints plugin adds blocks automatically.
-        // Frontends: when app provides frontendId, request Default + app frontend (OR); otherwise no filter (single-frontend backend).
-        // Use a custom slug-based param to avoid colliding with WordPress core taxonomy term ID filters.
-        const fetchParams = {
-            per_page: this.config.maxItems || 100,
-            _embed: true,
-            context: 'view', // Plugin adds blocks in 'view' context
-        };
-        if (this.config.frontendId && this.config.frontendId.trim() !== '') {
-            fetchParams.frontend_slugs = 'default,' + this.config.frontendId.trim();
-        }
-        console.log(`📋 Fetching post types: ${postTypes.join(', ')}`);
-        console.log(`⚙️  Settings: maxItems=${fetchParams.per_page}, includeEmbedded=${fetchParams._embed}`);
-        // Fetch WordPress Settings (Reading Settings + Site Branding + Theme Styles)
-        let frontPage;
-        let settingsPageId;
-        let siteSettings;
-        let themeStyles;
-        let header;
-        let footer;
-        let menuData;
-        let menus = {}; // Declare menus outside try block so it's accessible later
-        try {
-            console.log('🔍 Fetching WordPress Settings...');
-            const settings = await client.getSettings();
-            if (settings.front_page) {
-                // WordPress has a page set as front page in Reading Settings
-                frontPage = settings.front_page;
-                console.log(`✅ Front page determined from Reading Settings: ${frontPage.slug} (ID: ${frontPage.id})`);
-            }
-            else if (settings.show_on_front === 'page' && settings.page_on_front > 0) {
-                // Page is set but not returned in front_page (might be in pages list)
-                settingsPageId = settings.page_on_front;
-                console.log(`📋 Front page ID ${settingsPageId} set in Reading Settings, will check fetched pages`);
-            }
-            // Extract site branding settings
-            if (settings.logo || settings.site_icon || settings.site_name || settings.site_description) {
-                siteSettings = {
-                    ...(settings.logo && { logo: settings.logo }),
-                    ...(settings.site_icon && { site_icon: settings.site_icon }),
-                    ...(settings.site_name && { site_name: settings.site_name }),
-                    ...(settings.site_description && { site_description: settings.site_description }),
-                };
-                if (siteSettings.logo) {
-                    console.log(`✅ Site logo found: ${siteSettings.logo.cloudflare_url || siteSettings.logo.url}`);
-                }
-                if (siteSettings.site_icon) {
-                    console.log(`✅ Site icon found: ${siteSettings.site_icon.cloudflare_url || siteSettings.site_icon.url}`);
-                }
-                if (siteSettings.site_name) {
-                    console.log(`✅ Site name: ${siteSettings.site_name}`);
-                }
-            }
-            // Extract theme styles
-            if (settings.theme_styles) {
-                themeStyles = settings.theme_styles;
-                console.log(`✅ Theme styles found:`, {
-                    hasTypography: !!themeStyles.typography,
-                    hasColors: !!themeStyles.colors,
-                    hasLayout: !!themeStyles.layout,
-                });
-            }
-            else {
-                console.log('⚠️  No theme_styles found in settings response');
-            }
-            // Fetch header template part and extract menu
-            console.log('🔍 Fetching Header template part...');
-            try {
-                header = await client.getHeader('header', 'header');
-                if (header && header.blocks && header.blocks.length > 0) {
-                    console.log(`✅ Header found: ${header.blocks_count} blocks`);
-                    // Find navigation block and extract menu ID
-                    const findNavigationBlock = (blocks) => {
-                        for (const block of blocks) {
-                            if (block.name === 'core/navigation') {
-                                return block;
-                            }
-                            if (block.innerBlocks && block.innerBlocks.length > 0) {
-                                const found = findNavigationBlock(block.innerBlocks);
-                                if (found)
-                                    return found;
-                            }
-                        }
-                        return null;
-                    };
-                    const navBlock = findNavigationBlock(header.blocks);
-                    if (navBlock && navBlock.attributes) {
-                        // Debug: Log all navigation block attributes
-                        console.log('🔍 Navigation block attributes:', JSON.stringify(navBlock.attributes, null, 2));
-                        console.log('🔍 Navigation block innerBlocks:', navBlock.innerBlocks ? `${navBlock.innerBlocks.length} blocks` : 'none');
-                        // WordPress stores menu ID in 'ref' attribute (term_id of the menu)
-                        // Also check for other possible attribute names
-                        const menuId = navBlock.attributes['ref'] ||
-                            navBlock.attributes['menuId'] ||
-                            navBlock.attributes['menu'] ||
-                            navBlock.attributes['navigationMenuId'] ||
-                            navBlock.attributes['menuRef'];
-                        if (menuId) {
-                            try {
-                                console.log(`🔍 Found navigation block with menu ID: ${menuId}, fetching menu data...`);
-                                menuData = await client.getMenu(parseInt(menuId));
-                                console.log(`✅ Menu data fetched: ${menuData.items?.length || 0} items`);
-                                console.log('📋 Menu data structure:', JSON.stringify({
-                                    id: menuData.id,
-                                    name: menuData.name,
-                                    itemsCount: menuData.items?.length || 0,
-                                    firstItem: menuData.items?.[0] ? {
-                                        id: menuData.items[0].id,
-                                        title: menuData.items[0].title,
-                                        url: menuData.items[0].url
-                                    } : null
-                                }, null, 2));
-                            }
-                            catch (error) {
-                                console.warn(`⚠️  Could not fetch menu data for menu ID ${menuId}:`, error);
-                                // Fallback: Try to find menu by name (mainmenu, main-menu, Main Menu, etc.)
-                                console.log('🔍 Menu fetch failed, attempting to find menu by name "mainmenu"...');
-                                try {
-                                    const namedMenu = await findMenuByName(client, 'mainmenu');
-                                    if (namedMenu && namedMenu.items && namedMenu.items.length > 0) {
-                                        menuData = namedMenu;
-                                        console.log(`✅ Found menu by name "mainmenu": ${namedMenu.name} (${namedMenu.items.length} items)`);
-                                    }
-                                    else {
-                                        console.log('ℹ️  No menu found with name "mainmenu"');
-                                        // Try extracting from Navigation block HTML as last resort
-                                        console.log('🔍 Attempting to extract navigation from Navigation block innerHTML...');
-                                        try {
-                                            const extractedMenu = extractMenuFromNavigationBlock(navBlock);
-                                            if (extractedMenu && extractedMenu.items && extractedMenu.items.length > 0) {
-                                                menuData = extractedMenu;
-                                                console.log(`✅ Extracted navigation from Navigation block: ${extractedMenu.items.length} items`);
-                                            }
-                                        }
-                                        catch (extractError) {
-                                            console.warn('⚠️  Error extracting navigation from Navigation block:', extractError);
-                                        }
-                                    }
-                                }
-                                catch (nameError) {
-                                    console.warn('⚠️  Error finding menu by name:', nameError);
-                                }
-                            }
-                        }
-                        else {
-                            console.log('ℹ️  Navigation block found but no menu ID attribute found');
-                            console.log('🔍 Available attributes:', Object.keys(navBlock.attributes));
-                            // Priority 2: Try to find menu by name (mainmenu, main-menu, Main Menu, etc.)
-                            console.log('🔍 Attempting to find menu by name "mainmenu"...');
-                            try {
-                                const namedMenu = await findMenuByName(client, 'mainmenu');
-                                if (namedMenu && namedMenu.items && namedMenu.items.length > 0) {
-                                    menuData = namedMenu;
-                                    console.log(`✅ Found menu by name "mainmenu": ${namedMenu.name} (${namedMenu.items.length} items)`);
-                                }
-                                else {
-                                    console.log('ℹ️  No menu found with name "mainmenu"');
-                                    // In block themes, navigation items may be stored directly in the Navigation block's innerBlocks
-                                    // Try to extract from innerBlocks (this is how block themes work)
-                                    console.log('🔍 Attempting to extract navigation from Navigation block innerBlocks...');
-                                    try {
-                                        const extractedMenu = extractMenuFromNavigationBlock(navBlock);
-                                        if (extractedMenu && extractedMenu.items && extractedMenu.items.length > 0) {
-                                            menuData = extractedMenu;
-                                            console.log(`✅ Extracted navigation from Navigation block: ${extractedMenu.items.length} items`);
-                                            console.log('📋 Navigation items:', extractedMenu.items.map((item) => `${item.title} (${item.url})`).join(', '));
-                                            console.log('💡 TIP: For better control, create a WordPress menu (Appearance > Menus) named "mainmenu" and assign it to the Navigation block.');
-                                        }
-                                        else {
-                                            console.log('⚠️  WARNING: No navigation found in Navigation block. The frontend will fall back to page hierarchy.');
-                                            console.log('💡 TIP: Add navigation items to the Navigation block in the Site Editor, or create a menu named "mainmenu" in WordPress (Appearance > Menus).');
-                                            menuData = null;
-                                        }
-                                    }
-                                    catch (error) {
-                                        console.warn('⚠️  Error extracting navigation from Navigation block:', error);
-                                        console.log('⚠️  WARNING: The frontend will fall back to page hierarchy.');
-                                        menuData = null;
-                                    }
-                                }
-                            }
-                            catch (error) {
-                                console.warn('⚠️  Error finding menu by name:', error);
-                                console.log('ℹ️  Skipping HTML extraction - frontend will use page hierarchy fallback');
-                                menuData = null; // Don't use extracted menu - let frontend handle fallback
-                            }
-                        }
-                    }
-                    else {
-                        console.log('ℹ️  No navigation block found in header');
-                    }
-                }
-                else {
-                    console.log('ℹ️  No header template part found');
-                }
-            }
-            catch (error) {
-                console.warn('⚠️  Could not fetch header template part:', error);
-            }
-            // Fetch footer template part
-            console.log('🔍 Fetching Footer template part...');
-            try {
-                footer = await client.getFooter('footer', 'footer');
-                if (footer && footer.blocks && footer.blocks.length > 0) {
-                    console.log(`✅ Footer found: ${footer.blocks_count} blocks`);
-                }
-                else {
-                    console.log('⚠️  Footer template part is empty or not found');
-                }
-            }
-            catch (error) {
-                console.log('⚠️  Failed to fetch footer:', error instanceof Error ? error.message : 'Unknown error');
-            }
-            // Extract all menu IDs from footer blocks and fetch them for static data
-            const allMenuIds = new Set();
-            if (menuData && menuData.id) {
-                allMenuIds.add(menuData.id); // Add header menu
-                console.log(`📋 Added header menu ID ${menuData.id} (${menuData.name}) to menu list`);
-            }
-            if (footer && footer.blocks) {
-                let navigationBlockCount = 0;
-                const findNavigationBlocks = (blocks, depth = 0) => {
-                    for (const block of blocks) {
-                        if (block.name === 'core/navigation') {
-                            navigationBlockCount++;
-                            console.log(`🔍 Found navigation block at depth ${depth}:`, {
-                                blockName: block.name,
-                                hasAttributes: !!block.attributes,
-                                attributes: block.attributes ? Object.keys(block.attributes) : [],
-                            });
-                            if (block.attributes) {
-                                const menuId = block.attributes['ref'] ||
-                                    block.attributes['menuId'] ||
-                                    block.attributes['menu'] ||
-                                    block.attributes['navigationMenuId'] ||
-                                    block.attributes['menuRef'];
-                                if (menuId) {
-                                    const menuIdNum = parseInt(String(menuId));
-                                    allMenuIds.add(menuIdNum);
-                                    console.log(`  ✅ Extracted menu ID ${menuIdNum} from attribute:`, {
-                                        ref: block.attributes['ref'],
-                                        menuId: block.attributes['menuId'],
-                                        menu: block.attributes['menu'],
-                                        navigationMenuId: block.attributes['navigationMenuId'],
-                                        menuRef: block.attributes['menuRef'],
-                                        extracted: menuIdNum,
-                                    });
-                                }
-                                else {
-                                    console.warn(`  ⚠️  Navigation block found but no menu ID attribute detected. Available attributes:`, Object.keys(block.attributes));
-                                }
-                            }
-                            else {
-                                console.warn(`  ⚠️  Navigation block found but has no attributes`);
-                            }
-                        }
-                        if (block.innerBlocks && block.innerBlocks.length > 0) {
-                            findNavigationBlocks(block.innerBlocks, depth + 1);
-                        }
-                    }
-                };
-                findNavigationBlocks(footer.blocks);
-                console.log(`📊 Navigation block extraction summary:`, {
-                    navigationBlocksFound: navigationBlockCount,
-                    uniqueMenuIds: allMenuIds.size,
-                    menuIds: Array.from(allMenuIds),
-                });
-            }
-            else {
-                console.log(`ℹ️  No footer blocks found or footer is empty`);
-            }
-            // Fetch all menus and store them in a menus object keyed by ID
-            menus = {}; // Reset menus object (already declared above)
-            if (menuData && menuData.id) {
-                menus[menuData.id] = menuData;
-                console.log(`✅ Added header menu to menus object: ID ${menuData.id} (${menuData.name})`);
-            }
-            let fetchAttempts = 0;
-            let fetchSuccesses = 0;
-            let fetchFailures = 0;
-            for (const menuId of allMenuIds) {
-                if (!menus[menuId]) {
-                    fetchAttempts++;
-                    console.log(`🔍 Attempting to fetch menu ID ${menuId}... (attempt ${fetchAttempts}/${allMenuIds.size})`);
-                    try {
-                        const fetchedMenu = await client.getMenu(menuId);
-                        // Validate menu structure
-                        if (!fetchedMenu) {
-                            console.error(`❌ Menu ID ${menuId}: Fetched menu is null or undefined`);
-                            fetchFailures++;
-                            continue;
-                        }
-                        if (!fetchedMenu.id) {
-                            console.error(`❌ Menu ID ${menuId}: Fetched menu missing 'id' property:`, fetchedMenu);
-                            fetchFailures++;
-                            continue;
-                        }
-                        if (!fetchedMenu.name) {
-                            console.warn(`⚠️  Menu ID ${menuId}: Fetched menu missing 'name' property:`, fetchedMenu);
-                        }
-                        if (!fetchedMenu.items) {
-                            console.warn(`⚠️  Menu ID ${menuId}: Fetched menu missing 'items' property:`, fetchedMenu);
-                        }
-                        else if (!Array.isArray(fetchedMenu.items)) {
-                            console.error(`❌ Menu ID ${menuId}: Fetched menu 'items' is not an array:`, typeof fetchedMenu.items);
-                            fetchFailures++;
-                            continue;
-                        }
-                        // Store menu even if items array is empty (for debugging)
-                        menus[menuId] = fetchedMenu;
-                        if (fetchedMenu.items && fetchedMenu.items.length > 0) {
-                            fetchSuccesses++;
-                            console.log(`✅ Fetched menu ID ${menuId}: ${fetchedMenu.name} (${fetchedMenu.items.length} items)`);
-                        }
-                        else {
-                            fetchSuccesses++; // Still count as success, just empty
-                            console.warn(`⚠️  Menu ID ${menuId}: ${fetchedMenu.name} fetched but has no items`);
-                        }
-                    }
-                    catch (error) {
-                        fetchFailures++;
-                        const errorDetails = {
-                            message: error.message || 'Unknown error',
-                            status: error.status || 'unknown',
-                        };
-                        // Try to extract more error details
-                        if (error.response) {
-                            errorDetails.responseStatus = error.response.status;
-                            errorDetails.responseStatusText = error.response.statusText;
-                        }
-                        if (error.body) {
-                            try {
-                                errorDetails.body = typeof error.body === 'string' ? error.body : JSON.stringify(error.body);
-                            }
-                            catch (e) {
-                                errorDetails.body = 'Could not stringify error body';
-                            }
-                        }
-                        console.error(`❌ Could not fetch menu ID ${menuId}:`, errorDetails);
-                        console.error(`   Full error object:`, error);
-                    }
-                }
-                else {
-                    console.log(`ℹ️  Menu ID ${menuId} already in menus object, skipping fetch`);
-                }
-            }
-            // Log menu fetching summary
-            console.log(`📊 Menu fetching summary:`, {
-                totalMenuIds: allMenuIds.size,
-                fetchAttempts,
-                fetchSuccesses,
-                fetchFailures,
-                menusInObject: Object.keys(menus).length,
-                menuIdsInObject: Object.keys(menus).map(id => parseInt(id)),
-                menuNames: Object.values(menus).map((m) => m.name || 'unnamed').join(', '),
-            });
-            // Debug: Dump all WordPress theme data in development
-            if (process.env.NODE_ENV === 'development') {
-                const debugData = {
-                    timestamp: new Date().toISOString(),
-                    settings_response: settings,
-                    theme_styles_extracted: themeStyles,
-                    theme_styles_typography: themeStyles?.typography,
-                    theme_styles_colors: themeStyles?.colors,
-                    theme_styles_layout: themeStyles?.layout,
-                    theme_styles_palette: themeStyles?.theme_palette,
-                };
-                // Use same directory as output file (public/)
-                const outputFullPath = join(process.cwd(), this.config.outputPath);
-                const outputDir = dirname(outputFullPath);
-                const debugPath = join(outputDir, 'wp-theme-data.json');
-                try {
-                    writeFileSync(debugPath, JSON.stringify(debugData, null, 2), 'utf-8');
-                    console.log(`📊 Debug: WordPress theme data dumped to ${debugPath}`);
-                }
-                catch (error) {
-                    console.warn('⚠️  Could not write debug file:', error);
-                }
-            }
-        }
-        catch (error) {
-            console.warn('⚠️  Could not fetch WordPress settings, will use fallback logic:', error);
-        }
-        // Fetch standard post types
-        const data = await client.getAllData(fetchParams);
-        // Determine front page if not already set from settings
-        if (!frontPage) {
-            if (settingsPageId) {
-                // Try to find the page by ID from Reading Settings
-                const settingsPage = (data.pages || []).find((p) => p.id === settingsPageId);
-                if (settingsPage) {
-                    const title = typeof settingsPage.title === 'string'
-                        ? settingsPage.title
-                        : (settingsPage.title?.rendered || 'Frontpage');
-                    frontPage = {
-                        id: settingsPage.id,
-                        slug: settingsPage.slug,
-                        title,
-                    };
-                    if (frontPage) {
-                        console.log(`✅ Front page determined from Reading Settings (ID match): ${frontPage.slug} (ID: ${frontPage.id})`);
-                    }
-                }
-            }
-            // Fallback: look for page with slug "frontpage"
-            if (!frontPage) {
-                const frontpagePage = (data.pages || []).find((p) => p.slug === 'frontpage');
-                if (frontpagePage) {
-                    const title = typeof frontpagePage.title === 'string'
-                        ? frontpagePage.title
-                        : (frontpagePage.title?.rendered || 'Frontpage');
-                    frontPage = {
-                        id: frontpagePage.id,
-                        slug: frontpagePage.slug,
-                        title,
-                    };
-                    if (frontPage) {
-                        console.log(`✅ Front page determined from slug "frontpage": ${frontPage.slug} (ID: ${frontPage.id})`);
-                    }
-                }
-                else {
-                    console.log('⚠️  No front page found (neither in Reading Settings nor slug "frontpage")');
-                }
-            }
-        }
-        // Create the static data structure
-        const staticData = {
-            generated_at: new Date().toISOString(),
-            frontend_id: frontendId,
-            frontend_name: frontendName,
-            ...(frontPage && { front_page: frontPage }),
-            ...(siteSettings && { site_settings: siteSettings }),
-            ...(header && { header: header }),
-            ...(menuData && { navigation_menu: menuData }),
-            menus: menus, // Always include menus object, even if empty, for debugging
-            ...(footer && { footer: footer }),
-            ...(themeStyles && { theme_styles: themeStyles }),
-            config: {
-                frontend_id: frontendId,
-                frontend_name: frontendName,
-                post_types: postTypes.reduce((acc, postType) => {
-                    acc[postType] = {
-                        max_items: this.config.maxItems || 100,
-                        include_embedded: this.config.includeEmbedded || true,
-                        orderby: 'date',
-                        order: 'desc',
-                    };
-                    return acc;
-                }, {}),
-            },
-            // Map standard post types
-            posts: data.posts,
-            pages: await Promise.all((data.pages || []).map(async (p) => {
-                // Always use custom blocks endpoint to ensure we get the latest blocks with complete Cloudflare URLs
-                // The custom endpoint (/wp-custom/v1/pages/{id}/blocks) is more reliable and always has the latest data
-                let blocks = [];
-                try {
-                    console.log(`🌐 Fetching blocks from custom endpoint for page "${p.slug}" (ID: ${p.id})...`);
-                    const blocksResponse = await client.getPageBlocks(p.id);
-                    console.log(`📦 Blocks response for "${p.slug}":`, blocksResponse ? `has blocks=${Array.isArray(blocksResponse.blocks) ? blocksResponse.blocks.length : 'N/A'}` : 'null');
-                    if (blocksResponse && Array.isArray(blocksResponse.blocks) && blocksResponse.blocks.length > 0) {
-                        blocks = blocksResponse.blocks;
-                        console.log(`✅ Fetched ${blocks.length} blocks for page "${p.slug}" (ID: ${p.id}) from custom endpoint`);
-                    }
-                    else {
-                        // Fallback: try blocks from API response if custom endpoint is empty
-                        const blocksFromResponse = Array.isArray(p.blocks) ? p.blocks : [];
-                        if (blocksFromResponse.length > 0) {
-                            blocks = blocksFromResponse;
-                            console.log(`⚠️ Custom endpoint returned no blocks, using ${blocks.length} blocks from API response for page "${p.slug}" (ID: ${p.id})`);
-                        }
-                        else {
-                            console.warn(`⚠️ Custom endpoint returned no blocks for page "${p.slug}" (ID: ${p.id})`);
-                            // Last resort: try parsing from content.raw (but this won't work in 'view' context)
-                            const raw = p?.content?.raw || '';
-                            if (raw) {
-                                try {
-                                    blocks = parse(raw);
-                                    if (blocks.length > 0) {
-                                        console.log(`✅ Parsed ${blocks.length} blocks for page "${p.slug}" (ID: ${p.id}) from content.raw`);
-                                    }
-                                }
-                                catch (parseError) {
-                                    console.warn(`⚠️ Failed to parse blocks from content.raw for page "${p.slug}" (ID: ${p.id}):`, parseError);
-                                }
-                            }
-                            else {
-                                console.warn(`⚠️ Page "${p.slug}" (ID: ${p.id}) has no blocks and no content.raw. Plugin may not be active or working.`);
-                            }
-                        }
-                    }
-                }
-                catch (e) {
-                    console.warn(`⚠️ Failed to fetch blocks from custom endpoint for page "${p.slug}" (ID: ${p.id}):`, e.message);
-                    // Fallback: try blocks from API response
-                    const blocksFromResponse = Array.isArray(p.blocks) ? p.blocks : [];
-                    if (blocksFromResponse.length > 0) {
-                        blocks = blocksFromResponse;
-                        console.log(`⚠️ Using ${blocks.length} blocks from API response as fallback for page "${p.slug}" (ID: ${p.id})`);
-                    }
-                    else {
-                        // Last resort: try parsing from content.raw
-                        try {
-                            const raw = p?.content?.raw || '';
-                            if (raw) {
-                                blocks = parse(raw);
-                                if (blocks.length > 0) {
-                                    console.log(`✅ Parsed ${blocks.length} blocks for page "${p.slug}" (ID: ${p.id}) from content.raw (fallback)`);
-                                }
-                            }
-                        }
-                        catch (parseError) {
-                            // Silent fail - we've already logged the warning
-                        }
-                    }
-                }
-                return { ...p, blocks };
-            })),
-            media: data.media,
-            categories: data.categories,
-            tags: data.tags,
-        };
-        // Fetch custom post types (anything beyond the standard posts, pages, media, categories, tags)
-        const standardTypes = ['posts', 'pages', 'media', 'categories', 'tags'];
-        const customPostTypes = postTypes.filter(pt => !standardTypes.includes(pt));
-        if (customPostTypes.length > 0) {
-            console.log(`📦 Fetching custom post types: ${customPostTypes.join(', ')}`);
-            for (const postType of customPostTypes) {
-                try {
-                    console.log(`\n🔍 Fetching custom post type: ${postType}`);
-                    const customData = await client.getCustomPostType(postType, fetchParams);
-                    staticData[postType] = customData;
-                    console.log(`✅ ${postType}: ${customData.length} items fetched`);
-                }
-                catch (error) {
-                    const msg = error?.message || String(error);
-                    const status = error?.response?.status ?? error?.status;
-                    console.warn(`⚠️  Failed to fetch custom post type '${postType}':`, msg);
-                    if (status)
-                        console.warn(`   HTTP status: ${status}`);
-                    if (error?.response?.statusText)
-                        console.warn(`   Status text: ${error.response.statusText}`);
-                    staticData[postType] = [];
-                }
-            }
-            // Enrich CPT items that have featured_media with Cloudflare URL from media list
-            // (API may return WordPress URLs in featured_image_urls; media has cloudflare_image_standardized)
-            const mediaById = new Map();
-            (data.media || []).forEach((m) => {
-                const url = m.cloudflare_image_standardized || m.cloudflare_url;
-                if (url)
-                    mediaById.set(m.id, url);
-            });
-            if (mediaById.size > 0) {
-                for (const postType of customPostTypes) {
-                    const items = staticData[postType];
-                    if (!Array.isArray(items))
-                        continue;
-                    let enriched = 0;
-                    items.forEach((item) => {
-                        const fid = item.featured_media ? Number(item.featured_media) : 0;
-                        if (fid && mediaById.has(fid)) {
-                            item.featured_media_cloudflare_url = mediaById.get(fid);
-                            enriched++;
-                        }
-                    });
-                    if (enriched > 0) {
-                        console.log(`✅ Enriched ${enriched} ${postType} with featured_media_cloudflare_url`);
-                    }
-                }
-            }
-        }
-        // Write to file
-        this.writeStaticData(staticData);
-        console.log('\n✅ WordPress static data generation completed');
-        console.log(`📊 Standard data: ${data.posts.length} posts, ${data.pages.length} pages, ${data.media.length} media`);
-        if (customPostTypes.length > 0) {
-            const customCounts = customPostTypes.map(pt => `${pt}: ${staticData[pt]?.length || 0}`).join(', ');
-            console.log(`📊 Custom data: ${customCounts}`);
-        }
-        return staticData;
-    }
-    writeStaticData(data) {
-        try {
-            const outputPath = join(process.cwd(), this.config.outputPath);
-            writeFileSync(outputPath, JSON.stringify(data, null, 2));
-            console.log(`📁 Static data written to: ${outputPath}`);
-        }
-        catch (error) {
-            console.error('❌ Error writing static data:', error);
-            throw error;
-        }
-    }
-    async generatePostsOnly() {
-        const client = new WordPressClient(this.config);
-        return client.getPosts({ per_page: 100 });
-    }
-    async generatePagesOnly() {
-        const client = new WordPressClient(this.config);
-        return client.getPages({ per_page: 100 });
-    }
-    async generateMediaOnly() {
-        const client = new WordPressClient(this.config);
-        return client.getMedia({ per_page: 100 });
-    }
-}
-// Convenience function for easy usage
-async function generateWordPressData$1(config) {
-    const generator = new WordPressGenerator(config);
-    return generator.generateStaticData();
-}
-
-/**
- * @license GPL-3.0-or-later
- *
- * This file is part of the MarVAlt Open SDK.
- * Copyright (c) 2025 Vibune Pty Ltd.
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
- * See the GNU General Public License for more details.
- */
-class GravityFormsClient {
-    constructor(config) {
-        this.config = config;
-        // Determine mode: direct for generators (Node.js), proxy for browser
-        const hasCredentials = !!(config.username && config.password && config.username.length > 0 && config.password.length > 0);
-        this.useDirectMode = config.authMode === 'direct' && hasCredentials;
-        // Debug logging for Node.js environments (generators)
-        if (typeof process !== 'undefined' && process.env) {
-            console.log('🔍 GravityFormsClient Configuration:', {
-                authMode: config.authMode,
-                hasUsername: !!config.username,
-                hasPassword: !!config.password,
-                hasApiUrl: !!config.apiUrl,
-                useDirectMode: this.useDirectMode,
-            });
-        }
-        // Convention-based: Always use /api/gravity-forms-submit unless explicitly overridden
-        this.proxyEndpoint = config.proxyEndpoint || '/api/gravity-forms-submit';
-    }
-    async makeRequest(endpoint, options = {}) {
-        let url;
-        const headers = {
-            'Content-Type': 'application/json',
-            ...options.headers,
-        };
-        if (this.useDirectMode) {
-            // Direct mode: Call WordPress API directly (for generators/Node.js)
-            url = `${this.config.apiUrl}${endpoint}`;
-            // Add Basic Auth
-            if (this.config.username && this.config.password) {
-                const credentials = btoa(`${this.config.username}:${this.config.password}`);
-                headers['Authorization'] = `Basic ${credentials}`;
-            }
-            // Add Cloudflare Access Service Token headers if provided (for CF Access protected APIs)
-            if (this.config.cfAccessClientId && this.config.cfAccessClientSecret) {
-                headers['CF-Access-Client-Id'] = this.config.cfAccessClientId;
-                headers['CF-Access-Client-Secret'] = this.config.cfAccessClientSecret;
-                console.log('🔐 Added CF Access Service Token headers to Gravity Forms request');
-                console.log('🔐 CF-Access-Client-Id:', this.config.cfAccessClientId.substring(0, 8) + '...');
-                console.log('🔐 CF-Access-Client-Secret:', this.config.cfAccessClientSecret.substring(0, 8) + '... (hidden)');
-            }
-            else {
-                console.log('⚠️  CF Access Service Token NOT provided - requests may be blocked by Zero Trust');
-                console.log('   cfAccessClientId present:', !!this.config.cfAccessClientId);
-                console.log('   cfAccessClientSecret present:', !!this.config.cfAccessClientSecret);
-            }
-        }
-        else {
-            // Proxy mode: Use Pages Function (for browser)
-            const proxyEndpoint = endpoint.startsWith('/') ? endpoint : `/${endpoint}`;
-            url = `${this.proxyEndpoint}?endpoint=${encodeURIComponent(proxyEndpoint)}`;
-        }
-        const response = await fetch(url, {
-            ...options,
-            headers,
-            signal: AbortSignal.timeout(this.config.timeout || 30000),
-        });
-        const responseText = await response.text();
-        if (!response.ok) {
-            // Try to parse error response for validation details
-            let errorDetails = null;
-            try {
-                if (responseText) {
-                    errorDetails = JSON.parse(responseText);
-                }
-            }
-            catch (e) {
-                // Ignore parse errors, use generic error
-            }
-            // Provide helpful error message for 404 (plugin not installed/activated)
-            if (response.status === 404) {
-                const errorMsg = `Gravity Forms API request failed: ${response.status} ${response.statusText}\n` +
-                    `The endpoint ${url} was not found.\n` +
-                    `This usually means the 'gravity-forms-api-endpoint' plugin is not installed or activated on your WordPress site.\n` +
-                    `Please verify:\n` +
-                    `  1. The plugin is installed in /wp-content/plugins/gravity-forms-api-endpoint/\n` +
-                    `  2. The plugin is activated in WordPress admin\n` +
-                    `  3. The endpoint is accessible: ${this.config.apiUrl}/health`;
-                throw new Error(errorMsg);
-            }
-            // For 400 errors, include validation details if available
-            // WordPress REST API formats WP_Error as: { code, message, data: { status, validation_errors? } }
-            if (response.status === 400 && errorDetails) {
-                // Debug logging to see the actual error structure
-                if (typeof process !== 'undefined' && process.env && process.env.NODE_ENV !== 'production') {
-                    console.log('🔍 GravityFormsClient 400 error details:', JSON.stringify(errorDetails, null, 2));
-                }
-                const error = new Error(errorDetails.message || `Gravity Forms API request failed: ${response.status} ${response.statusText}`);
-                error.data = errorDetails;
-                error.code = errorDetails.code;
-                // Extract validation_errors from WordPress REST API format
-                if (errorDetails.data?.validation_errors) {
-                    error.validation_errors = errorDetails.data.validation_errors;
-                }
-                throw error;
-            }
-            throw new Error(`Gravity Forms API request failed: ${response.status} ${response.statusText}`);
-        }
-        if (!responseText) {
-            return [];
-        }
-        try {
-            return JSON.parse(responseText);
-        }
-        catch (error) {
-            console.error('❌ Gravity Forms JSON Parse Error:', {
-                error: error.message,
-                responseText: responseText.substring(0, 500),
-            });
-            throw new Error(`Failed to parse JSON response: ${error.message}`);
-        }
-    }
-    async getForm(id) {
-        // Always use custom gf-api/v1 endpoint (from custom plugin)
-        const endpoint = `/forms/${id}`;
-        return this.makeRequest(endpoint);
-    }
-    async getForms() {
-        // Always use custom gf-api/v1 endpoint (from custom plugin)
-        const endpoint = '/forms';
-        return this.makeRequest(endpoint);
-    }
-    async getFormConfig(id) {
-        // Always use custom gf-api/v1 endpoint (from custom plugin)
-        const endpoint = `/forms/${id}/config`;
-        return this.makeRequest(endpoint);
-    }
-    async submitForm(formId, submission) {
-        // Always use custom gf-api/v1 submit endpoint (from custom plugin)
-        const endpoint = `/forms/${formId}/submit`;
-        // Debug logging
-        console.log('🔍 GravityFormsClient.submitForm called:', {
-            formId,
-            field_values: submission.field_values,
-            field_values_stringified: JSON.stringify(submission.field_values),
-            has_headers: !!submission.headers,
-        });
-        // Merge custom headers (e.g., Turnstile token) with default headers
-        const headers = {
-            'Content-Type': 'application/json',
-            ...(submission.headers || {}),
-        };
-        return this.makeRequest(endpoint, {
-            method: 'POST',
-            headers,
-            body: JSON.stringify(submission.field_values),
-        });
-    }
-    async getHealth() {
-        const endpoint = '/health';
-        return this.makeRequest(endpoint);
-    }
-}
-
-/**
- * @license GPL-3.0-or-later
- *
- * This file is part of the MarVAlt Open SDK.
- * Copyright (c) 2025 Vibune Pty Ltd.
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
- * See the GNU General Public License for more details.
- */
-// Gravity Forms Static Data Generator
-class GravityFormsGenerator {
-    constructor(config) {
-        this.config = config;
-    }
-    async generateStaticData() {
-        const client = new GravityFormsClient(this.config);
-        console.log('🚀 Starting Gravity Forms static data generation...');
-        let forms = [];
-        if (this.config.formIds && this.config.formIds.length > 0) {
-            // Generate specific forms
-            for (const formId of this.config.formIds) {
-                try {
-                    const form = await client.getFormConfig(formId);
-                    if (this.config.includeInactive || form.is_active) {
-                        forms.push(form);
-                    }
-                }
-                catch (error) {
-                    console.warn(`⚠️ Could not fetch form ${formId}:`, error);
-                }
-            }
-        }
-        else {
-            // Generate all forms
-            const formsList = await client.getForms();
-            console.log('🔍 Gravity Forms Response:', {
-                formsType: typeof formsList,
-                isArray: Array.isArray(formsList),
-                formsLength: formsList?.length,
-                formsPreview: formsList ? JSON.stringify(formsList).substring(0, 200) : 'null',
-            });
-            let formsMetadata = [];
-            if (Array.isArray(formsList)) {
-                formsMetadata = formsList;
-            }
-            else if (formsList && typeof formsList === 'object' && Array.isArray(formsList.forms)) {
-                formsMetadata = formsList.forms;
-            }
-            else if (formsList) {
-                formsMetadata = [formsList];
-            }
-            if (!this.config.includeInactive) {
-                formsMetadata = formsMetadata.filter(form => form.is_active === '1' || form.is_active === true);
-            }
-            // Fetch full form configuration for each form (schema lives under /config)
-            console.log(`🔄 Fetching full data for ${formsMetadata.length} forms...`);
-            forms = [];
-            for (const formMetadata of formsMetadata) {
-                try {
-                    const formId = Number(formMetadata.id);
-                    const fullForm = await client.getFormConfig(formId);
-                    forms.push(fullForm);
-                    console.log(`✅ Fetched form: ${fullForm.title} (${fullForm.fields?.length || 0} fields)`);
-                }
-                catch (error) {
-                    console.error(`❌ Failed to fetch form ${formMetadata.id} config:`, error);
-                    throw error;
-                }
-            }
-        }
-        const staticData = {
-            generated_at: new Date().toISOString(),
-            total_forms: forms.length,
-            forms,
-        };
-        // Write to file
-        this.writeStaticData(staticData);
-        console.log('✅ Gravity Forms static data generation completed');
-        console.log(`📊 Generated data: ${forms.length} forms`);
-        return staticData;
-    }
-    writeStaticData(data) {
-        try {
-            const outputPath = join(process.cwd(), this.config.outputPath);
-            writeFileSync(outputPath, JSON.stringify(data, null, 2));
-            console.log(`📁 Static data written to: ${outputPath}`);
-        }
-        catch (error) {
-            console.error('❌ Error writing static data:', error);
-            throw error;
-        }
-    }
-    async generateFormConfig(formId) {
-        const client = new GravityFormsClient(this.config);
-        return client.getFormConfig(formId);
-    }
-}
-// Convenience function for easy usage
-async function generateGravityFormsData$1(config) {
-    const generator = new GravityFormsGenerator(config);
-    return generator.generateStaticData();
-}
+import fs from 'fs';
 
 const DEFAULT_ENABLED_POST_TYPES = 'posts,pages';
 /** Integration tokens in VITE_ENABLED_POST_TYPES that are not WordPress CPTs. */
@@ -1940,464 +123,6 @@ async function generateGravityFormsData(options) {
     }
 }
 
-/**
- * @license GPL-3.0-or-later
- *
- * This file is part of the MarVAlt Open SDK.
- * Copyright (c) 2025 Vibune Pty Ltd.
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
- * See the GNU General Public License for more details.
- */
-class MauticClient {
-    constructor(config) {
-        this.config = config;
-        // Convention-based: Always use /api/mautic-submit unless explicitly overridden
-        this.proxyEndpoint = config.proxyEndpoint || '/api/mautic-submit';
-    }
-    async makeRequest(endpoint, options = {}) {
-        // Always use proxy endpoint (convention-based)
-        const proxyEndpoint = endpoint.startsWith('/') ? endpoint : `/${endpoint}`;
-        const url = `${this.proxyEndpoint}?endpoint=${encodeURIComponent(proxyEndpoint)}`;
-        const isFormSubmission = endpoint.startsWith('/form/submit') ||
-            (endpoint.startsWith('/forms/') && endpoint.includes('/submit'));
-        const headers = {
-            ...options.headers,
-        };
-        // Default JSON only for non-form submissions when a body exists and no explicit content-type provided
-        const hasBody = options.body != null && options.body !== undefined;
-        if (!isFormSubmission && hasBody && !('Content-Type' in headers)) {
-            headers['Content-Type'] = 'application/json';
-        }
-        try {
-            const response = await fetch(url, {
-                ...options,
-                headers,
-            });
-            // Determine if this was a form submission based on the original endpoint
-            const wasFormSubmission = endpoint.startsWith('/form/submit') ||
-                (endpoint.startsWith('/forms/') && endpoint.includes('/submit'));
-            if (!response.ok) {
-                // For form submissions, some Mautic setups respond with an HTML 404 after a successful submit.
-                // Do not treat this as an error; let the frontend handle success/redirect messaging.
-                const isRedirect = response.status >= 300 && response.status < 400;
-                const isHtmlLike = (response.headers.get('content-type') || '').includes('text/html');
-                if (!(wasFormSubmission && (isRedirect || response.status === 404 || isHtmlLike))) {
-                    throw new Error(`Mautic API request failed: ${response.status} ${response.statusText}`);
-                }
-            }
-            const responseText = await response.text();
-            // Handle empty responses
-            if (!responseText) {
-                return [];
-            }
-            // For Mautic form submissions, the response may be HTML. Try JSON first, fallback to text.
-            try {
-                return JSON.parse(responseText);
-            }
-            catch {
-                return responseText;
-            }
-        }
-        catch (error) {
-            const message = error instanceof Error ? error.message : String(error);
-            console.error('Mautic API request error:', message);
-            throw new Error(message);
-        }
-    }
-    /**
-     * Submit a form to Mautic
-     */
-    async submitForm(formId, submission) {
-        // Endpoint should be just the path, without query string (formId is in the body)
-        const endpoint = `/form/submit`;
-        // Encode as application/x-www-form-urlencoded to match Mautic expectations
-        const formParams = new URLSearchParams();
-        // Add fields
-        Object.entries(submission.fields || {}).forEach(([alias, value]) => {
-            if (Array.isArray(value)) {
-                value.forEach((v) => formParams.append(`mauticform[${alias}]`, String(v)));
-            }
-            else if (typeof value === 'boolean') {
-                formParams.append(`mauticform[${alias}]`, value ? '1' : '0');
-            }
-            else if (value != null) {
-                formParams.append(`mauticform[${alias}]`, String(value));
-            }
-        });
-        // Required hidden fields
-        formParams.append('mauticform[formId]', String(formId));
-        // Prevent Mautic from attempting a redirect; frontend will handle any redirect
-        formParams.append('mauticform[return]', '');
-        // Mautic submit flag similar to native form button name/value
-        formParams.append('mauticform[submit]', '1');
-        // Include formName only if provided (derived from cachedHtml)
-        if (submission.formName) {
-            formParams.append('mauticform[formName]', submission.formName);
-        }
-        // Merge custom headers (e.g., Turnstile token) with default headers
-        const headers = {
-            'Content-Type': 'application/x-www-form-urlencoded',
-            ...(submission.headers || {}),
-        };
-        return this.makeRequest(endpoint, {
-            method: 'POST',
-            headers,
-            body: formParams.toString(),
-        });
-    }
-    /**
-     * Create a new contact in Mautic
-     */
-    async createContact(contact) {
-        return this.makeRequest('/contacts/new', {
-            method: 'POST',
-            body: JSON.stringify(contact),
-        });
-    }
-    /**
-     * Update an existing contact in Mautic
-     */
-    async updateContact(contactId, contact) {
-        return this.makeRequest(`/contacts/${contactId}/edit`, {
-            method: 'PATCH',
-            body: JSON.stringify(contact),
-        });
-    }
-    /**
-     * Get a contact by email
-     */
-    async getContactByEmail(email) {
-        return this.makeRequest(`/contacts?search=email:${encodeURIComponent(email)}`);
-    }
-    /**
-     * Get all forms from Mautic
-     */
-    async getForms() {
-        const response = await this.makeRequest('/forms');
-        return response.forms || [];
-    }
-    /**
-     * Get a specific form by ID
-     */
-    async getForm(formId) {
-        return this.makeRequest(`/forms/${formId}`);
-    }
-    /**
-     * Track an event in Mautic
-     */
-    async trackEvent(eventName, eventData = {}) {
-        return this.makeRequest('/events', {
-            method: 'POST',
-            body: JSON.stringify({
-                eventName,
-                eventData,
-            }),
-        });
-    }
-    /**
-     * Add tags to a contact
-     */
-    async addTagToContact(contactId, tags) {
-        return this.makeRequest(`/contacts/${contactId}/tags`, {
-            method: 'POST',
-            body: JSON.stringify({ tags }),
-        });
-    }
-    /**
-     * Remove tags from a contact
-     */
-    async removeTagFromContact(contactId, tags) {
-        return this.makeRequest(`/contacts/${contactId}/tags`, {
-            method: 'DELETE',
-            body: JSON.stringify({ tags }),
-        });
-    }
-    /**
-     * Get contact tags
-     */
-    async getContactTags(contactId) {
-        return this.makeRequest(`/contacts/${contactId}/tags`);
-    }
-    /**
-     * Get all tags
-     */
-    async getTags() {
-        return this.makeRequest('/tags');
-    }
-    /**
-     * Get segments
-     */
-    async getSegments() {
-        return this.makeRequest('/segments');
-    }
-    /**
-     * Add contact to segment
-     */
-    async addContactToSegment(contactId, segmentId) {
-        return this.makeRequest(`/contacts/${contactId}/segments`, {
-            method: 'POST',
-            body: JSON.stringify({ segmentId }),
-        });
-    }
-    /**
-     * Remove contact from segment
-     */
-    async removeContactFromSegment(contactId, segmentId) {
-        return this.makeRequest(`/contacts/${contactId}/segments`, {
-            method: 'DELETE',
-            body: JSON.stringify({ segmentId }),
-        });
-    }
-}
-
-/**
- * @license GPL-3.0-or-later
- *
- * This file is part of the MarVAlt Open SDK.
- * Copyright (c) 2025 Vibune Pty Ltd.
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
- * See the GNU General Public License for more details.
- */
-class MauticGenerator {
-    constructor(config) {
-        this.cachedToken = null;
-        this.config = config;
-        // Generator uses direct OAuth2 calls, not the client
-        // Client is only used for proxy mode (cloudflare_proxy)
-        this.client = new MauticClient({
-            apiUrl: config.apiUrl,
-            proxyEndpoint: config.cloudflareWorkerUrl,
-            timeout: config.timeout,
-            retries: config.retries,
-        });
-    }
-    /**
-     * Get OAuth2 token for direct mode API calls
-     */
-    async getOAuth2Token() {
-        if (this.cachedToken && this.cachedToken.expires_at > Date.now() + 300000) {
-            console.log('🔑 Using cached OAuth2 token');
-            return this.cachedToken.access_token;
-        }
-        if (!this.config.clientId || !this.config.clientSecret) {
-            throw new Error('OAuth2 credentials (clientId, clientSecret) required for direct mode');
-        }
-        console.log('🔑 Fetching new OAuth2 token...');
-        const tokenUrl = `${this.config.apiUrl}/oauth/v2/token`;
-        const body = new URLSearchParams({
-            grant_type: 'client_credentials',
-            client_id: this.config.clientId,
-            client_secret: this.config.clientSecret,
-        });
-        const headers = { 'Content-Type': 'application/x-www-form-urlencoded' };
-        if (this.config.cfAccessClientId && this.config.cfAccessClientSecret) {
-            headers['CF-Access-Client-Id'] = this.config.cfAccessClientId;
-            headers['CF-Access-Client-Secret'] = this.config.cfAccessClientSecret;
-            console.log('🔐 Added CF Access headers to OAuth2 token request');
-        }
-        const resp = await fetch(tokenUrl, { method: 'POST', headers, body: body.toString() });
-        if (!resp.ok) {
-            const errText = await resp.text();
-            throw new Error(`OAuth2 token failed: ${resp.status} ${errText}`);
-        }
-        const data = await resp.json();
-        this.cachedToken = {
-            access_token: data.access_token,
-            expires_at: Date.now() + (data.expires_in * 1000),
-        };
-        console.log('✅ OAuth2 token cached');
-        return this.cachedToken.access_token;
-    }
-    /**
-     * Generate static data for Mautic forms
-     */
-    async generateStaticData() {
-        console.log('🔄 Generating Mautic forms JSON data...');
-        try {
-            const allForms = await this.fetchMauticFormsList();
-            console.log(`📝 Found ${allForms.length} forms`);
-            const forms = [];
-            for (const formSummary of allForms) {
-                const formId = formSummary.id?.toString();
-                if (!formId) {
-                    console.warn(`⚠️ Form summary missing ID:`, formSummary);
-                    continue;
-                }
-                try {
-                    const formDetails = await this.fetchMauticForm(formId);
-                    if (!formDetails) {
-                        console.warn(`⚠️ No form details returned for form ${formId}`);
-                        continue;
-                    }
-                    // Extract the form data with proper structure
-                    const formData = {
-                        id: formId,
-                        name: formDetails.name || formSummary.name || `Form ${formId}`,
-                        description: formDetails.description,
-                        isPublished: formDetails.isPublished || formSummary.isPublished || false,
-                        // Include post-submission behavior configuration
-                        postAction: formDetails.postAction || 'message',
-                        postActionProperty: formDetails.postActionProperty || 'Thank you for your submission!',
-                        // Include other important form properties
-                        formType: formDetails.formType || 'standalone',
-                        // Extract fields with validation and properties
-                        fields: (formDetails.fields || []).map((field) => ({
-                            id: field.id,
-                            label: field.label,
-                            alias: field.alias,
-                            type: field.type,
-                            isRequired: field.isRequired || false,
-                            validationMessage: field.validationMessage,
-                            defaultValue: field.defaultValue,
-                            properties: {
-                                placeholder: field.properties?.placeholder,
-                                cssClass: field.properties?.cssClass,
-                                validation: field.properties?.validation,
-                                options: field.properties?.options,
-                                helpText: field.properties?.helpText,
-                                size: field.properties?.size,
-                                ...field.properties
-                            }
-                        })),
-                        // Extract actions
-                        actions: (formDetails.actions || []).map((action) => ({
-                            id: action.id,
-                            name: action.name,
-                            type: action.type,
-                            properties: action.properties || {}
-                        })),
-                        // Include styling and behavior
-                        cssClass: formDetails.cssClass,
-                        submitAction: formDetails.submitAction,
-                        // Keep the details for reference
-                        ...formSummary
-                    };
-                    forms.push(formData);
-                    console.log(`✅ Processed form: ${formData.name} (ID: ${formId})`);
-                }
-                catch (error) {
-                    const message = error instanceof Error ? error.message : String(error);
-                    console.error(`❌ Error processing form ${formId}:`, message);
-                    // Continue with other forms
-                }
-            }
-            const staticData = {
-                generated_at: new Date().toISOString(),
-                total_forms: forms.length,
-                forms: forms.map((form) => ({
-                    id: parseInt(form.id),
-                    name: form.name,
-                    alias: String(form.alias ?? (form.name || '').toLowerCase().replace(/\s+/g, '-')),
-                    description: form.description,
-                    isPublished: form.isPublished,
-                    fields: form.fields,
-                    actions: form.actions,
-                    cssClass: form.cssClass,
-                    submitAction: form.submitAction,
-                    postAction: form.postAction,
-                    postActionProperty: form.postActionProperty,
-                    formType: form.formType,
-                }))
-            };
-            console.log(`✅ Generated static data for ${forms.length} forms`);
-            return staticData;
-        }
-        catch (error) {
-            const message = error instanceof Error ? error.message : String(error);
-            console.error('❌ Error generating Mautic static data:', message);
-            throw new Error(message);
-        }
-    }
-    /**
-     * Write static data to file
-     */
-    async writeStaticData(staticData) {
-        const outputPath = path.resolve(this.config.outputPath);
-        const outputDir = path.dirname(outputPath);
-        // Ensure output directory exists
-        if (!fs.existsSync(outputDir)) {
-            fs.mkdirSync(outputDir, { recursive: true });
-        }
-        // Write the static data
-        fs.writeFileSync(outputPath, JSON.stringify(staticData, null, 2));
-        console.log(`📁 Static data written to: ${outputPath}`);
-    }
-    /**
-     * Generate and write static data
-     */
-    async generateAndWrite() {
-        const staticData = await this.generateStaticData();
-        await this.writeStaticData(staticData);
-        return staticData;
-    }
-    /**
-     * Fetch list of forms from Mautic
-     */
-    async fetchMauticFormsList() {
-        if (this.config.authMode === 'cloudflare_proxy') {
-            const forms = await this.client.getForms();
-            return Array.isArray(forms) ? forms : [];
-        }
-        // Direct mode with OAuth2
-        const token = await this.getOAuth2Token();
-        const url = `${this.config.apiUrl}/api/forms`;
-        const headers = { 'Authorization': `Bearer ${token}` };
-        if (this.config.cfAccessClientId && this.config.cfAccessClientSecret) {
-            headers['CF-Access-Client-Id'] = this.config.cfAccessClientId;
-            headers['CF-Access-Client-Secret'] = this.config.cfAccessClientSecret;
-        }
-        const resp = await fetch(url, { headers });
-        if (!resp.ok)
-            throw new Error(`Failed to fetch forms: ${resp.status}`);
-        const data = await resp.json();
-        return Array.isArray(data.forms) ? data.forms : [];
-    }
-    /**
-     * Fetch individual form details from Mautic
-     */
-    async fetchMauticForm(formId) {
-        if (this.config.authMode === 'cloudflare_proxy') {
-            return this.client.getForm(parseInt(formId, 10));
-        }
-        // Direct mode with OAuth2
-        const token = await this.getOAuth2Token();
-        const url = `${this.config.apiUrl}/api/forms/${formId}`;
-        const headers = { 'Authorization': `Bearer ${token}` };
-        if (this.config.cfAccessClientId && this.config.cfAccessClientSecret) {
-            headers['CF-Access-Client-Id'] = this.config.cfAccessClientId;
-            headers['CF-Access-Client-Secret'] = this.config.cfAccessClientSecret;
-        }
-        const resp = await fetch(url, { headers });
-        if (!resp.ok)
-            throw new Error(`Failed to fetch form ${formId}: ${resp.status}`);
-        const data = await resp.json();
-        return data.form || data;
-    }
-}
-/**
- * Generate Mautic static data with configuration
- */
-async function generateMauticData$1(config) {
-    const generator = new MauticGenerator(config);
-    return generator.generateAndWrite();
-}
-
 async function generateMauticData(options) {
     const outputPath = options?.outputPath || './src/data/mautic-data.json';
     const mauticUrl = process.env.MAUTIC_URL || process.env.VITE_MAUTIC_URL;
@@ -2433,255 +158,6 @@ async function generateMauticData(options) {
     }
 }
 
-/** Normalize PHPList base URL to REST API v2 root. */
-function getApiBaseUrl(phplistUrl) {
-    const trimmed = phplistUrl.replace(/\/$/, '');
-    if (trimmed.endsWith('/api/v2'))
-        return trimmed;
-    if (trimmed.endsWith('/lists'))
-        return `${trimmed}/api/v2`;
-    return `${trimmed}/lists/api/v2`;
-}
-function buildViewProxyPath(messageId, uid) {
-    const params = new URLSearchParams({ endpoint: 'view', mid: String(messageId) });
-    return `/api/phplist-proxy?${params.toString()}`;
-}
-
-let cachedSession = null;
-function buildAccessHeaders(options) {
-    const headers = {};
-    if (options.cfAccessClientId && options.cfAccessClientSecret) {
-        headers['CF-Access-Client-Id'] = options.cfAccessClientId;
-        headers['CF-Access-Client-Secret'] = options.cfAccessClientSecret;
-    }
-    return headers;
-}
-async function createPhplistSession(options) {
-    if (cachedSession && cachedSession.expiresAt > Date.now() + 300000) {
-        return cachedSession.key;
-    }
-    const apiBase = getApiBaseUrl(options.apiUrl);
-    const headers = {
-        'Content-Type': 'application/json',
-        ...buildAccessHeaders(options),
-    };
-    const response = await fetch(`${apiBase}/sessions`, {
-        method: 'POST',
-        headers,
-        body: JSON.stringify({
-            login_name: options.apiUser,
-            password: options.apiPassword,
-        }),
-    });
-    if (!response.ok) {
-        const errText = await response.text();
-        throw new Error(`PHPList session failed: ${response.status} ${errText}`);
-    }
-    const data = (await response.json());
-    const expiryMs = data.expiry ? Date.parse(data.expiry) : Date.now() + 3600000;
-    cachedSession = { key: data.key, expiresAt: expiryMs };
-    return data.key;
-}
-async function phplistApiFetch(options, path, init = {}) {
-    const sessionKey = await createPhplistSession(options);
-    const apiBase = getApiBaseUrl(options.apiUrl);
-    const url = path.startsWith('http') ? path : `${apiBase}${path.startsWith('/') ? path : `/${path}`}`;
-    const headers = {
-        'Content-Type': 'application/json',
-        'php-auth-pw': sessionKey,
-        ...init.headers,
-        ...buildAccessHeaders(options),
-    };
-    const response = await fetch(url, { ...init, headers });
-    if (!response.ok) {
-        const errText = await response.text();
-        throw new Error(`PHPList API ${path} failed: ${response.status} ${errText}`);
-    }
-    if (response.status === 204) {
-        return undefined;
-    }
-    const text = await response.text();
-    if (!text)
-        return undefined;
-    return JSON.parse(text);
-}
-
-/** URL-safe slug from subject line. */
-function slugifySubject(subject) {
-    return subject
-        .toLowerCase()
-        .normalize('NFKD')
-        .replace(/[\u0300-\u036f]/g, '')
-        .replace(/[^a-z0-9]+/g, '-')
-        .replace(/^-+|-+$/g, '')
-        .slice(0, 80) || 'newsletter';
-}
-function slugifyListName(name) {
-    return slugifySubject(name);
-}
-function buildNewsletterSlug(listSlug, messageId, subject) {
-    return `${listSlug}/${messageId}-${slugifySubject(subject)}`;
-}
-function stripHtmlExcerpt(html, maxLength = 200) {
-    const text = html
-        .replace(/<style[^>]*>[\s\S]*?<\/style>/gi, '')
-        .replace(/<script[^>]*>[\s\S]*?<\/script>/gi, '')
-        .replace(/<[^>]+>/g, ' ')
-        .replace(/\s+/g, ' ')
-        .trim();
-    if (text.length <= maxLength)
-        return text;
-    return `${text.slice(0, maxLength).trim()}…`;
-}
-
-async function generatePhplistData$1(config) {
-    console.log('🔄 Generating PHPList newsletter JSON data...');
-    try {
-        const authOptions = {
-            apiUrl: config.apiUrl,
-            apiUser: config.apiUser,
-            apiPassword: config.apiPassword,
-            cfAccessClientId: config.cfAccessClientId,
-            cfAccessClientSecret: config.cfAccessClientSecret,
-        };
-        const list = await phplistApiFetch(authOptions, `/lists/${config.listId}`);
-        const listSlug = slugifyListName(list.name);
-        const existing = readExistingData(config.outputPath);
-        const knownIds = new Set(existing?.newsletters.map((n) => n.id) ?? []);
-        const lastSentAt = existing?.newsletters.reduce((max, n) => {
-            const t = Date.parse(n.sent_at);
-            return Number.isNaN(t) ? max : Math.max(max, t);
-        }, 0) ?? 0;
-        const listMessageIds = await fetchListMessageIds(authOptions, config.listId);
-        const listMessageIdSet = new Set(listMessageIds);
-        const newItems = [];
-        let afterId = 0;
-        let hasMore = true;
-        while (hasMore) {
-            const page = await phplistApiFetch(authOptions, `/campaigns?limit=100&after_id=${afterId || 1}`);
-            const items = page.items ?? [];
-            if (items.length === 0)
-                break;
-            for (const summary of items) {
-                const id = summary.id;
-                if (!id || !listMessageIdSet.has(id) || knownIds.has(id))
-                    continue;
-                if (summary.message_metadata?.status !== 'sent')
-                    continue;
-                const sentAt = summary.message_metadata?.sent;
-                if (sentAt && lastSentAt > 0 && Date.parse(sentAt) <= lastSentAt) {
-                    continue;
-                }
-                const detail = await phplistApiFetch(authOptions, `/campaigns/${id}`);
-                const item = messageToNewsletter(detail, listSlug, config.newsletterRouteBase);
-                if (item) {
-                    newItems.push(item);
-                    knownIds.add(id);
-                }
-            }
-            const lastId = items[items.length - 1]?.id;
-            if (!lastId || items.length < 100) {
-                hasMore = false;
-            }
-            else {
-                afterId = lastId;
-                const oldestSent = items
-                    .map((m) => m.message_metadata?.sent)
-                    .filter(Boolean)
-                    .map((s) => Date.parse(s))
-                    .filter((t) => !Number.isNaN(t));
-                if (lastSentAt > 0 && oldestSent.length && Math.min(...oldestSent) <= lastSentAt) {
-                    hasMore = false;
-                }
-            }
-        }
-        const mergedNewsletters = [
-            ...(existing?.newsletters ?? []),
-            ...newItems,
-        ].sort((a, b) => Date.parse(b.sent_at) - Date.parse(a.sent_at));
-        const subscribePages = await fetchSubscribePages(authOptions, config.subscribePageIds);
-        const data = {
-            generated_at: new Date().toISOString(),
-            list: {
-                id: list.id,
-                name: list.name,
-                slug: listSlug,
-                description: list.description,
-            },
-            subscribe_pages: subscribePages,
-            newsletters: mergedNewsletters,
-        };
-        writeStaticData(config.outputPath, data);
-        console.log(`✅ PHPList: ${mergedNewsletters.length} newsletters (${newItems.length} new)`);
-        return { success: true, data };
-    }
-    catch (error) {
-        const message = error instanceof Error ? error.message : String(error);
-        console.warn(`⚠️  PHPList generation failed: ${message}`);
-        return { success: false, error: message };
-    }
-}
-async function fetchListMessageIds(authOptions, listId) {
-    const response = await phplistApiFetch(authOptions, `/list-messages/list/${listId}/messages`);
-    return (response.items ?? []).map((row) => row.message_id).filter(Boolean);
-}
-async function fetchSubscribePages(authOptions, pageIds) {
-    const pages = [];
-    for (const pageId of pageIds) {
-        try {
-            const publicPage = await phplistApiFetch(authOptions, `/public/subscribe-pages/${pageId}`);
-            pages.push({
-                id: pageId,
-                title: publicPage.title,
-                intro: publicPage.intro,
-                attributes: publicPage.attributes ?? [],
-                list_ids: publicPage.list_ids,
-            });
-        }
-        catch (e) {
-            console.warn(`⚠️  Could not load subscribe page ${pageId}:`, e.message);
-        }
-    }
-    return pages;
-}
-function messageToNewsletter(message, listSlug, _routeBase) {
-    const subject = message.message_content?.subject?.trim();
-    const html = message.message_content?.text ?? '';
-    const sentAt = message.message_metadata?.sent;
-    if (!subject || !sentAt || message.message_metadata?.status !== 'sent') {
-        return null;
-    }
-    const slug = buildNewsletterSlug(listSlug, message.id, subject);
-    return {
-        id: message.id,
-        unique_id: message.unique_id,
-        slug,
-        subject,
-        sent_at: sentAt,
-        excerpt: stripHtmlExcerpt(html),
-        html,
-        plain_text: message.message_content?.text_message,
-        view_url: buildViewProxyPath(message.id),
-    };
-}
-function readExistingData(outputPath) {
-    try {
-        if (!fs.existsSync(outputPath))
-            return null;
-        return JSON.parse(fs.readFileSync(outputPath, 'utf8'));
-    }
-    catch {
-        return null;
-    }
-}
-function writeStaticData(outputPath, data) {
-    const dir = path.dirname(outputPath);
-    if (!fs.existsSync(dir)) {
-        fs.mkdirSync(dir, { recursive: true });
-    }
-    fs.writeFileSync(outputPath, JSON.stringify(data, null, 2), 'utf8');
-}
-
 function parseSubscribePageIds(raw) {
     if (!raw?.trim())
         return [];
@@ -3120,20 +596,20 @@ async function generateAllData() {
 }
 
 var index = /*#__PURE__*/Object.freeze({
-  __proto__: null,
-  PSEUDO_POST_TYPES: PSEUDO_POST_TYPES,
-  generateAllData: generateAllData,
-  generateGoogleReviewsData: generateGoogleReviewsData,
-  generateGravityFormsData: generateGravityFormsData,
-  generateMauticData: generateMauticData,
-  generatePhplistData: generatePhplistData,
-  generateSitemapPaths: generateSitemapPaths,
-  generateSitemapPathsSafe: generateSitemapPathsSafe,
-  generateSuiteCRMData: generateSuiteCRMData,
-  generateWordPressData: generateWordPressData,
-  getWordPressPostTypes: getWordPressPostTypes,
-  isGoogleReviewsEnabled: isGoogleReviewsEnabled,
-  parseEnabledPostTypes: parseEnabledPostTypes
+    __proto__: null,
+    PSEUDO_POST_TYPES: PSEUDO_POST_TYPES,
+    generateAllData: generateAllData,
+    generateGoogleReviewsData: generateGoogleReviewsData,
+    generateGravityFormsData: generateGravityFormsData,
+    generateMauticData: generateMauticData,
+    generatePhplistData: generatePhplistData,
+    generateSitemapPaths: generateSitemapPaths,
+    generateSitemapPathsSafe: generateSitemapPathsSafe,
+    generateSuiteCRMData: generateSuiteCRMData,
+    generateWordPressData: generateWordPressData,
+    getWordPressPostTypes: getWordPressPostTypes,
+    isGoogleReviewsEnabled: isGoogleReviewsEnabled,
+    parseEnabledPostTypes: parseEnabledPostTypes
 });
 
 /**