@marvalt/digivalt-core 0.1.6 → 0.2.0

package/dist/generators.esm.js

@@ -0,0 +1,2475 @@
+import dotenv from 'dotenv';
+import path, { join, dirname } from 'path';
+import fs, { writeFileSync } from 'fs';
+import { generateSuiteCRMData as generateSuiteCRMData$1 } from '@marvalt/sadapter';
+
+/**
+ * @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();
+}
+
+async function generateWordPressData(options) {
+    const outputPath = options?.outputPath || './public/wordpress-data.json';
+    const apiUrl = process.env.WORDPRESS_API_URL || process.env.VITE_WORDPRESS_API_URL;
+    const username = process.env.WP_API_USERNAME || process.env.VITE_WP_API_USERNAME;
+    const password = process.env.WP_APP_PASSWORD || process.env.VITE_WP_APP_PASSWORD;
+    const cloudflareWorkerUrl = process.env.CLOUDFLARE_WORKER_URL || process.env.VITE_CLOUDFLARE_WORKER_URL;
+    const cfAccessClientId = process.env.CF_ACCESS_CLIENT_ID || process.env.VITE_CF_ACCESS_CLIENT_ID;
+    const cfAccessClientSecret = process.env.CF_ACCESS_CLIENT_SECRET || process.env.VITE_CF_ACCESS_CLIENT_SECRET;
+    if (!apiUrl) {
+        console.error('❌ Missing WordPress API URL. Set WORDPRESS_API_URL or VITE_WORDPRESS_API_URL');
+        return false;
+    }
+    const localDev = process.env.VITE_LOCAL_DEVELOPMENT === 'true';
+    const requestedAuth = process.env.VITE_AUTH_MODE;
+    const hasProxy = !!cloudflareWorkerUrl;
+    const authMode = localDev ? 'direct' : (requestedAuth === 'cloudflare_proxy' && hasProxy ? 'cloudflare_proxy' : 'direct');
+    const config = {
+        authMode,
+        cloudflareWorkerUrl: authMode === 'cloudflare_proxy' ? cloudflareWorkerUrl : undefined,
+        apiUrl,
+        username,
+        password,
+        cfAccessClientId,
+        cfAccessClientSecret,
+    };
+    const enabledPostTypes = process.env.VITE_ENABLED_POST_TYPES || process.env.ENABLED_POST_TYPES || 'posts,pages';
+    const rawPostTypes = enabledPostTypes.split(',').map(pt => pt.trim()).filter(Boolean);
+    const postTypeMapping = {
+        'members': 'member',
+        'testimonials': 'testimonial',
+        'faqs': 'faq',
+        'eventbrite_events': 'eventbrite_event',
+    };
+    const postTypes = rawPostTypes.map(pt => postTypeMapping[pt] || pt);
+    const frontendId = process.env.VITE_FRONTEND_ID || process.env.FRONTEND_ID || undefined;
+    const frontendName = process.env.VITE_FRONTEND_NAME || process.env.FRONTEND_NAME || 'Default Frontend';
+    try {
+        const result = await generateWordPressData$1({
+            ...config,
+            outputPath,
+            postTypes,
+            ...(frontendId && { frontendId }),
+            frontendName,
+            includeEmbedded: true,
+            maxItems: parseInt(process.env.VITE_DEFAULT_MAX_ITEMS || '200', 10),
+        });
+        console.log(`📁 WordPress data written to: ${path.join(process.cwd(), outputPath)}`);
+        return true;
+    }
+    catch (e) {
+        console.error('❌ WordPress generation failed:', e.message);
+        return false;
+    }
+}
+
+async function generateGravityFormsData(options) {
+    const outputPath = options?.outputPath || './public/gravity-forms-data.json';
+    const wpApiUrl = process.env.WORDPRESS_API_URL || process.env.VITE_WORDPRESS_API_URL;
+    const gfApiUrl = process.env.GRAVITY_FORMS_API_URL || process.env.VITE_GRAVITY_FORMS_API_URL;
+    const username = process.env.GRAVITY_FORMS_USERNAME || process.env.VITE_GRAVITY_FORMS_USERNAME ||
+        process.env.WP_API_USERNAME || process.env.VITE_WP_API_USERNAME || '';
+    const password = process.env.GRAVITY_FORMS_PASSWORD || process.env.VITE_GRAVITY_FORMS_PASSWORD ||
+        process.env.WP_APP_PASSWORD || process.env.VITE_WP_APP_PASSWORD || '';
+    const cloudflareWorkerUrl = process.env.CLOUDFLARE_WORKER_URL || process.env.VITE_CLOUDFLARE_WORKER_URL;
+    const cfAccessClientId = process.env.CF_ACCESS_CLIENT_ID || process.env.VITE_CF_ACCESS_CLIENT_ID;
+    const cfAccessClientSecret = process.env.CF_ACCESS_CLIENT_SECRET || process.env.VITE_CF_ACCESS_CLIENT_SECRET;
+    const apiUrl = gfApiUrl || (wpApiUrl ? `${wpApiUrl}/wp-json/gf-api/v1` : undefined);
+    if (!apiUrl) {
+        console.error('❌ Missing WordPress/Gravity Forms API URL.');
+        return false;
+    }
+    const localDev = process.env.VITE_LOCAL_DEVELOPMENT === 'true';
+    const requestedAuth = process.env.VITE_AUTH_MODE;
+    const hasProxy = !!cloudflareWorkerUrl;
+    const authMode = localDev ? 'direct' : (requestedAuth === 'cloudflare_proxy' && hasProxy ? 'cloudflare_proxy' : 'direct');
+    const config = {
+        authMode,
+        cloudflareWorkerUrl: authMode === 'cloudflare_proxy' ? cloudflareWorkerUrl : undefined,
+        apiUrl,
+        username,
+        password,
+        cfAccessClientId,
+        cfAccessClientSecret,
+        useCustomEndpoint: true,
+    };
+    try {
+        const result = await generateGravityFormsData$1({
+            ...config,
+            outputPath,
+            includeInactive: false,
+        });
+        console.log(`📁 Gravity Forms data written to: ${path.join(process.cwd(), outputPath)}`);
+        return true;
+    }
+    catch (e) {
+        console.error('❌ Gravity Forms generation failed:', e.message);
+        return false;
+    }
+}
+
+/**
+ * @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;
+    const mauticProxyUrl = process.env.MAUTIC_PROXY_URL || process.env.VITE_MAUTIC_PROXY_URL;
+    const clientId = process.env.MAUTIC_API_PUBLIC_KEY || process.env.VITE_MAUTIC_API_PUBLIC_KEY;
+    const clientSecret = process.env.MAUTIC_API_SECRET_KEY || process.env.VITE_MAUTIC_API_SECRET_KEY;
+    const cfAccessClientId = process.env.CF_ACCESS_CLIENT_ID || process.env.VITE_CF_ACCESS_CLIENT_ID;
+    const cfAccessClientSecret = process.env.CF_ACCESS_CLIENT_SECRET || process.env.VITE_CF_ACCESS_CLIENT_SECRET;
+    if (!mauticUrl) {
+        console.log('⚠️  Mautic URL not configured. Skipping Mautic data generation.');
+        return true;
+    }
+    try {
+        const hasProxy = !!mauticProxyUrl;
+        const authMode = hasProxy ? 'cloudflare_proxy' : 'direct';
+        const result = await generateMauticData$1({
+            authMode,
+            apiUrl: mauticUrl,
+            cloudflareWorkerUrl: authMode === 'cloudflare_proxy' ? mauticProxyUrl : undefined,
+            clientId: clientId,
+            clientSecret: clientSecret,
+            cfAccessClientId,
+            cfAccessClientSecret,
+            outputPath,
+            includeInactive: false,
+        });
+        console.log(`📁 Mautic data written to: ${path.join(process.cwd(), outputPath)}`);
+        return true;
+    }
+    catch (e) {
+        console.error('❌ Mautic generation failed:', e.message);
+        return false;
+    }
+}
+
+async function generateSuiteCRMData(options) {
+    const outputPath = options?.outputPath || './src/data/suitecrm-data.json';
+    const apiUrl = process.env.VITE_SUITECRM_URL;
+    if (!apiUrl) {
+        console.log('⚠️  SuiteCRM URL not configured. Skipping SuiteCRM data generation.');
+        return true;
+    }
+    try {
+        const hasProxy = !!process.env.VITE_SUITECRM_PROXY_URL;
+        const authMode = hasProxy ? 'cloudflare_proxy' : 'direct';
+        const result = await generateSuiteCRMData$1({
+            authMode,
+            apiUrl,
+            proxyUrl: authMode === 'cloudflare_proxy' ? process.env.VITE_SUITECRM_PROXY_URL : undefined,
+            oauth2: {
+                clientId: process.env.VITE_SUITECRM_CLIENT_ID,
+                clientSecret: process.env.VITE_SUITECRM_CLIENT_SECRET,
+                username: process.env.VITE_SUITECRM_USERNAME,
+                password: process.env.VITE_SUITECRM_PASSWORD,
+            },
+            accessFunctionPath: '/api/fetch-with-access',
+            outputPath,
+            modules: ['Leads', 'Contacts', 'Accounts'],
+            includeFields: true,
+            includeRelationships: false,
+        });
+        console.log(`📁 SuiteCRM data written to: ${path.join(process.cwd(), outputPath)}`);
+        return true;
+    }
+    catch (e) {
+        console.error('❌ SuiteCRM generation failed:', e.message);
+        return false;
+    }
+}
+
+async function generateAllData() {
+    // Load .env files if they exist (for local development)
+    dotenv.config();
+    dotenv.config({ path: '.env.local' });
+    console.log('🚀 Starting DigiVAlt static data generation...');
+    if (process.env.VITE_IS_LOVABLE === 'true') {
+        console.log('⚡ Lovable Environment Detected (VITE_IS_LOVABLE). Skipping static data generation to use GitHub synced static files.');
+        return;
+    }
+    const wpSuccess = await generateWordPressData();
+    const gfSuccess = await generateGravityFormsData();
+    const mauticSuccess = await generateMauticData();
+    const suitecrmSuccess = await generateSuiteCRMData();
+    if (!wpSuccess || !gfSuccess || !mauticSuccess || !suitecrmSuccess) {
+        console.error('❌ Some generation tasks failed. See above for details.');
+        process.exit(1);
+    }
+    console.log('✅ Generation complete!');
+}
+
+export { generateAllData, generateGravityFormsData, generateMauticData, generateSuiteCRMData, generateWordPressData };
+//# sourceMappingURL=generators.esm.js.map