@marvalt/wadapter 2.3.44 → 2.3.46

package/dist/generators.esm.js

@@ -287,11 +287,107 @@ class WordPressClient {
     }
     /**
      * Fetch a specific navigation menu with its items
-     * @param menuId Menu ID
+     * 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) {
-        return this.makeRequest(`/wp-custom/v1/menus/${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 (navPost.menu) {
+                        console.log(`  ✅ Returning menu from navigation post: ${navPost.menu.name}`);
+                        return navPost.menu;
+                    }
+                    // If navigation post has a menu_term_id, 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`);
+                        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 });
@@ -520,86 +616,194 @@ function addBlockFromStack(endOffset) {
 /**
  * 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;
-    // Parse HTML to extract menu items from <a> tags
-    // Look for links inside navigation items: <a class="wp-block-navigation-item__content" href="..."><span class="wp-block-navigation-item__label">...</span></a>
-    const linkRegex = /<a[^>]+class="[^"]*wp-block-navigation-item__content[^"]*"[^>]+href=["']([^"']+)["'][^>]*>[\s\S]*?<span[^>]*class="[^"]*wp-block-navigation-item__label[^"]*"[^>]*>([^<]+)<\/span>[\s\S]*?<\/a>/gi;
+    // 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 match;
-    let order = 0;
-    while ((match = linkRegex.exec(innerHTML)) !== null) {
-        const url = match[1].trim();
-        const title = match[2].trim();
-        if (title && url) {
-            // Handle URLs: preserve external URLs, convert internal absolute URLs to relative paths
-            let finalUrl = url;
-            try {
-                const urlObj = new URL(url);
-                // Check if it's an external URL (different origin from WordPress site)
-                // We'll consider it external if the origin doesn't match common internal patterns
-                // For now, preserve all absolute URLs that are clearly external (different domain)
-                // Internal URLs from the same WordPress site will be converted to relative paths
-                const isAbsoluteUrl = url.startsWith('http://') || url.startsWith('https://');
-                if (isAbsoluteUrl) {
-                    // Check if pathname is empty or just "/" - likely an external URL
-                    // Or if the domain is clearly different (simple heuristic: check if it contains common external domains)
-                    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) {
-                        // Preserve external URLs as-is
-                        finalUrl = url;
-                    }
-                    else {
-                        // Convert internal absolute URLs to relative paths
-                        finalUrl = pathname + urlObj.search + urlObj.hash;
-                        // Ensure relative URL starts with /
-                        if (!finalUrl.startsWith('/')) {
-                            finalUrl = `/${finalUrl}`;
-                        }
-                        // Remove trailing slash (except for root path) to match React Router routes
-                        if (finalUrl !== '/' && finalUrl.endsWith('/')) {
-                            finalUrl = finalUrl.slice(0, -1);
-                        }
-                    }
+    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 {
-                    // Already a relative URL, ensure it starts with /
+                    finalUrl = pathname + urlObj.search + urlObj.hash;
                     if (!finalUrl.startsWith('/')) {
                         finalUrl = `/${finalUrl}`;
                     }
-                    // Remove trailing slash (except for root path) to match React Router routes
                     if (finalUrl !== '/' && finalUrl.endsWith('/')) {
                         finalUrl = finalUrl.slice(0, -1);
                     }
                 }
             }
-            catch (e) {
-                // If URL parsing fails, assume it's already relative or keep as is
-                // Ensure relative URLs start with /
-                if (!finalUrl.startsWith('http://') && !finalUrl.startsWith('https://') && !finalUrl.startsWith('/')) {
+            else {
+                if (!finalUrl.startsWith('/')) {
                     finalUrl = `/${finalUrl}`;
                 }
-                // Remove trailing slash (except for root path) to match React Router routes
                 if (finalUrl !== '/' && finalUrl.endsWith('/')) {
                     finalUrl = finalUrl.slice(0, -1);
                 }
             }
-            items.push({
-                id: order + 1,
-                title: title,
-                url: finalUrl,
-                type: 'custom',
-                object_id: 0,
-                object: 'custom',
-                parent: 0,
-                menu_order: order++,
-            });
+        }
+        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) {
@@ -741,6 +945,7 @@ class WordPressGenerator {
         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();
@@ -834,6 +1039,33 @@ class WordPressGenerator {
                             }
                             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 {
@@ -905,6 +1137,149 @@ class WordPressGenerator {
             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 = {
@@ -983,6 +1358,7 @@ class WordPressGenerator {
             ...(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: {