/**
 * Agile-Ed Form Integration Module
 * 
 * Reusable module for integrating Agile-Ed API with HubSpot forms
 * Provides email autocomplete, school/district autocomplete, and form population
 * 
 * CRITICAL: API Failures Never Block Form Functionality
 * ======================================================
 * This module is designed with fail-safe principles:
 * - All API errors are caught and handled gracefully
 * - Form fields are NEVER disabled or made readonly due to API failures
 * - Form submission is NEVER blocked by API errors
 * - Users can ALWAYS manually fill in all form fields, even if all API calls fail
 * - API failures result in silent degradation - form works normally without autocomplete
 * 
 * Dependencies:
 *   - jQuery
 *   - agile-ed-api-proxy.js (AgileEdAPI class)
 *   - institution-lookup.js (InstitutionLookupWidget class)
 * 
 * Usage:
 *   // In your HTML file, include the scripts:
 *   <script src="/site/js/agile-ed-api-proxy.js"></script>
 *   <script src="/site/js/institution-lookup.js"></script>
 *   <script src="/site/js/agile-ed-form-integration.js"></script>
 * 
 *   // Then initialize:
 *   const integration = new AgileEdFormIntegration({
 *     proxyUrl: '/api/agile-ed-proxy.php',
 *     fieldMapping: {
 *       institution_name: 'company',
 *       state: 'us_states',
 *       country: 'country__new_',
 *       firstname: 'firstname',
 *       lastname: 'lastname',
 *       student_count: 'connectlink_district_student_count',
 *       building_students: 'connectlink_building_student_count',
 *       institution_id: 'account_connectlink_key',
 *       phone: 'phone',
 *       jobtitle: 'jobtitle',
 *       // purchase_level removed - district_or_building field no longer used
 *       building_type: 'connectlink_institution_type', // Maps "BLDG" -> "Building", "DIST" -> "District"
 *       file_type_text: 'connectlink_type_of_school', // Maps "Public" or "Private" (Type of School)
 *       institution_type: 'connectlink_type_of_school' // Alternative mapping for Type of School
 *     },
 *     portalId: '20180325',
 *     hubspotFormId: '0c5252b0-043f-406e-97a8-3290aff02866'
 *   });
 * 
 *   // In HubSpot form's onFormReady callback:
 *   hbspt.forms.create({
 *     // ... form config ...
 *     onFormReady: function($form, ctx) {
 *       integration.initForm($form, ctx);
 *     }
 *   });
 */

// Production mode - all logging disabled
// Debug logging is completely disabled for production
// All debugLog, debugWarn, and logError calls are no-ops
const DEBUG_MODE = false;

// Debug logging utilities - all disabled in production
const debugLog = function() {}; // No-op - all logging disabled
const debugWarn = function() {}; // No-op - all logging disabled
const logError = function() {}; // No-op - all logging disabled

// Debug instrumentation - disabled in production
// All debugInstrument calls are no-ops in production
const debugInstrument = function(location, message, data, hypothesisId) {
    // Production: All debug logging disabled
    // No-op function - does nothing
};

// Global error handler to prevent HubSpot DOM errors from breaking the form
// This catches insertBefore/removeChild errors from HubSpot's v2.js
if (typeof window !== 'undefined') {
    const originalErrorHandler = window.onerror;
    window.onerror = function(message, source, lineno, colno, error) {
        // Check error message string
        const errorMessage = message ? String(message) : '';
        // Check error object properties
        const errorObjMessage = error && error.message ? String(error.message) : '';
        const errorObjName = error && error.name ? String(error.name) : '';
        const errorObjString = error && error.toString ? String(error.toString()) : '';
        const errorStack = error && error.stack ? String(error.stack) : '';
        
        // Combine all error information
        const fullErrorText = errorMessage + ' ' + errorObjMessage + ' ' + errorObjName + ' ' + errorObjString + ' ' + errorStack;
        
        // Check if error is from HubSpot's v2.js
        const isFromHubSpot = source && (source.includes('v2.js') || source.includes('hubspot'));
        
        // Suppress HubSpot's DOM manipulation errors that don't actually break functionality
        if (isFromHubSpot || 
            fullErrorText.includes('insertBefore') || 
            fullErrorText.includes('removeChild') || 
            fullErrorText.includes('appendChild') ||
            fullErrorText.includes('NotFoundError') ||
            fullErrorText.includes('Failed to execute') ||
            fullErrorText.includes('not a child of this node') ||
            fullErrorText.includes('The node before which') ||
            fullErrorText.includes('The node to be removed') ||
            (errorObjName === 'NotFoundError' && (fullErrorText.includes('Node') || fullErrorText.includes('DOM')))) {
            // These are typically timing issues with HubSpot's DOM manipulation
            // They don't actually break the form, so we suppress them
            debugWarn('Suppressed HubSpot DOM manipulation error:', fullErrorText.substring(0, 200));
            
            // CRITICAL: Ensure form is still visible after error
            // Sometimes HubSpot errors can cause form to be hidden
            try {
                if (typeof $ !== 'undefined' && $.fn) {
                    // Check all HubSpot forms and ensure they're visible
                    setTimeout(function() {
                        try {
                            $('.hs-form, .hs-form-container, form[id*="form"], #form1').each(function() {
                                const $form = $(this);
                                if ($form.length && !$form.is(':visible')) {
                                    debugLog('Form was hidden after error - making visible');
                                    $form.show();
                                }
                            });
                        } catch (e) {
                            // Ignore errors in form visibility check
                        }
                    }, 100);
                }
            } catch (e) {
                // Ignore errors in form visibility restoration
            }
            
            return true; // Prevent error from propagating
        }
        // For other errors, call original handler if it exists
        if (originalErrorHandler) {
            return originalErrorHandler.apply(this, arguments);
        }
        return false; // Let error propagate
    };
    
    // Also catch unhandled promise rejections
    window.addEventListener('unhandledrejection', function(event) {
        if (event.reason) {
            const reason = event.reason;
            const reasonMessage = reason.message ? String(reason.message) : '';
            const reasonName = reason.name ? String(reason.name) : '';
            const reasonString = reason.toString ? String(reason.toString()) : '';
            const reasonStack = reason.stack ? String(reason.stack) : '';
            const fullReasonText = reasonMessage + ' ' + reasonName + ' ' + reasonString + ' ' + reasonStack;
            
            if (fullReasonText.includes('insertBefore') || 
                fullReasonText.includes('removeChild') || 
                fullReasonText.includes('appendChild') ||
                fullReasonText.includes('NotFoundError') ||
                fullReasonText.includes('Failed to execute') ||
                fullReasonText.includes('not a child of this node') ||
                fullReasonText.includes('The node before which') ||
                fullReasonText.includes('The node to be removed') ||
                (reasonName === 'NotFoundError' && (fullReasonText.includes('Node') || fullReasonText.includes('DOM')))) {
                debugWarn('Suppressed HubSpot DOM manipulation promise rejection:', fullReasonText.substring(0, 200));
                event.preventDefault(); // Prevent error from propagating
                event.stopPropagation(); // Also stop propagation
            }
        }
    });
    
    // Also catch errors from addEventListener error events
    window.addEventListener('error', function(event) {
        if (event.error) {
            const error = event.error;
            const errorMessage = error.message ? String(error.message) : '';
            const errorName = error.name ? String(error.name) : '';
            const errorString = error.toString ? String(error.toString()) : '';
            const errorStack = error.stack ? String(error.stack) : '';
            const eventSource = event.filename || event.source || '';
            const fullErrorText = errorMessage + ' ' + errorName + ' ' + errorString + ' ' + errorStack;
            
            // Check if error is from HubSpot's v2.js
            const isFromHubSpot = eventSource.includes('v2.js') || eventSource.includes('hubspot');
            
            if (isFromHubSpot ||
                fullErrorText.includes('insertBefore') || 
                fullErrorText.includes('removeChild') || 
                fullErrorText.includes('appendChild') ||
                fullErrorText.includes('NotFoundError') ||
                fullErrorText.includes('Failed to execute') ||
                fullErrorText.includes('not a child of this node') ||
                fullErrorText.includes('The node before which') ||
                fullErrorText.includes('The node to be removed') ||
                (errorName === 'NotFoundError' && (fullErrorText.includes('Node') || fullErrorText.includes('DOM')))) {
                debugWarn('Suppressed HubSpot DOM manipulation error event:', fullErrorText.substring(0, 200));
                event.preventDefault(); // Prevent error from propagating
                event.stopPropagation(); // Also stop propagation
                return true; // Suppress the error
            }
        } else if (event.message) {
            // Handle errors without error object
            const errorMessage = String(event.message);
            const eventSource = event.filename || event.source || '';
            const isFromHubSpot = eventSource.includes('v2.js') || eventSource.includes('hubspot');
            
            if (isFromHubSpot ||
                errorMessage.includes('insertBefore') || 
                errorMessage.includes('removeChild') || 
                errorMessage.includes('appendChild') ||
                errorMessage.includes('NotFoundError') ||
                errorMessage.includes('Failed to execute')) {
                debugWarn('Suppressed HubSpot DOM manipulation error event (no error object):', errorMessage.substring(0, 200));
                event.preventDefault(); // Prevent error from propagating
                event.stopPropagation(); // Also stop propagation
                return true; // Suppress the error
            }
        }
    }, true); // Use capture phase to catch errors early
}

class AgileEdFormIntegration {
    constructor(config = {}) {
        // Validate required dependencies
        if (typeof AgileEdAPI === 'undefined') {
            throw new Error('AgileEdAPI class is required. Please include agile-ed-api-proxy.js');
        }
        if (typeof InstitutionLookupWidget === 'undefined') {
            throw new Error('InstitutionLookupWidget class is required. Please include institution-lookup.js');
        }
        if (typeof $ === 'undefined') {
            throw new Error('jQuery is required');
        }
        
        // Required configuration
        this.proxyUrl = config.proxyUrl || '/api/agile-ed-proxy.php';
        this.fieldMapping = config.fieldMapping || {};
        this.portalId = config.portalId;
        this.hubspotFormId = config.hubspotFormId;
        
        // Optional configuration
        this.emailSelectors = config.emailSelectors || [
            'input[type="email"]',
            'input[name*="email"]',
            'input[name*="Email"]',
            'input[id*="email"]',
            'input[id*="Email"]',
            'input[placeholder*="email"]',
            'input[placeholder*="Email"]',
            'input[aria-label*="email"]',
            'input[aria-label*="Email"]'
        ];
        
        this.companySelectors = config.companySelectors || [
            'input[name*="company"]',
            'input[name*="Company"]',
            'input[name*="school"]',
            'input[name*="School"]',
            'input[name*="district"]',
            'input[name*="District"]',
            'input[id*="company"]',
            'input[id*="Company"]'
        ];
        
        // Initialize API and Widget
        this.agileEdAPI = new AgileEdAPI({
            proxyUrl: this.proxyUrl
        });
        
        this.institutionWidget = new InstitutionLookupWidget({
            api: this.agileEdAPI,
            hubspotFormId: this.hubspotFormId,
            portalId: this.portalId,
            fieldMapping: this.fieldMapping
        });
        
        // State management
        this.activeTimeouts = [];
        this.emailSearchTimeout = null;
        this.lastApiCallTime = 0;
        this.MIN_API_CALL_INTERVAL = 1000;
        this.isSearching = false;
        this.lastSearchedEmail = null;
        this.searchTriggeredFromInput = false;
        this.currentRequestAbortController = null;
        
        // Cache
        this.emailSearchCache = new Map();
        this.CACHE_DURATION = 15 * 60 * 1000; // 15 minutes (increased for better performance)
        this.MAX_CACHE_SIZE = 100;
        
        // Global state
        if (!window.SecurlyForm) {
            window.SecurlyForm = {};
        }
        // Fix: Don't set global emailSearchSucceeded - it should be per-form instance
        // This will be set per form in initForm
    }
    
    /**
     * Initialize form with Agile-Ed integration
     * @param {jQuery} $form - jQuery form element
     * @param {Object} ctx - HubSpot form context (optional)
     */
    initForm($form, ctx) {
        // CRITICAL: Wrap all initialization in try-catch to ensure form works even if API fails
        // Never let API initialization errors prevent form from being usable
        try {
            this._initFormInternal($form, ctx);
        } catch (error) {
            // Log error but don't break form - allow manual data entry
            // Form should work normally even if integration fails completely
            if (typeof console !== 'undefined' && console.error) {
                console.error('Agile-Ed form integration initialization error (form will work manually):', error);
            }
            // Form remains fully functional for manual data entry
        }
    }
    
    _initFormInternal($form, ctx) {
        debugLog('AgileEdFormIntegration.initForm called', {
            formId: $form.attr('id'),
            hasAgileEdAPI: !!this.agileEdAPI,
            hasInstitutionWidget: !!this.institutionWidget
        });
        
        if (!this.agileEdAPI || !this.institutionWidget) {
            debugWarn('AgileEdFormIntegration.initForm: Missing dependencies', {
                agileEdAPI: !!this.agileEdAPI,
                institutionWidget: !!this.institutionWidget
            });
            // Don't return - allow form to work manually even without dependencies
            return;
        }
        
        // Fix: Create form-specific instance ID to isolate multiple forms
        const formInstanceId = 'form_' + Date.now() + '_' + Math.random().toString(36).substr(2, 9);
        
        // CRITICAL: Initialize global form instances storage
        if (typeof window !== 'undefined') {
            if (!window.agileEdFormInstances) {
                window.agileEdFormInstances = {};
            }
        }
        
        // CRITICAL: Store original form HTML and context for restoration
        const originalFormHTML = $form[0] ? $form[0].outerHTML : null;
        const originalFormContext = ctx;
        
        // CRITICAL: Extract HubSpot form configuration from context for re-creation
        let hubspotFormConfig = null;
        if (ctx) {
            try {
                hubspotFormConfig = {
                    formId: ctx.formId || (ctx.data && ctx.data.formId) || null,
                    portalId: ctx.portalId || (ctx.data && ctx.data.portalId) || null,
                    region: ctx.region || (ctx.data && ctx.data.region) || 'na1',
                    target: ctx.target || null
                };
                debugLog('Extracted HubSpot form config:', hubspotFormConfig);
            } catch (e) {
                debugWarn('Error extracting HubSpot form config:', e);
            }
        }
        
        // CRITICAL: Store form's exact position in DOM for immediate restoration
        let formParent = null;
        let formNextSibling = null;
        let formParentSelector = null;
        let formContainerSelector = null;
        try {
            if ($form && $form[0] && $form[0].parentNode) {
                formParent = $form[0].parentNode;
                formNextSibling = $form[0].nextSibling;
                
                // Store parent selector for recovery if reference is lost
                try {
                    if (formParent.id) {
                        formParentSelector = '#' + formParent.id;
                    } else if (formParent.className) {
                        const classes = formParent.className.split(' ').filter(c => c).slice(0, 2).join('.');
                        if (classes) {
                            formParentSelector = '.' + classes;
                        }
                    }
                    
                    // Also try to find a container (like iframe or form container)
                    let container = formParent;
                    for (let i = 0; i < 5 && container; i++) {
                        if (container.tagName === 'IFRAME' || container.id || (container.className && container.className.includes('hs-form'))) {
                            if (container.id) {
                                formContainerSelector = '#' + container.id;
                            } else if (container.className) {
                                const classes = container.className.split(' ').filter(c => c).slice(0, 2).join('.');
                                if (classes) {
                                    formContainerSelector = '.' + classes;
                                }
                            }
                            break;
                        }
                        container = container.parentNode;
                    }
                } catch (e) {
                    // Ignore selector generation errors
                }
            }
        } catch (e) {
            debugWarn('Error storing form position:', e);
        }
        
        const formData = {
            instanceId: formInstanceId,
            $form: $form,
            originalFormHTML: originalFormHTML,
            originalFormContext: originalFormContext,
            hubspotFormConfig: hubspotFormConfig, // Store HubSpot config for re-creation
            formParent: formParent,
            formNextSibling: formNextSibling,
            formParentSelector: formParentSelector, // Store selector for recovery
            formContainerSelector: formContainerSelector, // Store container selector for recovery
            formCloneWithStyles: null, // Will be cloned right before removal
            computedStylesMap: null, // Will store computed styles before removal
            autocompleteContainer: null,
            cssMonitorInterval: null, // Interval ID for CSS monitoring
            lastCssCheck: 0, // Timestamp of last CSS check
            cssPreservedStyles: null, // Store preserved CSS styles for restoration
            interactingWithAutocomplete: false,
            emailSearchSucceeded: false,
            emailInputActive: false, // Flag to prevent DOM manipulation during email input (shared between initEmailField and initCompanyField)
            hubspotManipulating: false, // Flag to track when HubSpot is manipulating DOM
            lastEmailInputTime: 0, // Track when email input last occurred
            isRestoring: false, // Flag to prevent restoration loops
            lastRestoreTime: 0, // Track when form was last restored
            restoreCount: 0 // Track number of restorations to prevent infinite loops
        };
        
        // CRITICAL: Store form instance globally
        if (typeof window !== 'undefined' && window.agileEdFormInstances) {
            window.agileEdFormInstances[formInstanceId] = formData;
        }
        
        // CRITICAL: Function to clone form with computed styles right before removal
        const cloneFormWithComputedStyles = function() {
            try {
                if ($form && $form[0] && $form[0].isConnected) {
                    // Clone the form element with all its children (deep clone)
                    const clonedForm = $form[0].cloneNode(true);
                    
                    // Store computed styles for all elements in the form
                    const stylesMap = new Map();
                    const allElements = $form[0].querySelectorAll('*');
                    const clonedElements = clonedForm.querySelectorAll('*');
                    
                    // Store computed styles for the form itself
                    const formComputedStyle = window.getComputedStyle($form[0]);
                    const formStyles = {};
                    for (let i = 0; i < formComputedStyle.length; i++) {
                        const prop = formComputedStyle[i];
                        formStyles[prop] = formComputedStyle.getPropertyValue(prop);
                    }
                    stylesMap.set(clonedForm, formStyles);
                    
                    // Store computed styles for all child elements
                    allElements.forEach(function(originalEl, index) {
                        const clonedEl = clonedElements[index];
                        if (originalEl && clonedEl) {
                            const computedStyle = window.getComputedStyle(originalEl);
                            const styles = {};
                            for (let i = 0; i < computedStyle.length; i++) {
                                const prop = computedStyle[i];
                                styles[prop] = computedStyle.getPropertyValue(prop);
                            }
                            stylesMap.set(clonedEl, styles);
                        }
                    });
                    
                    formData.formCloneWithStyles = clonedForm;
                    formData.computedStylesMap = stylesMap;
                    debugLog('Form cloned with computed styles for restoration');
                }
            } catch (e) {
                debugWarn('Error cloning form with computed styles:', e);
            }
        };
        
        // Store the clone function for use in MutationObserver
        formData.cloneFormWithComputedStyles = cloneFormWithComputedStyles;
        
        // CRITICAL: Set up periodic CSS monitoring to detect and fix CSS loss
        const setupCssMonitor = function() {
            // Function to re-apply CSS styles if they've been lost
            const reapplyCssStyles = function() {
                try {
                    if (!$form || !$form[0] || !$form[0].isConnected) {
                        return; // Form not available
                    }
                    
                    // Check if form has lost critical styles
                    const formElement = $form[0];
                    const computedStyle = window.getComputedStyle(formElement);
                    const currentDisplay = computedStyle.display;
                    const currentVisibility = computedStyle.visibility;
                    const currentOpacity = computedStyle.opacity;
                    
                    // If form is hidden or has lost visibility, restore it
                    if (currentDisplay === 'none' || currentVisibility === 'hidden' || parseFloat(currentOpacity) === 0) {
                        // Form has lost visibility - restore it
                        if (formData.cssPreservedStyles) {
                            // Restore from preserved styles
                            formElement.setAttribute('style', formData.cssPreservedStyles.formStyle || '');
                        } else {
                            // Apply default visible styles
                            formElement.style.display = 'block';
                            formElement.style.visibility = 'visible';
                            formElement.style.opacity = '1';
                        }
                    }
                    
                    // Check and restore input field styles
                    const formInputs = $form.find('input, select, textarea, label');
                    formInputs.each(function() {
                        const el = this;
                        if (el.isConnected) {
                            const elComputed = window.getComputedStyle(el);
                            const elDisplay = elComputed.display;
                            const elVisibility = elComputed.visibility;
                            
                            // If element is hidden, restore it
                            if (elDisplay === 'none' || elVisibility === 'hidden') {
                                if (formData.cssPreservedStyles && formData.cssPreservedStyles.elements && formData.cssPreservedStyles.elements[el]) {
                                    el.setAttribute('style', formData.cssPreservedStyles.elements[el]);
                                } else {
                                    el.style.display = '';
                                    el.style.visibility = '';
                                }
                            }
                        }
                    });
                } catch (e) {
                    // Silently handle errors - don't break form
                }
            };
            
            // Store preserved CSS styles on first run
            const preserveCssStyles = function() {
                try {
                    if (!$form || !$form[0] || !$form[0].isConnected) {
                        return;
                    }
                    
                    if (!formData.cssPreservedStyles) {
                        formData.cssPreservedStyles = {
                            formStyle: $form[0].getAttribute('style') || '',
                            elements: {},
                            originalHiddenState: {} // Store which fields were originally hidden
                        };
                    }
                    
                    // Preserve styles for all form elements AND their original hidden state
                    const formInputs = $form.find('input, select, textarea, label, .hs-form-field, .hs-input');
                    const targetWindow = formData.iframeWindow || window;
                    formInputs.each(function() {
                        const el = this;
                        formData.cssPreservedStyles.elements[el] = el.getAttribute('style') || '';
                        
                        // CRITICAL: Store original hidden state to prevent restoring intentionally hidden fields
                        const originalComputed = targetWindow.getComputedStyle(el);
                        const originalDisplay = originalComputed.display;
                        const originalVisibility = originalComputed.visibility;
                        const originalOpacity = parseFloat(originalComputed.opacity);
                        const originalRect = el.getBoundingClientRect();
                        const originalStyle = el.getAttribute('style') || '';
                        
                        // Mark as originally hidden if:
                        // 1. Has hidden attribute or aria-hidden
                        // 2. Has hidden classes
                        // 3. Computed style shows hidden
                        // 4. Inline style explicitly sets display:none
                        const wasOriginallyHidden = el.hasAttribute('hidden') ||
                                                    el.getAttribute('aria-hidden') === 'true' ||
                                                    el.classList.contains('hs-hidden') ||
                                                    el.classList.contains('hidden') ||
                                                    el.classList.contains('sr-only') ||
                                                    el.classList.contains('visually-hidden') ||
                                                    originalDisplay === 'none' ||
                                                    originalVisibility === 'hidden' ||
                                                    originalOpacity === 0 ||
                                                    (originalRect.width === 0 && originalRect.height === 0) ||
                                                    originalStyle.includes('display:none') ||
                                                    originalStyle.includes('display: none');
                        
                        formData.cssPreservedStyles.originalHiddenState[el] = wasOriginallyHidden;
                    });
                } catch (e) {
                    // Silently handle errors
                }
            };
            
            // Preserve styles initially
            preserveCssStyles();
            
            // Set up periodic monitoring (check every 2 seconds normally, every 500ms during email editing)
            if (formData.cssMonitorInterval) {
                clearInterval(formData.cssMonitorInterval);
            }
            
            const runCssCheck = function() {
                // Only check if form is still connected
                if ($form && $form[0] && $form[0].isConnected) {
                    reapplyCssStyles();
                    // Re-preserve styles periodically to capture any updates
                    preserveCssStyles();
                    
                    // If email input is active, check more frequently
                    if (formData && formData.emailInputActive) {
                        // During email editing, check every 500ms
                        if (formData.cssMonitorInterval) {
                            clearInterval(formData.cssMonitorInterval);
                        }
                        formData.cssMonitorInterval = setTimeout(runCssCheck, 500);
                    } else {
                        // Normal monitoring - check every 2 seconds
                        if (formData.cssMonitorInterval) {
                            clearInterval(formData.cssMonitorInterval);
                        }
                        formData.cssMonitorInterval = setTimeout(runCssCheck, 2000);
                    }
                } else {
                    // Form removed - clear interval
                    if (formData.cssMonitorInterval) {
                        clearInterval(formData.cssMonitorInterval);
                        formData.cssMonitorInterval = null;
                    }
                }
            };
            
            // Start monitoring
            formData.cssMonitorInterval = setTimeout(runCssCheck, 500); // Start with frequent check
            
            // Also monitor for style attribute changes via MutationObserver
            if ($form && $form[0]) {
                const styleObserver = new MutationObserver(function(mutations) {
                    mutations.forEach(function(mutation) {
                        if (mutation.type === 'attributes' && mutation.attributeName === 'style') {
                            // Style attribute changed - check if it was removed or if field became hidden
                            const target = mutation.target;
                            if (target === $form[0] || $form.find(target).length) {
                                const currentStyle = target.getAttribute('style');
                                if (!currentStyle || currentStyle.trim() === '') {
                                    // Style was removed - restore it
                                    if (formData.cssPreservedStyles) {
                                        if (target === $form[0] && formData.cssPreservedStyles.formStyle) {
                                            target.setAttribute('style', formData.cssPreservedStyles.formStyle);
                                        } else if (formData.cssPreservedStyles.elements && formData.cssPreservedStyles.elements[target]) {
                                            target.setAttribute('style', formData.cssPreservedStyles.elements[target]);
                                        }
                                    }
                                } else {
                                    // Style was changed - check if field became hidden
                                    // Only check form fields, not the form element itself
                                    const isFormField = target.tagName === 'INPUT' || target.tagName === 'TEXTAREA' || 
                                                       target.tagName === 'SELECT' || target.tagName === 'LABEL' ||
                                                       target.classList.contains('hs-form-field') || target.classList.contains('hs-input');
                                    if (isFormField && target.type !== 'hidden') {
                                        const targetWindow = formData.iframeWindow || window;
                                        const computedStyle = targetWindow.getComputedStyle(target);
                                        if (computedStyle.display === 'none' || computedStyle.visibility === 'hidden' || parseFloat(computedStyle.opacity) === 0) {
                                            // Field became hidden - restore it immediately
                                            let fieldStyle = target.getAttribute('style') || '';
                                            if (fieldStyle && !fieldStyle.endsWith(';')) {
                                                fieldStyle += ';';
                                            }
                                            if (computedStyle.display === 'none') {
                                                fieldStyle += 'display: block !important; ';
                                            }
                                            if (computedStyle.visibility === 'hidden') {
                                                fieldStyle += 'visibility: visible !important; ';
                                            }
                                            if (parseFloat(computedStyle.opacity) === 0) {
                                                fieldStyle += 'opacity: 1 !important; ';
                                            }
                                            if (fieldStyle) {
                                                target.setAttribute('style', fieldStyle);
                                                // #region agent log
                                                debugInstrument('agile-ed-form-integration.js:680', 'Form field hidden detected by MutationObserver - restored', {
                                                    fieldTag:target.tagName,
                                                    fieldType:target.type,
                                                    fieldClass:target.className
                                                }, 'CSS1');
                                                // #endregion
                                            }
                                        }
                                    }
                                }
                            }
                        }
                        
                        // Handle class changes - HubSpot might be adding classes that hide fields
                        if (mutation.type === 'attributes' && mutation.attributeName === 'class') {
                            const target = mutation.target;
                            if (target === $form[0] || $form.find(target).length) {
                                const isFormField = target.tagName === 'INPUT' || target.tagName === 'TEXTAREA' || 
                                                   target.tagName === 'SELECT' || target.tagName === 'LABEL' ||
                                                   target.classList.contains('hs-form-field') || target.classList.contains('hs-input');
                                if (isFormField && target.type !== 'hidden') {
                                    const targetWindow = formData.iframeWindow || window;
                                    const computedStyle = targetWindow.getComputedStyle(target);
                                    if (computedStyle.display === 'none' || computedStyle.visibility === 'hidden' || parseFloat(computedStyle.opacity) === 0) {
                                        // Field became hidden via class change - restore it immediately
                                        let fieldStyle = target.getAttribute('style') || '';
                                        if (fieldStyle && !fieldStyle.endsWith(';')) {
                                            fieldStyle += ';';
                                        }
                                        if (computedStyle.display === 'none') {
                                            fieldStyle += 'display: block !important; ';
                                        }
                                        if (computedStyle.visibility === 'hidden') {
                                            fieldStyle += 'visibility: visible !important; ';
                                        }
                                        if (parseFloat(computedStyle.opacity) === 0) {
                                            fieldStyle += 'opacity: 1 !important; ';
                                        }
                                        if (fieldStyle) {
                                            target.style.setProperty('display', 'block', 'important');
                                            target.style.setProperty('visibility', 'visible', 'important');
                                            target.style.setProperty('opacity', '1', 'important');
                                            // #region agent log
                                            debugInstrument('agile-ed-form-integration.js:720', 'Form field hidden via class change - restored', {
                                                fieldTag:target.tagName,
                                                fieldType:target.type,
                                                fieldClass:target.className
                                            }, 'CSS1');
                                            // #endregion
                                        }
                                    }
                                }
                            }
                        }
                        
                        // Handle childList changes - check if form fields were added/removed
                        if (mutation.type === 'childList') {
                            // Check all added nodes
                            mutation.addedNodes.forEach(function(node) {
                                if (node.nodeType === 1) { // Element node
                                    const isFormField = node.tagName === 'INPUT' || node.tagName === 'TEXTAREA' || 
                                                       node.tagName === 'SELECT' || node.tagName === 'LABEL' ||
                                                       node.classList.contains('hs-form-field') || node.classList.contains('hs-input');
                                    if (isFormField && node.type !== 'hidden' && node.isConnected) {
                                        const targetWindow = formData.iframeWindow || window;
                                        const computedStyle = targetWindow.getComputedStyle(node);
                                        if (computedStyle.display === 'none' || computedStyle.visibility === 'hidden' || parseFloat(computedStyle.opacity) === 0) {
                                            // Newly added field is hidden - restore it
                                            node.style.setProperty('display', 'block', 'important');
                                            node.style.setProperty('visibility', 'visible', 'important');
                                            node.style.setProperty('opacity', '1', 'important');
                                            // #region agent log
                                            debugInstrument('agile-ed-form-integration.js:740', 'Newly added form field was hidden - restored', {
                                                fieldTag:node.tagName,
                                                fieldType:node.type,
                                                fieldClass:node.className
                                            }, 'CSS1');
                                            // #endregion
                                        }
                                    }
                                }
                            });
                        }
                        
                        // Handle class changes - HubSpot might be adding classes that hide fields
                        if (mutation.type === 'attributes' && mutation.attributeName === 'class') {
                            const target = mutation.target;
                            if (target === $form[0] || $form.find(target).length) {
                                const isFormField = target.tagName === 'INPUT' || target.tagName === 'TEXTAREA' || 
                                                   target.tagName === 'SELECT' || target.tagName === 'LABEL' ||
                                                   target.classList.contains('hs-form-field') || target.classList.contains('hs-input');
                                if (isFormField && target.type !== 'hidden') {
                                    const targetWindow = formData.iframeWindow || window;
                                    const computedStyle = targetWindow.getComputedStyle(target);
                                    if (computedStyle.display === 'none' || computedStyle.visibility === 'hidden' || parseFloat(computedStyle.opacity) === 0) {
                                        // Field became hidden via class change - restore it immediately
                                        target.style.setProperty('display', 'block', 'important');
                                        target.style.setProperty('visibility', 'visible', 'important');
                                        target.style.setProperty('opacity', '1', 'important');
                                        // #region agent log
                                        debugInstrument('agile-ed-form-integration.js:720', 'Form field hidden via class change - restored', {
                                            fieldTag:target.tagName,
                                            fieldType:target.type,
                                            fieldClass:target.className
                                        }, 'CSS1');
                                        // #endregion
                                    }
                                }
                            }
                        }
                        
                        // Handle childList changes - check if form fields were added/removed
                        if (mutation.type === 'childList') {
                            // Check all added nodes
                            mutation.addedNodes.forEach(function(node) {
                                if (node.nodeType === 1) { // Element node
                                    const isFormField = node.tagName === 'INPUT' || node.tagName === 'TEXTAREA' || 
                                                       node.tagName === 'SELECT' || node.tagName === 'LABEL' ||
                                                       node.classList.contains('hs-form-field') || node.classList.contains('hs-input');
                                    if (isFormField && node.type !== 'hidden' && node.isConnected) {
                                        const targetWindow = formData.iframeWindow || window;
                                        const computedStyle = targetWindow.getComputedStyle(node);
                                        if (computedStyle.display === 'none' || computedStyle.visibility === 'hidden' || parseFloat(computedStyle.opacity) === 0) {
                                            // Newly added field is hidden - restore it
                                            node.style.setProperty('display', 'block', 'important');
                                            node.style.setProperty('visibility', 'visible', 'important');
                                            node.style.setProperty('opacity', '1', 'important');
                                            // #region agent log
                                            debugInstrument('agile-ed-form-integration.js:740', 'Newly added form field was hidden - restored', {
                                                fieldTag:node.tagName,
                                                fieldType:node.type,
                                                fieldClass:node.className
                                            }, 'CSS1');
                                            // #endregion
                                        }
                                    }
                                }
                            });
                        }
                    });
                });
                
                styleObserver.observe($form[0], {
                    attributes: true,
                    attributeFilter: ['style', 'class'], // Also watch for class changes
                    childList: true, // Watch for elements being added/removed
                    subtree: true
                });
                
                // Store observer for cleanup
                formData.styleObserver = styleObserver;
            }
        };
        
        // Initialize CSS monitoring
        setupCssMonitor();
        
        // CRITICAL: Inject minimal CSS protection to prevent form from losing visibility
        // Only inject essential protection rules, NOT duplicate all stylesheets
        // This prevents CSS duplication and maintains original form design
        const injectHubSpotFormCSS = function() {
            try {
                if (!$form || !$form[0] || !$form[0].isConnected) {
                    return;
                }
                
                const formElement = $form[0];
                let iframeWindow = null;
                let iframeDocument = null;
                let targetHead = null;
                let targetDocument = null;
                
                // Detect if form is in iframe
                if (formElement.ownerDocument !== document) {
                    // Form is in a different document (likely iframe)
                    iframeDocument = formElement.ownerDocument;
                    iframeWindow = iframeDocument.defaultView || iframeDocument.parentWindow;
                    targetHead = iframeDocument.head;
                    targetDocument = iframeDocument;
                } else {
                    // Check if form's parent is an iframe
                    let parent = formElement.parentElement;
                    while (parent && parent !== document.body) {
                        if (parent.tagName === 'IFRAME') {
                            try {
                                iframeWindow = parent.contentWindow;
                                iframeDocument = parent.contentDocument;
                                if (iframeDocument && iframeDocument.head) {
                                    targetHead = iframeDocument.head;
                                    targetDocument = iframeDocument;
                                }
                                break;
                            } catch (e) {
                                // Cross-origin iframe - can't access
                                break;
                            }
                        }
                        parent = parent.parentElement;
                    }
                    
                    // If not in iframe, use main document
                    if (!targetHead) {
                        targetHead = document.head;
                        targetDocument = document;
                    }
                }
                
                if (!targetHead || !targetDocument) {
                    return; // Can't access head
                }
                
                // CRITICAL: Only inject MINIMAL protection CSS
                // Do NOT duplicate all stylesheets - this causes duplicate styling and design issues
                // Only protect against visibility/display loss, not override all styles
                // Use :not() selectors to avoid affecting elements that are intentionally hidden
                const protectionCSS = `
                    /* Minimal CSS protection - only prevent visibility loss for visible elements */
                    /* CRITICAL: Protect form element itself - must come first to override any other rules */
                    form.hs-form,
                    .hs-form,
                    form[id*="hsForm"],
                    form[class*="hs-form"] { 
                        display: block !important; 
                        visibility: visible !important; 
                        opacity: 1 !important; 
                    }
                    /* Additional protection for form elements that might be hidden by other CSS */
                    .hs-form:not([style*="display: none"]):not([style*="display:none"]) { 
                        display: block !important; 
                        visibility: visible !important; 
                        opacity: 1 !important; 
                    }
                    /* CRITICAL: Protect all form fields - must be strong to override HubSpot's hiding CSS */
                    /* Use high specificity selectors to override HubSpot's CSS */
                    /* EXCLUDE checkbox inputs to preserve their flexbox layout */
                    form.hs-form input:not([type="hidden"]):not([type="checkbox"]):not([style*="display: none"]):not([style*="display:none"]),
                    form.hs-form select:not([style*="display: none"]):not([style*="display:none"]),
                    form.hs-form textarea:not([style*="display: none"]):not([style*="display:none"]),
                    .hs-form input:not([type="hidden"]):not([type="checkbox"]):not([style*="display: none"]):not([style*="display:none"]), 
                    .hs-form select:not([style*="display: none"]):not([style*="display:none"]), 
                    .hs-form textarea:not([style*="display: none"]):not([style*="display:none"]),
                    form[id*="hsForm"] input:not([type="hidden"]):not([type="checkbox"]):not([style*="display: none"]):not([style*="display:none"]),
                    form[id*="hsForm"] select:not([style*="display: none"]):not([style*="display:none"]),
                    form[id*="hsForm"] textarea:not([style*="display: none"]):not([style*="display:none"]) { 
                        display: block !important; 
                        visibility: visible !important; 
                        opacity: 1 !important; 
                    }
                    /* EXCLUDE checkbox labels to preserve flexbox layout */
                    .hs-form label:not(.hs-form-checkbox-display):not([style*="display: none"]):not([style*="display:none"]):not(:has(input[type="checkbox"])),
                    form.hs-form label:not(.hs-form-checkbox-display):not([style*="display: none"]):not([style*="display:none"]):not(:has(input[type="checkbox"])) { 
                        display: block !important; 
                        visibility: visible !important; 
                    }
                    /* CRITICAL: Protect form field containers - these wrap the inputs */
                    .hs-form-field:not([style*="display: none"]):not([style*="display:none"]):not(:has(input[type="hidden"])),
                    form.hs-form .hs-form-field:not([style*="display: none"]):not([style*="display:none"]):not(:has(input[type="hidden"])) { 
                        display: block !important; 
                        visibility: visible !important; 
                        opacity: 1 !important;
                    }
                    /* EXCLUDE checkbox inputs from .hs-input rule to preserve flexbox layout */
                    .hs-input:not([type="hidden"]):not([type="checkbox"]):not([style*="display: none"]):not([style*="display:none"]),
                    form.hs-form .hs-input:not([type="hidden"]):not([type="checkbox"]):not([style*="display: none"]):not([style*="display:none"]) { 
                        display: block !important; 
                        visibility: visible !important; 
                        opacity: 1 !important;
                    }
                    /* CRITICAL: Protect submit buttons and buttons in general */
                    .hs-form button:not([style*="display: none"]):not([style*="display:none"]),
                    .hs-form input[type="submit"]:not([style*="display: none"]):not([style*="display:none"]),
                    .hs-button:not([style*="display: none"]):not([style*="display:none"]),
                    form.hs-form button:not([style*="display: none"]):not([style*="display:none"]),
                    form.hs-form input[type="submit"]:not([style*="display: none"]):not([style*="display:none"]) {
                        display: block !important;
                        visibility: visible !important;
                        opacity: 1 !important;
                    }
                    /* CRITICAL: Ensure hidden fields and hidden form fields stay hidden */
                    input[type="hidden"], 
                    .hs-form input[type="hidden"],
                    .hs-form-field:has(input[type="hidden"]),
                    .hs-form-field[style*="display: none"],
                    .hs-form-field[style*="display:none"] { 
                        display: none !important; 
                        visibility: hidden !important; 
                        opacity: 0 !important; 
                        height: 0 !important;
                        width: 0 !important;
                        padding: 0 !important;
                        margin: 0 !important;
                        border: none !important;
                        overflow: hidden !important;
                    }
                `;
                
                // Store references
                formData.iframeDocument = iframeDocument;
                formData.iframeWindow = iframeWindow;
                formData.targetHead = targetHead;
                formData.targetDocument = targetDocument;
                formData.hubspotFormCSS = protectionCSS;
                
                // Function to update CSS in target
                const updateCSSInTarget = function() {
                    try {
                        if (!targetHead || !targetDocument) {
                            // #region agent log
                            debugInstrument('agile-ed-form-integration.js:734', 'updateCSSInTarget - no target head/document', {hasTargetHead:!!targetHead,hasTargetDocument:!!targetDocument,isIframe:!!iframeDocument}, 'CSS1');
                            // #endregion
                            return;
                        }
                        
                        // Check current state of CSS tag
                        let cssStyleTag = targetDocument.getElementById('agile-ed-hubspot-form-css');
                        const cssTagExists = !!cssStyleTag;
                        const cssTagInHead = cssStyleTag && targetHead.contains(cssStyleTag);
                        
                        // #region agent log
                        debugInstrument('agile-ed-form-integration.js:739', 'updateCSSInTarget - checking CSS tag', {cssTagExists,cssTagInHead,isIframe:!!iframeDocument,headChildCount:targetHead.children.length}, 'CSS1');
                        // #endregion
                        
                        // Create or update style tag
                        if (!cssStyleTag) {
                            cssStyleTag = targetDocument.createElement('style');
                            cssStyleTag.id = 'agile-ed-hubspot-form-css';
                            cssStyleTag.type = 'text/css';
                            targetHead.appendChild(cssStyleTag);
                            // #region agent log
                            debugInstrument('agile-ed-form-integration.js:744', 'updateCSSInTarget - created new CSS tag', {isIframe:!!iframeDocument}, 'CSS1');
                            // #endregion
                        }
                        
                        // Check form computed styles before injection
                        const formComputedBefore = formElement ? (iframeWindow || window).getComputedStyle(formElement) : null;
                        const formDisplayBefore = formComputedBefore ? formComputedBefore.display : 'unknown';
                        const formVisibilityBefore = formComputedBefore ? formComputedBefore.visibility : 'unknown';
                        
                        // Only inject minimal protection CSS
                        cssStyleTag.textContent = protectionCSS;
                        
                        // CRITICAL: Set up MutationObserver to watch for CSS tag removal
                        // This ensures CSS is immediately re-injected if HubSpot removes it
                        if (!formData.cssTagObserver && targetHead) {
                            formData.cssTagObserver = new MutationObserver(function(mutations) {
                                mutations.forEach(function(mutation) {
                                    if (mutation.type === 'childList') {
                                        // Check if CSS tag was removed
                                        mutation.removedNodes.forEach(function(node) {
                                            if (node.nodeType === 1 && (node.id === 'agile-ed-hubspot-form-css' || node === cssStyleTag)) {
                                                // CSS tag was removed - re-inject immediately
                                                // #region agent log
                                                debugInstrument('agile-ed-form-integration.js:1000', 'CSS tag removed - re-injecting immediately', {
                                                    tagId:node.id,
                                                    tagInHead:targetHead.contains(node)
                                                }, 'CSS11');
                                                // #endregion
                                                
                                                // Re-inject CSS immediately
                                                if (formData && formData.injectHubSpotFormCSS && typeof formData.injectHubSpotFormCSS === 'function') {
                                                    try {
                                                        formData.injectHubSpotFormCSS();
                                                    } catch (e) {
                                                        // #region agent log
                                                        debugInstrument('agile-ed-form-integration.js:1010', 'Error re-injecting CSS after removal', {errorMessage:e?.message}, 'CSS11');
                                                        // #endregion
                                                    }
                                                }
                                            }
                                        });
                                        
                                        // Also check if stylesheets were removed
                                        mutation.removedNodes.forEach(function(node) {
                                            if (node.nodeType === 1 && (node.tagName === 'LINK' || node.tagName === 'STYLE')) {
                                                // A stylesheet was removed - re-inject CSS to ensure protection is still active
                                                if (formData && formData.injectHubSpotFormCSS && typeof formData.injectHubSpotFormCSS === 'function') {
                                                    setTimeout(function() {
                                                        if (formData && formData.injectHubSpotFormCSS) {
                                                            formData.injectHubSpotFormCSS();
                                                            // #region agent log
                                                            debugInstrument('agile-ed-form-integration.js:1025', 'CSS re-injected after stylesheet removal', {
                                                                removedTag:node.tagName,
                                                                removedId:node.id,
                                                                removedHref:node.href
                                                            }, 'CSS11');
                                                            // #endregion
                                                        }
                                                    }, 50);
                                                }
                                            }
                                        });
                                    }
                                });
                            });
                            
                            // Observe head for childList changes (when tags are added/removed)
                            formData.cssTagObserver.observe(targetHead, {
                                childList: true,
                                subtree: false
                            });
                            
                            // #region agent log
                            debugInstrument('agile-ed-form-integration.js:1040', 'CSS tag MutationObserver set up', {hasTargetHead:!!targetHead}, 'CSS11');
                            // #endregion
                        }
                        
                        // CRITICAL: After injecting CSS, immediately check and restore form field visibility
                        // Use requestAnimationFrame to ensure this runs after HubSpot's CSS is applied
                        const checkAndRestoreFormFields = function() {
                            let hiddenAfterInjection = 0;
                            if ($form && $form[0]) {
                                const formFields = $form.find('input:not([type="hidden"]), textarea, select, label, .hs-form-field, .hs-input');
                                formFields.each(function() {
                                    const field = this;
                                    if (field.isConnected) {
                                        // CRITICAL: Check if field was originally hidden - if so, skip restoration
                                        const wasOriginallyHidden = formData.cssPreservedStyles && 
                                                                   formData.cssPreservedStyles.originalHiddenState && 
                                                                   formData.cssPreservedStyles.originalHiddenState[field] === true;
                                        
                                        if (wasOriginallyHidden) {
                                            // Field was originally hidden - keep it hidden, don't restore
                                            return;
                                        }
                                        
                                        // CRITICAL: Skip hidden input fields - they should stay hidden
                                        if (field.tagName === 'INPUT' && field.type === 'hidden') {
                                            return; // Skip this field
                                        }
                                        
                                        // CRITICAL: Check if field's original inline style had display:none
                                        // This indicates it was intentionally hidden by design
                                        const originalStyle = formData.cssPreservedStyles && 
                                                             formData.cssPreservedStyles.elements && 
                                                             formData.cssPreservedStyles.elements[field];
                                        if (originalStyle && (originalStyle.includes('display:none') || originalStyle.includes('display: none'))) {
                                            // Original style had display:none - keep it hidden
                                            return;
                                        }
                                        
                                        const fieldComputed = (iframeWindow || window).getComputedStyle(field);
                                        if (fieldComputed.display === 'none' || fieldComputed.visibility === 'hidden' || parseFloat(fieldComputed.opacity) === 0) {
                                            // Field is hidden - force it visible with inline styles
                                            const beforeDisplay = fieldComputed.display;
                                            const beforeVisibility = fieldComputed.visibility;
                                            const beforeOpacity = fieldComputed.opacity;
                                            
                                            let fieldStyle = field.getAttribute('style') || '';
                                            if (fieldStyle && !fieldStyle.endsWith(';')) {
                                                fieldStyle += ';';
                                            }
                                            if (fieldComputed.display === 'none') {
                                                fieldStyle += 'display: block !important; ';
                                            }
                                            if (fieldComputed.visibility === 'hidden') {
                                                fieldStyle += 'visibility: visible !important; ';
                                            }
                                            if (parseFloat(fieldComputed.opacity) === 0) {
                                                fieldStyle += 'opacity: 1 !important; ';
                                            }
                                            if (fieldStyle) {
                                                field.setAttribute('style', fieldStyle);
                                                // Force a reflow
                                                field.offsetHeight;
                                                
                                                // Verify the style was applied
                                                const afterComputed = (iframeWindow || window).getComputedStyle(field);
                                                if (afterComputed.display === 'none' || afterComputed.visibility === 'hidden' || parseFloat(afterComputed.opacity) === 0) {
                                                    // setAttribute didn't work - use style property directly
                                                    if (afterComputed.display === 'none') {
                                                        field.style.setProperty('display', 'block', 'important');
                                                    }
                                                    if (afterComputed.visibility === 'hidden') {
                                                        field.style.setProperty('visibility', 'visible', 'important');
                                                    }
                                                    if (parseFloat(afterComputed.opacity) === 0) {
                                                        field.style.setProperty('opacity', '1', 'important');
                                                    }
                                                    // Force another reflow
                                                    field.offsetHeight;
                                                }
                                            }
                                            hiddenAfterInjection++;
                                        }
                                    }
                                });
                                
                                if (hiddenAfterInjection > 0) {
                                    // #region agent log
                                    debugInstrument('agile-ed-form-integration.js:880', 'Form fields hidden after CSS injection - restored', {
                                        hiddenAfterInjection,
                                        totalFields:formFields.length
                                    }, 'CSS1');
                                    // #endregion
                                }
                            }
                            return hiddenAfterInjection;
                        };
                        
                        // Check immediately
                        let hiddenAfterInjection = checkAndRestoreFormFields();
                        
                        // Also check after multiple delays to catch any delayed CSS application by HubSpot
                        // HubSpot may hide fields after our initial restoration
                        setTimeout(function() {
                            const hidden = checkAndRestoreFormFields();
                            if (hidden > 0) {
                                // #region agent log
                                debugInstrument('agile-ed-form-integration.js:890', 'Form fields hidden after 50ms delay - restored', {
                                    hiddenAfterDelay:hidden
                                }, 'CSS1');
                                // #endregion
                            }
                        }, 50);
                        
                        // Check again after 150ms to catch any further HubSpot manipulation
                        setTimeout(function() {
                            const hidden = checkAndRestoreFormFields();
                            if (hidden > 0) {
                                // #region agent log
                                debugInstrument('agile-ed-form-integration.js:900', 'Form fields hidden after 150ms delay - restored', {
                                    hiddenAfterDelay:hidden
                                }, 'CSS1');
                                // #endregion
                            }
                        }, 150);
                        
                        // Check again after 300ms to catch any final HubSpot manipulation
                        setTimeout(function() {
                            const hidden = checkAndRestoreFormFields();
                            if (hidden > 0) {
                                // #region agent log
                                debugInstrument('agile-ed-form-integration.js:910', 'Form fields hidden after 300ms delay - restored', {
                                    hiddenAfterDelay:hidden
                                }, 'CSS1');
                                // #endregion
                            }
                        }, 300);
                        
                        // Check form computed styles after injection
                        const formComputedAfter = formElement ? (iframeWindow || window).getComputedStyle(formElement) : null;
                        const formDisplayAfter = formComputedAfter ? formComputedAfter.display : 'unknown';
                        const formVisibilityAfter = formComputedAfter ? formComputedAfter.visibility : 'unknown';
                        
                        // #region agent log
                        debugInstrument('agile-ed-form-integration.js:748', 'updateCSSInTarget - CSS injected', {
                            isIframe:!!iframeDocument,
                            formDisplayBefore,
                            formVisibilityBefore,
                            formDisplayAfter,
                            formVisibilityAfter,
                            cssTagExists:!!cssStyleTag,
                            cssTagInHead:targetHead.contains(cssStyleTag),
                            hiddenFieldsAfterInjection:hiddenAfterInjection
                        }, 'CSS1');
                        // #endregion
                        
                        debugLog('Minimal HubSpot form CSS protection injected into ' + (iframeDocument ? 'iframe' : 'document') + ' head');
                        
                        // Monitor for removal
                        if (!formData.hubspotCssObserver) {
                            const cssObserver = new MutationObserver((mutations) => {
                                mutations.forEach((mutation) => {
                                    if (mutation.type === 'childList') {
                                        mutation.removedNodes.forEach((node) => {
                                            if (node === cssStyleTag || (node.id === 'agile-ed-hubspot-form-css')) {
                                                // #region agent log
                                                debugInstrument('agile-ed-form-integration.js:758', 'CSS tag removed - re-injecting', {nodeId:node?.id,isIframe:!!iframeDocument,emailInputActive:formData?.emailInputActive}, 'CSS2');
                                                // #endregion
                                                // CSS tag removed - re-inject immediately
                                                setTimeout(() => {
                                                    updateCSSInTarget();
                                                }, 50);
                                            }
                                        });
                                    }
                                });
                            });
                            
                            cssObserver.observe(targetHead, {
                                childList: true,
                                subtree: false
                            });
                            
                            formData.hubspotCssObserver = cssObserver;
                            // #region agent log
                            debugInstrument('agile-ed-form-integration.js:774', 'CSS observer set up', {isIframe:!!iframeDocument}, 'CSS1');
                            // #endregion
                        }
                    } catch (e) {
                        // #region agent log
                        debugInstrument('agile-ed-form-integration.js:777', 'updateCSSInTarget - error', {errorMessage:e?.message,isIframe:!!iframeDocument}, 'CSS1');
                        // #endregion
                        debugWarn('Error updating CSS in target:', e);
                    }
                };
                
                // Initial injection
                updateCSSInTarget();
                
            } catch (e) {
                debugWarn('Error injecting HubSpot form CSS:', e);
            }
        };
        
        // Inject CSS on form initialization
        injectHubSpotFormCSS();
        
        // Store function for re-injection during email editing
        formData.injectHubSpotFormCSS = injectHubSpotFormCSS;
        
        // CRITICAL: Capture HubSpot stylesheets on initialization
        const captureHubSpotStylesheets = function() {
            try {
                const targetDoc = formData.targetDocument || document;
                const targetHead = formData.targetHead || document.head;
                
                if (!targetHead || !targetDoc) {
                    return;
                }
                
                // Capture all stylesheets
                const stylesheets = [];
                const styleTags = targetHead.querySelectorAll('style, link[rel="stylesheet"]');
                styleTags.forEach(function(tag, index) {
                    if (tag.id !== 'agile-ed-hubspot-form-css') { // Don't capture our own CSS
                        // Generate a unique identifier for stylesheets without IDs/hrefs
                        let uniqueId = tag.id || tag.href || null;
                        if (!uniqueId && tag.tagName === 'STYLE') {
                            // For style tags without ID, use textContent hash or position
                            const textContent = tag.textContent || '';
                            if (textContent.trim()) {
                                // Generate a simple hash from textContent (first 50 chars + length)
                                uniqueId = 'style-' + textContent.substring(0, 50).replace(/[^a-zA-Z0-9]/g, '') + '-' + textContent.length;
                            } else {
                                // Empty style tag - use position as identifier
                                uniqueId = 'style-empty-' + index;
                            }
                        }
                        
                        stylesheets.push({
                            tag: tag.tagName,
                            id: tag.id || null,
                            href: tag.href || null,
                            textContent: tag.textContent || '',
                            uniqueId: uniqueId, // Always have a unique identifier
                            index: index // Store position for matching
                        });
                    }
                });
                
                formData.capturedStylesheets = stylesheets;
                
                // #region agent log
                debugInstrument('agile-ed-form-integration.js:800', 'Captured HubSpot stylesheets', {stylesheetsCount:stylesheets.length,isIframe:!!formData.iframeDocument}, 'CSS6');
                // #endregion
            } catch (e) {
                // #region agent log
                debugInstrument('agile-ed-form-integration.js:805', 'Error capturing stylesheets', {errorMessage:e?.message}, 'CSS6');
                // #endregion
            }
        };
        
        // Capture stylesheets on initialization
        captureHubSpotStylesheets();
        formData.captureHubSpotStylesheets = captureHubSpotStylesheets;
        
        // CRITICAL: Set up continuous CSS monitoring during email editing
        // This proactively prevents CSS loss instead of reactively fixing it
        let cssMonitorInterval = null;
        const startCssMonitoring = function() {
            // #region agent log
            debugInstrument('agile-ed-form-integration.js:820', 'startCssMonitoring called', {alreadyMonitoring:!!cssMonitorInterval,emailInputActive:formData?.emailInputActive}, 'CSS7');
            // #endregion
            
            if (cssMonitorInterval) {
                return; // Already monitoring
            }
            
            // #region agent log
            debugInstrument('agile-ed-form-integration.js:826', 'Starting CSS monitoring interval', {emailInputActive:formData?.emailInputActive}, 'CSS7');
            // #endregion
            
            // Monitor every 50ms during email editing (faster to catch HubSpot hiding fields)
            cssMonitorInterval = setInterval(function() {
                try {
                    // #region agent log
                    debugInstrument('agile-ed-form-integration.js:890', 'CSS monitoring interval tick', {hasFormData:!!formData,emailInputActive:formData?.emailInputActive,hasForm:!!$form,formConnected:$form?.[0]?.isConnected}, 'CSS5');
                    // #endregion
                    
                    if (!formData || !formData.emailInputActive) {
                        // Email editing stopped - stop monitoring
                        if (cssMonitorInterval) {
                            clearInterval(cssMonitorInterval);
                            cssMonitorInterval = null;
                        }
                        return;
                    }
                    
                    if (!$form || !$form[0]) {
                        return;
                    }
                    
                    const formElement = $form[0];
                    
                    // Track form connection state to detect reconnection
                    const wasConnected = formData.formWasConnected !== false; // Default to true on first check
                    const isConnected = formElement.isConnected;
                    
                    // #region agent log
                    debugInstrument('agile-ed-form-integration.js:908', 'CSS monitoring - checking form connection', {wasConnected,isConnected,hasFormParent:!!formData.formParent}, 'CSS5');
                    // #endregion
                    
                    // CRITICAL: If form was disconnected and is now reconnected, restore CSS immediately
                    if (!wasConnected && isConnected) {
                        // #region agent log
                        debugInstrument('agile-ed-form-integration.js:914', 'Form reconnected - restoring CSS immediately', {}, 'CSS5');
                        // #endregion
                        // Form was reconnected - restore CSS immediately
                        if (formData.injectHubSpotFormCSS && typeof formData.injectHubSpotFormCSS === 'function') {
                            formData.injectHubSpotFormCSS();
                        }
                        // Restore form styles
                        if (formData.cssPreservedStyles && formData.cssPreservedStyles.formStyle) {
                            formElement.setAttribute('style', formData.cssPreservedStyles.formStyle);
                        } else if (formData.originalFormStyle) {
                            formElement.setAttribute('style', formData.originalFormStyle);
                        }
                        // Also restore all form input styles
                        const formInputs = $form.find('input:not([type="hidden"]), textarea, select, label, .hs-form-field, .hs-input');
                        formInputs.each(function() {
                            const el = this;
                            if (el.isConnected && formData.cssPreservedStyles && formData.cssPreservedStyles.elements && formData.cssPreservedStyles.elements[el]) {
                                el.setAttribute('style', formData.cssPreservedStyles.elements[el]);
                            }
                        });
                    }
                    
                    // Update connection state
                    formData.formWasConnected = isConnected;
                    
                    // CRITICAL: If form is disconnected, re-append it immediately
                    if (!formElement.isConnected) {
                        // #region agent log
                        debugInstrument('agile-ed-form-integration.js:947', 'Form disconnected during email editing - re-appending', {hasFormParent:!!formData.formParent,hasFormNextSibling:!!formData.formNextSibling,hasParentSelector:!!formData.formParentSelector}, 'CSS5');
                        // #endregion
                        
                        // Try to recover formParent if it's lost
                        let formParent = formData.formParent;
                        if (!formParent || !formParent.isConnected) {
                            // Try to find parent using selector
                            if (formData.formParentSelector) {
                                try {
                                    const targetDoc = formData.targetDocument || document;
                                    const foundParent = targetDoc.querySelector(formData.formParentSelector);
                                    if (foundParent && foundParent.isConnected) {
                                        formParent = foundParent;
                                        formData.formParent = formParent; // Update stored reference
                                        // #region agent log
                                        debugInstrument('agile-ed-form-integration.js:960', 'Recovered formParent using selector', {selector:formData.formParentSelector}, 'CSS5');
                                        // #endregion
                                    }
                                } catch (e) {
                                    // Ignore
                                }
                            }
                            
                            // If still not found, try container selector
                            if (!formParent && formData.formContainerSelector) {
                                try {
                                    const targetDoc = formData.targetDocument || document;
                                    const foundContainer = targetDoc.querySelector(formData.formContainerSelector);
                                    if (foundContainer && foundContainer.isConnected) {
                                        // Try to find form within container
                                        const foundForm = foundContainer.querySelector('form');
                                        if (foundForm && foundForm.parentNode) {
                                            formParent = foundForm.parentNode;
                                            formData.formParent = formParent;
                                            // #region agent log
                                            debugInstrument('agile-ed-form-integration.js:978', 'Recovered formParent using container selector', {selector:formData.formContainerSelector}, 'CSS5');
                                            // #endregion
                                        }
                                    }
                                } catch (e) {
                                    // Ignore
                                }
                            }
                            
                            // Last resort: try to find form's iframe and use its body
                            if (!formParent) {
                                try {
                                    const targetDoc = formData.targetDocument || document;
                                    const iframe = targetDoc.defaultView ? targetDoc.defaultView.frameElement : null;
                                    if (iframe && iframe.contentDocument && iframe.contentDocument.body) {
                                        formParent = iframe.contentDocument.body;
                                        formData.formParent = formParent;
                                        // #region agent log
                                        debugInstrument('agile-ed-form-integration.js:995', 'Recovered formParent using iframe body', {}, 'CSS5');
                                        // #endregion
                                    }
                                } catch (e) {
                                    // Ignore
                                }
                            }
                        }
                        
                        // Re-append form to DOM immediately
                        // CRITICAL: Check if form is already connected before re-appending to prevent duplicates
                        if (formParent && formParent.appendChild && !formElement.isConnected) {
                            try {
                                // Double-check: form might have been reconnected by HubSpot between check and re-append
                                if (formElement.isConnected) {
                                    // #region agent log
                                    debugInstrument('agile-ed-form-integration.js:1046', 'Form already reconnected by HubSpot - skipping re-append', {isConnected:formElement.isConnected}, 'CSS5');
                                    // #endregion
                                    return; // Form is already connected, don't re-append
                                }
                                
                                // Temporarily disconnect any observers to prevent loops
                                if (formData.formObserver) {
                                    try {
                                        formData.formObserver.disconnect();
                                    } catch (e) {
                                        // Ignore
                                    }
                                }
                                
                                // CRITICAL: Check if form is already a child of formParent to prevent duplicates
                                const isAlreadyChild = formParent.contains && formParent.contains(formElement);
                                if (isAlreadyChild) {
                                    // #region agent log
                                    debugInstrument('agile-ed-form-integration.js:1058', 'Form already a child of formParent - skipping re-append', {isConnected:formElement.isConnected}, 'CSS5');
                                    // #endregion
                                    // Re-connect observer and return
                                    if (formData.formObserver && formParent) {
                                        try {
                                            formData.formObserver.observe(formParent, {
                                                childList: true,
                                                subtree: true
                                            });
                                        } catch (e) {
                                            // Ignore
                                        }
                                    }
                                    return; // Form is already in the right place
                                }
                                
                                // CRITICAL: Check if HubSpot has already created a duplicate form in the parent
                                // If form has an ID, check for existing form with same ID
                                const doc = formData.targetDocument || document;
                                const formId = formElement.id;
                                let existingForm = null;
                                
                                // First, check if form is already in the document somewhere (even if not in formParent)
                                if (formId) {
                                    const existingFormById = doc.getElementById(formId);
                                    if (existingFormById && existingFormById !== formElement && existingFormById.isConnected) {
                                        existingForm = existingFormById;
                                    }
                                }
                                
                                // If not found by ID, check in formParent for forms with same class/structure
                                if (!existingForm) {
                                    const allFormsInParent = formParent.querySelectorAll('form');
                                    if (allFormsInParent.length > 0) {
                                        // Check if any form has the same structure/attributes
                                        for (let i = 0; i < allFormsInParent.length; i++) {
                                            const f = allFormsInParent[i];
                                            // If forms have same class or similar structure, it might be a duplicate
                                            if (f.className === formElement.className && f !== formElement) {
                                                existingForm = f;
                                                break;
                                            }
                                        }
                                    }
                                }
                                
                                // If duplicate form exists, remove it first
                                if (existingForm && existingForm !== formElement) {
                                    // #region agent log
                                    debugInstrument('agile-ed-form-integration.js:1087', 'Duplicate form detected - removing before re-append', {
                                        formId:formId,
                                        existingFormId:existingForm.id,
                                        existingFormConnected:existingForm.isConnected,
                                        existingFormParent:existingForm.parentNode ? existingForm.parentNode.nodeName : 'none'
                                    }, 'CSS5');
                                    // #endregion
                                    try {
                                        if (existingForm.parentNode) {
                                            existingForm.parentNode.removeChild(existingForm);
                                        }
                                    } catch (e) {
                                        // #region agent log
                                        debugInstrument('agile-ed-form-integration.js:1105', 'Error removing duplicate form', {errorMessage:e?.message}, 'CSS5');
                                        // #endregion
                                    }
                                }
                                
                                // Re-append form to exact same position
                                if (formData.formNextSibling && formData.formNextSibling.parentNode === formParent) {
                                    formParent.insertBefore(formElement, formData.formNextSibling);
                                } else {
                                    formParent.appendChild(formElement);
                                }
                                
                                // Re-connect observer
                                if (formData.formObserver && formParent) {
                                    try {
                                        formData.formObserver.observe(formParent, {
                                            childList: true,
                                            subtree: true
                                        });
                                    } catch (e) {
                                        // Ignore
                                    }
                                }
                                
                                // Update stored formParent reference
                                formData.formParent = formParent;
                                
                                // CRITICAL: Restore CSS immediately after re-appending
                                // Re-inject CSS FIRST (before restoring inline styles) to ensure stylesheets are available
                                if (formData.injectHubSpotFormCSS && typeof formData.injectHubSpotFormCSS === 'function') {
                                    formData.injectHubSpotFormCSS(); // Immediate, no delay
                                }
                                
                                // Restore form styles
                                if (formData.cssPreservedStyles && formData.cssPreservedStyles.formStyle) {
                                    formElement.setAttribute('style', formData.cssPreservedStyles.formStyle);
                                } else if (formData.originalFormStyle) {
                                    formElement.setAttribute('style', formData.originalFormStyle);
                                }
                                
                                // Ensure form visibility with !important
                                const targetDoc = formData.targetDocument || document;
                                
                                // #region agent log
                                // Check for duplicate forms/buttons after re-appending
                                const allForms = targetDoc.querySelectorAll('form');
                                const formButtons = formElement.querySelectorAll('button[type="submit"], input[type="submit"], .hs-button, [class*="button"]');
                                const allButtons = targetDoc.querySelectorAll('button[type="submit"], input[type="submit"], .hs-button, [class*="button"]');
                                debugInstrument('agile-ed-form-integration.js:1081', 'Form re-appended successfully', {
                                    isConnected:formElement.isConnected,
                                    totalFormsInDoc:allForms.length,
                                    buttonsInForm:formButtons.length,
                                    totalButtonsInDoc:allButtons.length
                                }, 'CSS5');
                                // #endregion
                                const targetWindow = formData.iframeWindow || window;
                                const computedStyle = targetWindow.getComputedStyle(formElement);
                                let formStyle = formElement.getAttribute('style') || '';
                                if (formStyle && !formStyle.endsWith(';')) {
                                    formStyle += ';';
                                }
                                if (computedStyle.display === 'none') {
                                    formStyle += 'display: block !important; ';
                                }
                                if (computedStyle.visibility === 'hidden') {
                                    formStyle += 'visibility: visible !important; ';
                                }
                                if (parseFloat(computedStyle.opacity) === 0) {
                                    formStyle += 'opacity: 1 !important; ';
                                }
                                if (formStyle) {
                                    formElement.setAttribute('style', formStyle);
                                }
                                
                                // CRITICAL: Restore all form input styles and ensure visibility
                                // Use multiple passes to ensure all fields are restored
                                const formInputs = $form.find('input:not([type="hidden"]):not([type="submit"]):not([type="button"]), textarea, select, label, .hs-form-field, .hs-input');
                                let hiddenFieldsCount = 0;
                                let visibleFieldsCount = 0;
                                
                                // First pass: Restore preserved styles and basic visibility
                                formInputs.each(function() {
                                    const el = this;
                                    if (el.isConnected) {
                                        // CRITICAL: Check if field was originally hidden - if so, skip restoration
                                        const wasOriginallyHidden = formData.cssPreservedStyles && 
                                                                   formData.cssPreservedStyles.originalHiddenState && 
                                                                   formData.cssPreservedStyles.originalHiddenState[el] === true;
                                        
                                        if (wasOriginallyHidden) {
                                            // Field was originally hidden - keep it hidden, don't restore
                                            return;
                                        }
                                        
                                        // Skip intentionally hidden fields (current state check)
                                        if (el.hasAttribute('hidden') || 
                                            el.getAttribute('aria-hidden') === 'true' ||
                                            el.classList.contains('hs-hidden') ||
                                            el.classList.contains('hidden') ||
                                            el.classList.contains('sr-only') ||
                                            el.classList.contains('visually-hidden')) {
                                            return;
                                        }
                                        
                                        // Skip .hs-form-field containers that only contain hidden inputs
                                        if (el.classList.contains('hs-form-field')) {
                                            const hiddenInputs = el.querySelectorAll('input[type="hidden"]');
                                            if (hiddenInputs.length > 0) {
                                                const visibleInputs = el.querySelectorAll('input:not([type="hidden"]):not([type="submit"]):not([type="button"]), textarea, select');
                                                if (visibleInputs.length === 0) {
                                                    return;
                                                }
                                            }
                                        }
                                        
                                        // Check if parent is hiding the field
                                        let parentElement = el.parentElement;
                                        while (parentElement && parentElement !== formElement) {
                                            if (parentElement.hasAttribute('hidden') || 
                                                parentElement.getAttribute('aria-hidden') === 'true' ||
                                                parentElement.classList.contains('hs-hidden') ||
                                                parentElement.classList.contains('hidden')) {
                                                return;
                                            }
                                            parentElement = parentElement.parentElement;
                                        }
                                        
                                        // CRITICAL: Check original inline style - if it had display:none, don't restore
                                        const originalStyle = formData.cssPreservedStyles && 
                                                             formData.cssPreservedStyles.elements && 
                                                             formData.cssPreservedStyles.elements[el];
                                        if (originalStyle && (originalStyle.includes('display:none') || originalStyle.includes('display: none'))) {
                                            // Original style had display:none - keep it hidden
                                            return;
                                        }
                                        
                                        // Restore preserved styles
                                        if (formData.cssPreservedStyles && formData.cssPreservedStyles.elements && formData.cssPreservedStyles.elements[el]) {
                                            el.setAttribute('style', formData.cssPreservedStyles.elements[el]);
                                        }
                                        
                                        // Ensure visibility - CRITICAL: Use style.setProperty with important flag
                                        const elComputed = targetWindow.getComputedStyle(el);
                                        
                                        // Check for all hiding methods
                                        const isHidden = elComputed.display === 'none' || 
                                                       elComputed.visibility === 'hidden' || 
                                                       parseFloat(elComputed.opacity) === 0;
                                        
                                        // Check for zero dimensions
                                        const hasZeroDimensions = (parseFloat(elComputed.height) === 0 && parseFloat(elComputed.width) === 0) ||
                                                                  parseFloat(elComputed.maxHeight) === 0 ||
                                                                  parseFloat(elComputed.maxWidth) === 0;
                                        
                                        // Check bounding box
                                        const rect = el.getBoundingClientRect();
                                        const isBoundingBoxHidden = rect.width === 0 && rect.height === 0;
                                        
                                        if (isHidden || hasZeroDimensions || isBoundingBoxHidden) {
                                            // Use style.setProperty with important flag for maximum priority
                                            if (elComputed.display === 'none') {
                                                el.style.setProperty('display', 'block', 'important');
                                            }
                                            if (elComputed.visibility === 'hidden') {
                                                el.style.setProperty('visibility', 'visible', 'important');
                                            }
                                            if (parseFloat(elComputed.opacity) === 0) {
                                                el.style.setProperty('opacity', '1', 'important');
                                            }
                                            
                                            // Restore dimensions if zero
                                            if (hasZeroDimensions || isBoundingBoxHidden) {
                                                if (parseFloat(elComputed.height) === 0) {
                                                    el.style.setProperty('height', 'auto', 'important');
                                                }
                                                if (parseFloat(elComputed.width) === 0) {
                                                    el.style.setProperty('width', 'auto', 'important');
                                                }
                                                if (parseFloat(elComputed.maxHeight) === 0) {
                                                    el.style.setProperty('max-height', 'none', 'important');
                                                }
                                                if (parseFloat(elComputed.maxWidth) === 0) {
                                                    el.style.setProperty('max-width', 'none', 'important');
                                                }
                                            }
                                            
                                            hiddenFieldsCount++;
                                        } else {
                                            visibleFieldsCount++;
                                        }
                                    }
                                });
                                
                                // Second pass: Verify and re-restore if needed (after a brief delay for DOM to settle)
                                setTimeout(function() {
                                    let secondPassHidden = 0;
                                    let secondPassVisible = 0;
                                    formInputs.each(function() {
                                        const el = this;
                                        if (el.isConnected) {
                                            // CRITICAL: Check if field was originally hidden - if so, skip restoration
                                            const wasOriginallyHidden = formData.cssPreservedStyles && 
                                                                       formData.cssPreservedStyles.originalHiddenState && 
                                                                       formData.cssPreservedStyles.originalHiddenState[el] === true;
                                            
                                            if (wasOriginallyHidden) {
                                                // Field was originally hidden - keep it hidden, don't restore
                                                return;
                                            }
                                            
                                            // Skip intentionally hidden fields (current state check)
                                            if (el.hasAttribute('hidden') || 
                                                el.getAttribute('aria-hidden') === 'true' ||
                                                el.classList.contains('hs-hidden') ||
                                                el.classList.contains('hidden') ||
                                                el.classList.contains('sr-only') ||
                                                el.classList.contains('visually-hidden')) {
                                                return;
                                            }
                                            
                                            // CRITICAL: Check original inline style - if it had display:none, don't restore
                                            const originalStyle = formData.cssPreservedStyles && 
                                                                 formData.cssPreservedStyles.elements && 
                                                                 formData.cssPreservedStyles.elements[el];
                                            if (originalStyle && (originalStyle.includes('display:none') || originalStyle.includes('display: none'))) {
                                                // Original style had display:none - keep it hidden
                                                return;
                                            }
                                            
                                            const elComputed = targetWindow.getComputedStyle(el);
                                            const isHidden = elComputed.display === 'none' || 
                                                           elComputed.visibility === 'hidden' || 
                                                           parseFloat(elComputed.opacity) === 0;
                                            const rect = el.getBoundingClientRect();
                                            const isBoundingBoxHidden = rect.width === 0 && rect.height === 0;
                                            
                                            if (isHidden || isBoundingBoxHidden) {
                                                // Force restore again
                                                if (elComputed.display === 'none') {
                                                    el.style.setProperty('display', 'block', 'important');
                                                }
                                                if (elComputed.visibility === 'hidden') {
                                                    el.style.setProperty('visibility', 'visible', 'important');
                                                }
                                                if (parseFloat(elComputed.opacity) === 0) {
                                                    el.style.setProperty('opacity', '1', 'important');
                                                }
                                                if (isBoundingBoxHidden) {
                                                    el.style.setProperty('height', 'auto', 'important');
                                                    el.style.setProperty('width', 'auto', 'important');
                                                }
                                                secondPassHidden++;
                                            } else {
                                                secondPassVisible++;
                                            }
                                        }
                                    });
                                    
                                    // #region agent log
                                    if (secondPassHidden > 0) {
                                        debugInstrument('agile-ed-form-integration.js:1700', 'Second pass restoration after re-append', {
                                            secondPassHidden,
                                            secondPassVisible
                                        }, 'CSS5');
                                    }
                                    // #endregion
                                }, 50);
                                
                                // #region agent log
                                debugInstrument('agile-ed-form-integration.js:1250', 'Form fields visibility restored', {
                                    totalFields:formInputs.length,
                                    hiddenFieldsCount,
                                    visibleFieldsCount
                                }, 'CSS5');
                                // #endregion
                                
                                // Check CSS state after restoration
                                const finalComputedStyle = targetWindow.getComputedStyle(formElement);
                                const cssTagExists = targetDoc.querySelector('#agile-ed-hubspot-form-css') !== null;
                                const targetHead = formData.targetHead || targetDoc.head;
                                const currentStyleTags = targetHead ? targetHead.querySelectorAll('style, link[rel="stylesheet"]') : [];
                                const currentStylesheetCount = currentStyleTags.length;
                                const capturedCount = formData.capturedStylesheets ? formData.capturedStylesheets.length : 0;
                                
                                // Check which stylesheets are missing
                                const missingAfterReappend = [];
                                if (formData.capturedStylesheets && capturedCount > 0) {
                                    formData.capturedStylesheets.forEach(function(captured) {
                                        let found = false;
                                        currentStyleTags.forEach(function(current) {
                                            // Match by ID first
                                            if (captured.id && current.id === captured.id) {
                                                found = true;
                                            } 
                                            // Match by href for link tags
                                            else if (captured.href && current.href === captured.href) {
                                                found = true;
                                            } 
                                            // Match style tags by textContent (even if empty)
                                            else if (captured.tag === 'STYLE' && current.tagName === 'STYLE') {
                                                const capturedText = (captured.textContent || '').trim();
                                                const currentText = (current.textContent || '').trim();
                                                if (capturedText === currentText) {
                                                    found = true;
                                                }
                                            }
                                        });
                                        if (!found) {
                                            missingAfterReappend.push(captured);
                                        }
                                    });
                                }
                                
                                // #region agent log
                                debugInstrument('agile-ed-form-integration.js:1135', 'CSS restored after re-appending', {
                                    formDisplay:finalComputedStyle.display,
                                    formVisibility:finalComputedStyle.visibility,
                                    formOpacity:finalComputedStyle.opacity,
                                    cssTagExists:cssTagExists,
                                    hasPreservedStyles:!!formData.cssPreservedStyles,
                                    formHasStyle:!!formElement.getAttribute('style'),
                                    stylesheetCount:currentStylesheetCount,
                                    capturedStylesheetCount:capturedCount,
                                    missingStylesheets:missingAfterReappend.length,
                                    missingHrefs:missingAfterReappend.map(s => s.href || s.id || s.uniqueId || 'unknown')
                                }, 'CSS5');
                                // #endregion
                                
                                // Re-inject CSS again after a short delay to ensure it persists
                                if (formData.injectHubSpotFormCSS && typeof formData.injectHubSpotFormCSS === 'function') {
                                    setTimeout(function() {
                                        formData.injectHubSpotFormCSS();
                                    }, 100);
                                }
                                
                                // CRITICAL: If HubSpot stylesheets are missing, try to restore them
                                if (missingAfterReappend.length > 0 && targetHead) {
                                    // Check form visibility before restoring stylesheets
                                    const formElement = $form && $form[0] ? $form[0] : null;
                                    const targetWindow = formData.iframeWindow || window;
                                    const formDisplayBeforeRestore = formElement ? targetWindow.getComputedStyle(formElement).display : 'unknown';
                                    const formVisibilityBeforeRestore = formElement ? targetWindow.getComputedStyle(formElement).visibility : 'unknown';
                                    
                                    // #region agent log
                                    debugInstrument('agile-ed-form-integration.js:1168', 'Restoring missing HubSpot stylesheets', {
                                        missingCount:missingAfterReappend.length,
                                        missingHrefs:missingAfterReappend.map(s => s.href || s.id || s.uniqueId || 'unknown'),
                                        formDisplayBeforeRestore,
                                        formVisibilityBeforeRestore
                                    }, 'CSS5');
                                    // #endregion
                                    
                                    // Try to restore missing stylesheet links and style tags
                                    missingAfterReappend.forEach(function(captured) {
                                                if (captured.tag === 'LINK' && captured.href) {
                                                    // Restore <link> stylesheet
                                                    const existingLink = targetHead.querySelector('link[href="' + captured.href + '"]');
                                                    if (!existingLink) {
                                                        try {
                                                            const linkTag = targetDoc.createElement('link');
                                                            linkTag.rel = 'stylesheet';
                                                            linkTag.href = captured.href;
                                                            if (captured.id) {
                                                                linkTag.id = captured.id;
                                                            }
                                                            targetHead.appendChild(linkTag);
                                                            // #region agent log
                                                            debugInstrument('agile-ed-form-integration.js:1183', 'Restored missing stylesheet link', {href:captured.href,id:captured.id}, 'CSS5');
                                                            // #endregion
                                                        } catch (e) {
                                                            // #region agent log
                                                            debugInstrument('agile-ed-form-integration.js:1188', 'Error restoring stylesheet link', {href:captured.href,errorMessage:e?.message}, 'CSS5');
                                                            // #endregion
                                                        }
                                                    }
                                                } else if (captured.tag === 'STYLE') {
                                                    // Restore <style> tag (even if textContent is empty)
                                                    let existingStyle = null;
                                                    if (captured.id) {
                                                        existingStyle = targetDoc.getElementById(captured.id);
                                                    }
                                                    // Also check by textContent match
                                                    if (!existingStyle && captured.textContent) {
                                                        Array.from(targetHead.querySelectorAll('style')).forEach(function(style) {
                                                            if ((style.textContent || '').trim() === (captured.textContent || '').trim()) {
                                                                existingStyle = style;
                                                            }
                                                        });
                                                    }
                                                    if (!existingStyle) {
                                                        try {
                                                            // CRITICAL: Check form visibility before restoring style tag
                                                            const formElement = $form && $form[0] ? $form[0] : null;
                                                            const targetWindow = formData.iframeWindow || window;
                                                            const formDisplayBefore = formElement ? targetWindow.getComputedStyle(formElement).display : 'unknown';
                                                            const formVisibilityBefore = formElement ? targetWindow.getComputedStyle(formElement).visibility : 'unknown';
                                                            
                                                            const styleTag = targetDoc.createElement('style');
                                                            if (captured.id) {
                                                                styleTag.id = captured.id;
                                                            } else if (captured.uniqueId) {
                                                                // Use uniqueId as a data attribute for tracking
                                                                styleTag.setAttribute('data-agile-ed-unique-id', captured.uniqueId);
                                                            }
                                                            styleTag.type = 'text/css';
                                                            styleTag.textContent = captured.textContent || '';
                                                            targetHead.appendChild(styleTag);
                                                            
                                                            // CRITICAL: Check form visibility after restoring style tag
                                                            const formDisplayAfter = formElement ? targetWindow.getComputedStyle(formElement).display : 'unknown';
                                                            const formVisibilityAfter = formElement ? targetWindow.getComputedStyle(formElement).visibility : 'unknown';
                                                            
                                                            // If form became hidden, restore it immediately
                                                            if (formElement && (formDisplayAfter === 'none' || formVisibilityAfter === 'hidden')) {
                                                                formElement.style.display = 'block';
                                                                formElement.style.visibility = 'visible';
                                                                formElement.style.opacity = '1';
                                                                // #region agent log
                                                                debugInstrument('agile-ed-form-integration.js:1240', 'Form hidden after style tag restoration - restored visibility', {id:captured.id,uniqueId:captured.uniqueId,formDisplayBefore,formVisibilityBefore,formDisplayAfter,formVisibilityAfter}, 'CSS5');
                                                                // #endregion
                                                            }
                                                            
                                                            // #region agent log
                                                            debugInstrument('agile-ed-form-integration.js:1205', 'Restored missing style tag', {id:captured.id,uniqueId:captured.uniqueId,textLength:(captured.textContent || '').length,formDisplayBefore,formVisibilityBefore,formDisplayAfter,formVisibilityAfter}, 'CSS5');
                                                            // #endregion
                                                        } catch (e) {
                                                            // #region agent log
                                                            debugInstrument('agile-ed-form-integration.js:1210', 'Error restoring style tag', {id:captured.id,uniqueId:captured.uniqueId,errorMessage:e?.message}, 'CSS5');
                                                            // #endregion
                                                        }
                                                    }
                                                }
                                    });
                                    
                                    // CRITICAL: After restoring all stylesheets, check if form became hidden
                                    if (formElement) {
                                        const formDisplayAfterAllRestore = targetWindow.getComputedStyle(formElement).display;
                                        const formVisibilityAfterAllRestore = targetWindow.getComputedStyle(formElement).visibility;
                                        
                                        if (formDisplayAfterAllRestore === 'none' || formVisibilityAfterAllRestore === 'hidden') {
                                            // Form became hidden - restore it immediately
                                            formElement.style.display = 'block';
                                            formElement.style.visibility = 'visible';
                                            formElement.style.opacity = '1';
                                            // #region agent log
                                            debugInstrument('agile-ed-form-integration.js:1419', 'Form hidden after all stylesheet restoration - restored visibility', {
                                                formDisplayBeforeRestore,
                                                formVisibilityBeforeRestore,
                                                formDisplayAfterAllRestore,
                                                formVisibilityAfterAllRestore
                                            }, 'CSS5');
                                            // #endregion
                                        }
                                    }
                                }
                                
                                // Update connection state
                                formData.formWasConnected = formElement.isConnected;
                            } catch (e) {
                                // #region agent log
                                debugInstrument('agile-ed-form-integration.js:940', 'Error re-appending form', {errorMessage:e?.message}, 'CSS5');
                                // #endregion
                            }
                        }
                        
                        // If form is still disconnected, can't proceed with CSS checks
                        if (!formElement.isConnected) {
                            return;
                        }
                    }
                    
                    const targetDoc = formData.targetDocument || document;
                    const targetHead = formData.targetHead || document.head;
                    
                    // Check if CSS tag exists
                    const cssTag = targetDoc.getElementById('agile-ed-hubspot-form-css');
                    const hasPreviousApiSuccess = formData && formData.emailSearchSucceeded;
                    
                    if (!cssTag || !targetHead.contains(cssTag)) {
                        // #region agent log
                        debugInstrument('agile-ed-form-integration.js:1857', 'CSS tag missing during email editing - re-injecting', {cssTagExists:!!cssTag,cssTagInHead:cssTag && targetHead.contains(cssTag),hasPreviousApiSuccess}, 'CSS5');
                        // #endregion
                        // CSS tag missing - re-inject immediately
                        if (formData.injectHubSpotFormCSS && typeof formData.injectHubSpotFormCSS === 'function') {
                            formData.injectHubSpotFormCSS();
                            
                            // CRITICAL: If API has previously succeeded, add more aggressive re-injection
                            // HubSpot's DOM manipulation after form population can break CSS when user edits email again
                            if (hasPreviousApiSuccess) {
                                // #region agent log
                                debugInstrument('agile-ed-form-integration.js:1865', 'Previous API success - adding aggressive CSS re-injection (monitoring interval)', {emailSearchSucceeded:formData.emailSearchSucceeded}, 'CSS10');
                                // #endregion
                                
                                // Re-inject CSS multiple times with delays to catch delayed DOM manipulation
                                setTimeout(function() {
                                    if (formData && formData.injectHubSpotFormCSS) {
                                        formData.injectHubSpotFormCSS();
                                    }
                                }, 50);
                                
                                setTimeout(function() {
                                    if (formData && formData.injectHubSpotFormCSS) {
                                        formData.injectHubSpotFormCSS();
                                    }
                                }, 150);
                                
                                setTimeout(function() {
                                    if (formData && formData.injectHubSpotFormCSS) {
                                        formData.injectHubSpotFormCSS();
                                    }
                                }, 300);
                            }
                        }
                    } else if (hasPreviousApiSuccess) {
                        // CRITICAL: Even if CSS tag exists, re-inject periodically when API has succeeded
                        // This ensures CSS stays intact even if HubSpot manipulates DOM
                        // Only do this occasionally to avoid performance issues (every 5th check)
                        const checkCount = formData.cssMonitoringCheckCount || 0;
                        formData.cssMonitoringCheckCount = checkCount + 1;
                        
                        if (checkCount % 5 === 0) { // Every 5th check (roughly every 2.5 seconds during email editing)
                            // #region agent log
                            debugInstrument('agile-ed-form-integration.js:1890', 'Periodic CSS re-injection (post-API monitoring)', {checkCount,emailSearchSucceeded:formData.emailSearchSucceeded}, 'CSS10');
                            // #endregion
                            
                            if (formData.injectHubSpotFormCSS && typeof formData.injectHubSpotFormCSS === 'function') {
                                formData.injectHubSpotFormCSS();
                            }
                        }
                    }
                    
                    // Check if stylesheets were removed
                    const currentStyleTags = targetHead.querySelectorAll('style, link[rel="stylesheet"]');
                    const currentStylesheetCount = currentStyleTags.length;
                    const capturedCount = formData.capturedStylesheets ? formData.capturedStylesheets.length : 0;
                    
                    // Track which stylesheets are missing
                    const missingStylesheets = [];
                    if (formData.capturedStylesheets && capturedCount > 0) {
                        formData.capturedStylesheets.forEach(function(captured) {
                            let found = false;
                            currentStyleTags.forEach(function(current) {
                                if (captured.id && current.id === captured.id) {
                                    found = true;
                                } else if (captured.href && current.href === captured.href) {
                                    found = true;
                                } else if (captured.textContent && current.textContent && current.textContent.trim() === captured.textContent.trim()) {
                                    found = true;
                                }
                            });
                            if (!found) {
                                missingStylesheets.push(captured);
                            }
                        });
                    }
                    
                    // If significant number of stylesheets were removed, re-capture
                    if (capturedCount > 0 && currentStylesheetCount < capturedCount * 0.5) {
                        // #region agent log
                        debugInstrument('agile-ed-form-integration.js:863', 'Stylesheets removed during email editing', {
                            currentCount:currentStylesheetCount,
                            capturedCount,
                            missingCount:missingStylesheets.length,
                            missingHrefs:missingStylesheets.map(s => s.href).filter(Boolean)
                        }, 'CSS5');
                        // #endregion
                        // Re-capture stylesheets
                        if (formData.captureHubSpotStylesheets && typeof formData.captureHubSpotStylesheets === 'function') {
                            formData.captureHubSpotStylesheets();
                        }
                    } else if (missingStylesheets.length > 0) {
                        // #region agent log
                        debugInstrument('agile-ed-form-integration.js:875', 'Some stylesheets missing but count OK', {
                            currentCount:currentStylesheetCount,
                            capturedCount,
                            missingCount:missingStylesheets.length,
                            missingDetails:missingStylesheets.map(s => ({
                                tag:s.tag,
                                id:s.id || 'no-id',
                                href:s.href || 'no-href',
                                hasTextContent:!!s.textContent,
                                textLength:s.textContent ? s.textContent.length : 0
                            }))
                        }, 'CSS5');
                        // #endregion
                        
                        // CRITICAL: Restore missing stylesheets even if count is OK
                        // This ensures individual stylesheets are restored when they're removed
                        if (targetHead) {
                            missingStylesheets.forEach(function(captured) {
                                if (captured.tag === 'LINK' && captured.href) {
                                    // Restore <link> stylesheet
                                    const existingLink = targetHead.querySelector('link[href="' + captured.href + '"]');
                                    if (!existingLink) {
                                        try {
                                            const linkTag = targetDoc.createElement('link');
                                            linkTag.rel = 'stylesheet';
                                            linkTag.href = captured.href;
                                            if (captured.id) {
                                                linkTag.id = captured.id;
                                            }
                                            targetHead.appendChild(linkTag);
                                            // #region agent log
                                            debugInstrument('agile-ed-form-integration.js:900', 'Restored missing stylesheet link (count OK)', {href:captured.href,id:captured.id}, 'CSS5');
                                            // #endregion
                                        } catch (e) {
                                            // #region agent log
                                            debugInstrument('agile-ed-form-integration.js:905', 'Error restoring stylesheet link (count OK)', {href:captured.href,errorMessage:e?.message}, 'CSS5');
                                            // #endregion
                                        }
                                    }
                                } else if (captured.tag === 'STYLE' && captured.textContent) {
                                    // Restore <style> tag
                                    let existingStyle = null;
                                    if (captured.id) {
                                        existingStyle = targetDoc.getElementById(captured.id);
                                    }
                                    if (!existingStyle) {
                                        try {
                                            const styleTag = targetDoc.createElement('style');
                                            if (captured.id) {
                                                styleTag.id = captured.id;
                                            }
                                            styleTag.type = 'text/css';
                                            styleTag.textContent = captured.textContent;
                                            targetHead.appendChild(styleTag);
                                            // #region agent log
                                            debugInstrument('agile-ed-form-integration.js:923', 'Restored missing style tag (count OK)', {id:captured.id,textLength:captured.textContent.length}, 'CSS5');
                                            // #endregion
                                        } catch (e) {
                                            // #region agent log
                                            debugInstrument('agile-ed-form-integration.js:928', 'Error restoring style tag (count OK)', {id:captured.id,errorMessage:e?.message}, 'CSS5');
                                            // #endregion
                                        }
                                    }
                                }
                            });
                        }
                    }
                    
                    // Check form computed styles
                    const computedStyle = (formData.iframeWindow || window).getComputedStyle(formElement);
                    const currentDisplay = computedStyle.display;
                    const currentVisibility = computedStyle.visibility;
                    const currentOpacity = computedStyle.opacity;
                    
                    // Check for CSS loss beyond visibility - check if form has lost its visual appearance
                    // This detects when stylesheets are removed but form is still visible
                    const formBackgroundColor = computedStyle.backgroundColor;
                    const formColor = computedStyle.color;
                    const formFontSize = computedStyle.fontSize;
                    const formPadding = computedStyle.padding;
                    const formMargin = computedStyle.margin;
                    // Check if form appears to have lost styling (very basic check - form should have some padding/margin if styled)
                    // This is a heuristic - a properly styled form usually has some spacing
                    const formHasNoStyles = (formPadding === '0px' || formPadding === '') && 
                                          (formMargin === '0px' || formMargin === '') &&
                                          (!formFontSize || formFontSize === '0px' || formFontSize === '16px'); // 16px is browser default
                    
                    // CRITICAL: Check if form looks unstyled (more comprehensive check)
                    // This detects when stylesheets are removed but form is still visible
                    const looksUnstyled = (
                        (!formBackgroundColor || formBackgroundColor === 'rgba(0, 0, 0, 0)' || formBackgroundColor === 'transparent') &&
                        (!formColor || formColor === 'rgb(0, 0, 0)') &&
                        (!formFontSize || formFontSize === '16px') &&
                        (!formPadding || formPadding === '0px')
                    );
                    
                    // CRITICAL: Check form field visibility - form fields might be hidden even if form is visible
                    // Use the SAME selector as continuous restore loop to ensure consistency
                    // IMPORTANT: Include .hs-form-field and .hs-input to catch all form elements
                    const formFields = $form.find('input:not([type="hidden"]):not([type="submit"]):not([type="button"]), textarea, select, label, .hs-form-field, .hs-input');
                    let hiddenFieldsCount = 0;
                    let visibleFieldsCount = 0;
                    formFields.each(function() {
                        const field = this;
                        if (field.isConnected) {
                            // CRITICAL: Check if field was originally hidden - if so, skip restoration
                            const wasOriginallyHidden = formData.cssPreservedStyles && 
                                                       formData.cssPreservedStyles.originalHiddenState && 
                                                       formData.cssPreservedStyles.originalHiddenState[field] === true;
                            
                            if (wasOriginallyHidden) {
                                // Field was originally hidden - keep it hidden, don't restore
                                return;
                            }
                            
                            // CRITICAL: Skip hidden input fields - they should stay hidden
                            if (field.tagName === 'INPUT' && (field.type === 'hidden' || field.type === 'submit' || field.type === 'button')) {
                                return; // Skip this field
                            }
                            
                            // CRITICAL: Skip fields that are intentionally hidden by design
                            // Check for hidden attribute, aria-hidden, or hidden classes
                            if (field.hasAttribute('hidden') || 
                                field.getAttribute('aria-hidden') === 'true' ||
                                field.classList.contains('hs-hidden') ||
                                field.classList.contains('hidden') ||
                                field.classList.contains('sr-only') ||
                                field.classList.contains('visually-hidden')) {
                                return; // Skip intentionally hidden fields
                            }
                            
                            // CRITICAL: For .hs-form-field containers, check if they contain hidden inputs
                            // If they do, they should remain hidden
                            if (field.classList.contains('hs-form-field')) {
                                const hiddenInputs = field.querySelectorAll('input[type="hidden"]');
                                if (hiddenInputs.length > 0) {
                                    // Check if this container is meant to be hidden (only contains hidden inputs)
                                    const visibleInputs = field.querySelectorAll('input:not([type="hidden"]):not([type="submit"]):not([type="button"]), textarea, select');
                                    if (visibleInputs.length === 0) {
                                        return; // Skip containers that only have hidden inputs
                                    }
                                }
                            }
                            
                            // CRITICAL: Check if parent has hidden attribute or aria-hidden
                            let parentElement = field.parentElement;
                            while (parentElement && parentElement !== formElement) {
                                if (parentElement.hasAttribute('hidden') || 
                                    parentElement.getAttribute('aria-hidden') === 'true' ||
                                    parentElement.classList.contains('hs-hidden') ||
                                    parentElement.classList.contains('hidden')) {
                                    return; // Skip fields with intentionally hidden parents
                                }
                                parentElement = parentElement.parentElement;
                            }
                            
                            // CRITICAL: Check if field's original inline style had display:none
                            // This indicates it was intentionally hidden by design
                            const originalStyle = formData.cssPreservedStyles && 
                                                 formData.cssPreservedStyles.elements && 
                                                 formData.cssPreservedStyles.elements[field];
                            if (originalStyle && (originalStyle.includes('display:none') || originalStyle.includes('display: none'))) {
                                // Original style had display:none - keep it hidden
                                return;
                            }
                            
                            const targetWindow = formData.iframeWindow || window;
                            const fieldComputed = targetWindow.getComputedStyle(field);
                            
                            // CRITICAL: Also check parent elements - they might be hiding the field
                            // Reuse parentElement variable (already declared above)
                            let parentHiding = false;
                            parentElement = field.parentElement; // Reset to start from field's parent
                            while (parentElement && parentElement !== formElement) {
                                const parentComputed = targetWindow.getComputedStyle(parentElement);
                                if (parentComputed.display === 'none' || parentComputed.visibility === 'hidden' || parseFloat(parentComputed.opacity) === 0) {
                                    parentHiding = true;
                                    // Restore parent visibility immediately
                                    parentElement.style.setProperty('display', 'block', 'important');
                                    parentElement.style.setProperty('visibility', 'visible', 'important');
                                    parentElement.style.setProperty('opacity', '1', 'important');
                                    // #region agent log
                                    debugInstrument('agile-ed-form-integration.js:1965', 'Parent element hiding field - restored', {
                                        fieldTag:field.tagName,
                                        fieldType:field.type,
                                        parentTag:parentElement.tagName,
                                        parentClass:parentElement.className
                                    }, 'CSS5');
                                    // #endregion
                                    break;
                                }
                                parentElement = parentElement.parentElement;
                            }
                            
                            // CRITICAL: Check for additional CSS properties that could hide fields
                            const fieldHeight = parseFloat(fieldComputed.height);
                            const fieldWidth = parseFloat(fieldComputed.width);
                            const fieldMaxHeight = parseFloat(fieldComputed.maxHeight);
                            const fieldMaxWidth = parseFloat(fieldComputed.maxWidth);
                            const fieldPosition = fieldComputed.position;
                            const fieldLeft = fieldComputed.left;
                            const fieldTop = fieldComputed.top;
                            const fieldTransform = fieldComputed.transform;
                            const fieldClip = fieldComputed.clip;
                            const fieldClipPath = fieldComputed.clipPath;
                            
                            // Check if field has zero dimensions (hidden by height/width)
                            const hasZeroDimensions = (fieldHeight === 0 && fieldWidth === 0) || 
                                                      (fieldMaxHeight === 0) || 
                                                      (fieldMaxWidth === 0);
                            
                            // Check if field is positioned off-screen
                            const isOffScreen = fieldPosition === 'absolute' && 
                                                (fieldLeft === '-9999px' || fieldTop === '-9999px' || 
                                                 parseFloat(fieldLeft) < -1000 || parseFloat(fieldTop) < -1000);
                            
                            // Check if field is transformed to be invisible
                            const isTransformedAway = fieldTransform && 
                                                      (fieldTransform.includes('scale(0)') || 
                                                       fieldTransform.includes('translateX(-9999px)') ||
                                                       fieldTransform.includes('translateY(-9999px)'));
                            
                            // Check if field is clipped
                            const isClipped = (fieldClip && fieldClip !== 'auto' && fieldClip.includes('rect(0')) ||
                                                (fieldClipPath && fieldClipPath !== 'none' && fieldClipPath.includes('inset(0'));

                            // CRITICAL: Also check bounding box - field might be hidden even if CSS says it's visible
                            let isBoundingBoxHidden = false;
                            try {
                                const boundingRect = field.getBoundingClientRect();
                                // Field is hidden if it has zero dimensions or is positioned off-screen
                                if (boundingRect.width === 0 && boundingRect.height === 0) {
                                    isBoundingBoxHidden = true;
                                } else if (boundingRect.left < -1000 || boundingRect.top < -1000 || 
                                           boundingRect.right < 0 || boundingRect.bottom < 0) {
                                    isBoundingBoxHidden = true;
                                }
                            } catch (e) {
                                // Ignore errors in bounding box check
                            }
                            
                            if (fieldComputed.display === 'none' || fieldComputed.visibility === 'hidden' || parseFloat(fieldComputed.opacity) === 0 || parentHiding || hasZeroDimensions || isOffScreen || isTransformedAway || isClipped || isBoundingBoxHidden) {
                                // Field is hidden - restore it with !important to override HubSpot's CSS
                                const beforeDisplay = fieldComputed.display;
                                const beforeVisibility = fieldComputed.visibility;
                                const beforeOpacity = fieldComputed.opacity;
                                const beforeStyle = field.getAttribute('style') || '';
                                
                                let fieldStyle = beforeStyle;
                                if (fieldStyle && !fieldStyle.endsWith(';')) {
                                    fieldStyle += ';';
                                }
                                if (fieldComputed.display === 'none') {
                                    fieldStyle += 'display: block !important; ';
                                }
                                if (fieldComputed.visibility === 'hidden') {
                                    fieldStyle += 'visibility: visible !important; ';
                                }
                                if (parseFloat(fieldComputed.opacity) === 0) {
                                    fieldStyle += 'opacity: 1 !important; ';
                                }
                                // Restore dimensions if zero
                                if (hasZeroDimensions || isBoundingBoxHidden) {
                                    if (fieldHeight === 0 || parseFloat(fieldComputed.height) === 0) {
                                        fieldStyle += 'height: auto !important; ';
                                    }
                                    if (fieldWidth === 0 || parseFloat(fieldComputed.width) === 0) {
                                        fieldStyle += 'width: auto !important; ';
                                    }
                                    if (fieldMaxHeight === 0) {
                                        fieldStyle += 'max-height: none !important; ';
                                    }
                                    if (fieldMaxWidth === 0) {
                                        fieldStyle += 'max-width: none !important; ';
                                    }
                                }
                                // Restore position if off-screen
                                if (isOffScreen || isBoundingBoxHidden) {
                                    fieldStyle += 'position: static !important; left: auto !important; top: auto !important; right: auto !important; bottom: auto !important; ';
                                }
                                // Restore transform if transformed away
                                if (isTransformedAway) {
                                    fieldStyle += 'transform: none !important; ';
                                }
                                // Restore clip if clipped
                                if (isClipped) {
                                    fieldStyle += 'clip: auto !important; clip-path: none !important; ';
                                }
                                if (fieldStyle) {
                                    field.setAttribute('style', fieldStyle);
                                    // Force a reflow to ensure the style is applied
                                    field.offsetHeight;
                                    
                                    // CRITICAL: Verify the style was actually applied
                                    const afterComputed = (formData.iframeWindow || window).getComputedStyle(field);
                                    const afterDisplay = afterComputed.display;
                                    const afterVisibility = afterComputed.visibility;
                                    const afterOpacity = afterComputed.opacity;
                                    const afterStyle = field.getAttribute('style') || '';
                                    
                                    // If still hidden, try using style property directly
                                    if (afterDisplay === 'none' || afterVisibility === 'hidden' || parseFloat(afterOpacity) === 0) {
                                        // #region agent log
                                        debugInstrument('agile-ed-form-integration.js:1800', 'Field still hidden after inline style - using style property', {
                                            fieldTag:field.tagName,
                                            fieldType:field.type,
                                            beforeDisplay,
                                            beforeVisibility,
                                            beforeOpacity,
                                            afterDisplay,
                                            afterVisibility,
                                            afterOpacity,
                                            beforeStyle,
                                            afterStyle
                                        }, 'CSS5');
                                        // #endregion
                                        
                                        // Try using style property directly (higher priority than setAttribute)
                                        if (afterDisplay === 'none') {
                                            field.style.setProperty('display', 'block', 'important');
                                        }
                                        if (afterVisibility === 'hidden') {
                                            field.style.setProperty('visibility', 'visible', 'important');
                                        }
                                        if (parseFloat(afterOpacity) === 0) {
                                            field.style.setProperty('opacity', '1', 'important');
                                        }
                                        
                                        // Force another reflow
                                        field.offsetHeight;
                                        
                                        // Verify again
                                        const finalComputed = (formData.iframeWindow || window).getComputedStyle(field);
                                        if (finalComputed.display === 'none' || finalComputed.visibility === 'hidden' || parseFloat(finalComputed.opacity) === 0) {
                                            // #region agent log
                                            debugInstrument('agile-ed-form-integration.js:1825', 'Field STILL hidden after style property - parent may be hiding it', {
                                                fieldTag:field.tagName,
                                                fieldType:field.type,
                                                finalDisplay:finalComputed.display,
                                                finalVisibility:finalComputed.visibility,
                                                finalOpacity:finalComputed.opacity,
                                                parentDisplay:field.parentElement ? (formData.iframeWindow || window).getComputedStyle(field.parentElement).display : 'no-parent',
                                                parentVisibility:field.parentElement ? (formData.iframeWindow || window).getComputedStyle(field.parentElement).visibility : 'no-parent'
                                            }, 'CSS5');
                                            // #endregion
                                        }
                                    }
                                }
                                hiddenFieldsCount++;
                            } else {
                                visibleFieldsCount++;
                            }
                        }
                    });
                    
                    // Check if CSS tag was removed and get reference
                    const cssTagForCheck = targetDoc.getElementById('agile-ed-hubspot-form-css');
                    const cssTagStillExists = cssTagForCheck !== null;
                    
                    // CRITICAL: Check if CSS tag content is intact
                    const cssTagContentLength = cssTagForCheck ? (cssTagForCheck.textContent || cssTagForCheck.innerHTML || '').length : 0;
                    const expectedCssTagLength = formData.hubspotFormCSS ? formData.hubspotFormCSS.length : 0;
                    const cssTagContentLost = cssTagForCheck && expectedCssTagLength > 0 && cssTagContentLength < expectedCssTagLength * 0.5;
                    
                    // #region agent log
                    // Log form field visibility status
                    if (hiddenFieldsCount > 0) {
                        debugInstrument('agile-ed-form-integration.js:1695', 'Form fields hidden detected - restoring', {
                            hiddenFieldsCount,
                            visibleFieldsCount,
                            totalFields:formFields.length
                        }, 'CSS5');
                    }
                    
                    debugInstrument('agile-ed-form-integration.js:1219', 'CSS monitoring - checking form styles', {
                        hiddenFieldsCount,
                        visibleFieldsCount,
                        totalFields:formFields.length,
                        display:currentDisplay,
                        visibility:currentVisibility,
                        opacity:currentOpacity,
                        backgroundColor:formBackgroundColor,
                        color:formColor,
                        fontSize:formFontSize,
                        padding:formPadding,
                        cssTagExists:cssTagStillExists,
                        cssTagContentLength,
                        expectedCssTagLength,
                        cssTagContentLost,
                        stylesheetCount:currentStylesheetCount,
                        capturedStylesheetCount:capturedCount,
                        looksUnstyled,
                        formHasNoStyles,
                        editCount:formData.emailEditCount || 0
                    }, 'CSS5');
                    // #endregion
                    
                    // If CSS tag was removed, re-inject immediately
                    if (!cssTagStillExists) {
                        // #region agent log
                        debugInstrument('agile-ed-form-integration.js:1233', 'CSS tag removed during monitoring - re-injecting', {editCount:formData.emailEditCount || 0}, 'CSS5');
                        // #endregion
                        if (formData.injectHubSpotFormCSS && typeof formData.injectHubSpotFormCSS === 'function') {
                            formData.injectHubSpotFormCSS();
                        }
                    }
                    
                    // CRITICAL: If CSS tag content is lost, re-inject immediately
                    if (cssTagContentLost && formData.injectHubSpotFormCSS && typeof formData.injectHubSpotFormCSS === 'function') {
                        // #region agent log
                        debugInstrument('agile-ed-form-integration.js:1245', 'CSS tag content lost during monitoring - re-injecting', {
                            editCount:formData.emailEditCount || 0,
                            cssTagContentLength,
                            expectedCssTagLength
                        }, 'CSS5');
                        // #endregion
                        formData.injectHubSpotFormCSS();
                    }
                    
                    // CRITICAL: If form looks unstyled, re-inject CSS immediately
                    if (looksUnstyled && formData.injectHubSpotFormCSS && typeof formData.injectHubSpotFormCSS === 'function') {
                        // #region agent log
                        debugInstrument('agile-ed-form-integration.js:1255', 'Form looks unstyled during monitoring - re-injecting CSS', {
                            editCount:formData.emailEditCount || 0,
                            formBackgroundColor,
                            formColor,
                            formFontSize
                        }, 'CSS5');
                        // #endregion
                        formData.injectHubSpotFormCSS();
                    }
                    
                    // If stylesheets were removed, re-inject CSS immediately
                    if (capturedCount > 0 && currentStylesheetCount < capturedCount * 0.5) {
                        // #region agent log
                        debugInstrument('agile-ed-form-integration.js:1248', 'Stylesheets removed - re-injecting CSS', {currentCount:currentStylesheetCount,capturedCount}, 'CSS5');
                        // #endregion
                        if (formData.injectHubSpotFormCSS && typeof formData.injectHubSpotFormCSS === 'function') {
                            formData.injectHubSpotFormCSS();
                        }
                        
                        // Try to restore missing stylesheet links and style tags
                        if (missingStylesheets.length > 0 && targetHead) {
                            missingStylesheets.forEach(function(captured) {
                                if (captured.tag === 'LINK' && captured.href) {
                                    // Restore <link> stylesheet
                                    const existingLink = targetHead.querySelector('link[href="' + captured.href + '"]');
                                    if (!existingLink) {
                                        try {
                                            const linkTag = targetDoc.createElement('link');
                                            linkTag.rel = 'stylesheet';
                                            linkTag.href = captured.href;
                                            if (captured.id) {
                                                linkTag.id = captured.id;
                                            }
                                            targetHead.appendChild(linkTag);
                                            // #region agent log
                                            debugInstrument('agile-ed-form-integration.js:1265', 'Restored missing stylesheet link during monitoring', {href:captured.href,id:captured.id}, 'CSS5');
                                            // #endregion
                                        } catch (e) {
                                            // #region agent log
                                            debugInstrument('agile-ed-form-integration.js:1270', 'Error restoring stylesheet link during monitoring', {href:captured.href,errorMessage:e?.message}, 'CSS5');
                                            // #endregion
                                        }
                                    }
                                } else if (captured.tag === 'STYLE' && captured.textContent) {
                                    // Restore <style> tag
                                    let existingStyle = null;
                                    if (captured.id) {
                                        existingStyle = targetDoc.getElementById(captured.id);
                                    }
                                    if (!existingStyle) {
                                        try {
                                            const styleTag = targetDoc.createElement('style');
                                            if (captured.id) {
                                                styleTag.id = captured.id;
                                            }
                                            styleTag.type = 'text/css';
                                            styleTag.textContent = captured.textContent;
                                            targetHead.appendChild(styleTag);
                                            // #region agent log
                                            debugInstrument('agile-ed-form-integration.js:1285', 'Restored missing style tag during monitoring', {id:captured.id,textLength:captured.textContent.length}, 'CSS5');
                                            // #endregion
                                        } catch (e) {
                                            // #region agent log
                                            debugInstrument('agile-ed-form-integration.js:1290', 'Error restoring style tag during monitoring', {id:captured.id,errorMessage:e?.message}, 'CSS5');
                                            // #endregion
                                        }
                                    }
                                }
                            });
                        }
                    }
                    
                    // If form has lost visibility OR visual appearance, restore immediately
                    if (currentDisplay === 'none' || currentVisibility === 'hidden' || parseFloat(currentOpacity) === 0 || formHasNoStyles) {
                        // #region agent log
                        debugInstrument('agile-ed-form-integration.js:1256', 'Form CSS lost during email editing - restoring', {
                            currentDisplay,
                            currentVisibility,
                            currentOpacity,
                            formHasNoStyles,
                            backgroundColor:formBackgroundColor,
                            color:formColor,
                            cssTagExists:cssTagStillExists
                        }, 'CSS5');
                        // #endregion
                        
                        // Re-inject CSS first if tag is missing
                        if (!cssTagStillExists && formData.injectHubSpotFormCSS && typeof formData.injectHubSpotFormCSS === 'function') {
                            formData.injectHubSpotFormCSS();
                        }
                        
                        // Restore from preserved styles
                        if (formData.cssPreservedStyles && formData.cssPreservedStyles.formStyle) {
                            formElement.setAttribute('style', formData.cssPreservedStyles.formStyle);
                        } else if (formData.originalFormStyle) {
                            formElement.setAttribute('style', formData.originalFormStyle);
                        }
                        
                        // Also ensure visibility properties
                        let inlineStyle = formElement.getAttribute('style') || '';
                        if (inlineStyle && !inlineStyle.endsWith(';')) {
                            inlineStyle += ';';
                        }
                        if (currentDisplay === 'none') {
                            inlineStyle += 'display: block !important; ';
                        }
                        if (currentVisibility === 'hidden') {
                            inlineStyle += 'visibility: visible !important; ';
                        }
                        if (parseFloat(currentOpacity) === 0) {
                            inlineStyle += 'opacity: 1 !important; ';
                        }
                        formElement.setAttribute('style', inlineStyle);
                        
                        // Re-inject CSS again after restoring styles
                        if (formData.injectHubSpotFormCSS && typeof formData.injectHubSpotFormCSS === 'function') {
                            setTimeout(function() {
                                formData.injectHubSpotFormCSS();
                            }, 50);
                        }
                    }
                    
                    // Check all form inputs/fields
                    const formInputs = $form.find('input:not([type="hidden"]), textarea, select, label, .hs-form-field, .hs-input');
                    formInputs.each(function() {
                        const el = this;
                        if (!el.isConnected) {
                            return;
                        }
                        
                        const elComputed = (formData.iframeWindow || window).getComputedStyle(el);
                        if (elComputed.display === 'none' || elComputed.visibility === 'hidden') {
                            // Restore from preserved styles
                            if (formData.cssPreservedStyles && formData.cssPreservedStyles.elements && formData.cssPreservedStyles.elements[el]) {
                                el.setAttribute('style', formData.cssPreservedStyles.elements[el]);
                            }
                            
                            // Ensure visibility
                            let elStyle = el.getAttribute('style') || '';
                            if (elStyle && !elStyle.endsWith(';')) {
                                elStyle += ';';
                            }
                            if (elComputed.display === 'none') {
                                elStyle += 'display: block !important; ';
                            }
                            if (elComputed.visibility === 'hidden') {
                                elStyle += 'visibility: visible !important; ';
                            }
                            el.setAttribute('style', elStyle);
                        }
                    });
                } catch (e) {
                    // #region agent log
                    debugInstrument('agile-ed-form-integration.js:850', 'Error in CSS monitoring', {errorMessage:e?.message}, 'CSS5');
                    // #endregion
                }
            }, 100); // Check every 100ms during email editing
        };
        
        const stopCssMonitoring = function() {
            if (cssMonitorInterval) {
                clearInterval(cssMonitorInterval);
                cssMonitorInterval = null;
            }
        };
        
        // Store monitoring functions
        formData.startCssMonitoring = startCssMonitoring;
        formData.stopCssMonitoring = stopCssMonitoring;
        
        // CRITICAL: Track HubSpot DOM manipulation by monitoring for insertBefore errors
        // When we detect HubSpot is manipulating DOM, pause all our operations
        const originalInsertBefore = Node.prototype.insertBefore;
        const originalRemoveChild = Node.prototype.removeChild;
        const originalReplaceChild = Node.prototype.replaceChild;
        
        // CRITICAL: Override innerHTML setter to prevent form removal via innerHTML manipulation
        const formElement = $form[0];
        if (formElement && formElement.parentNode) {
            const parentElement = formElement.parentNode;
            const parentDescriptor = Object.getOwnPropertyDescriptor(parentElement.constructor.prototype, 'innerHTML');
            if (parentDescriptor && parentDescriptor.set) {
                const originalInnerHTMLSetter = parentDescriptor.set;
                Object.defineProperty(parentElement, 'innerHTML', {
                    set: function(value) {
                        // Check if email input is active
                        if (formData && formData.emailInputActive) {
                            // Check if the new value would remove our form
                            if (typeof value === 'string' && !value.includes(formElement.outerHTML)) {
                                debugWarn('BLOCKED innerHTML manipulation - email input is active');
                                // Don't allow innerHTML change that would remove form
                                return;
                            }
                        }
                        // Check if value contains form - if not, prevent
                        if (formData && formData.$form && formData.$form[0] && typeof value === 'string') {
                            const formId = formData.$form.attr('id') || '';
                            const formClass = formData.$form.attr('class') || '';
                            if (formId && !value.includes('id="' + formId + '"') && !value.includes("id='" + formId + "'")) {
                                if (formData.emailInputActive) {
                                    debugWarn('BLOCKED innerHTML manipulation that would remove form');
                                    return;
                                }
                            }
                        }
                        return originalInnerHTMLSetter.call(this, value);
                    },
                    get: function() {
                        return parentDescriptor.get ? parentDescriptor.get.call(this) : this.innerHTML;
                    },
                    configurable: true
                });
            }
        }
        
        // CRITICAL: Override replaceChild to prevent form replacement
        Node.prototype.replaceChild = function(newChild, oldChild) {
            try {
                // Check if we're replacing the form
                if (oldChild && typeof oldChild === 'object' && formData && formData.$form && formData.$form[0] === oldChild) {
                    debugWarn('Prevented form replacement by HubSpot');
                    // Don't replace the form - just return the old child
                    return oldChild;
                }
                return originalReplaceChild.call(this, newChild, oldChild);
            } catch (error) {
                const stack = new Error().stack || '';
                if (stack.includes('v2.js')) {
                    // Suppress HubSpot errors
                    return oldChild;
                }
                throw error;
            }
        };
        
        // Wrap insertBefore to detect HubSpot operations
        Node.prototype.insertBefore = function(newNode, referenceNode) {
            try {
                return originalInsertBefore.call(this, newNode, referenceNode);
            } catch (error) {
                // If error is from HubSpot's v2.js, set flag and suppress
                const stack = new Error().stack || '';
                if (stack.includes('v2.js') || error.message.includes('not a child')) {
                    formData.hubspotManipulating = true;
                    clearTimeout(formData.hubspotManipulationTimeout);
                    formData.hubspotManipulationTimeout = setTimeout(() => {
                        formData.hubspotManipulating = false;
                    }, 1000);
                    // Suppress the error - don't throw
                    return newNode;
                }
                throw error;
            }
        };
        
        // Wrap removeChild similarly
        Node.prototype.removeChild = function(child) {
            // #region agent log
            debugInstrument('agile-ed-form-integration.js:861', 'removeChild called', {hasChild:!!child,childType:child?.nodeName,childId:child?.id,childClass:child?.className,parentNodeType:this?.nodeName,parentNodeId:this?.id,isChildOfParent:child?.parentNode===this,hasParentNode:!!child?.parentNode}, 'A');
            // #endregion
            try {
                // CRITICAL: First check if child is actually a child of this node
                // This prevents NotFoundError from being thrown
                if (!child) {
                    // No child provided - return null to match native behavior
                    return null;
                }
                
                // CRITICAL: Check if child is actually a child of this node BEFORE calling original
                // This prevents NotFoundError from being thrown by the native removeChild
                if (child.parentNode !== this) {
                    // Child is not a child of this node - this will cause NotFoundError
                    // Get stack trace to check if this is from HubSpot
                    let stack = '';
                    try {
                        throw new Error();
                    } catch (e) {
                        stack = e.stack || '';
                    }
                    
                    // #region agent log
                    debugInstrument('agile-ed-form-integration.js:865', 'removeChild - child not a child of parent', {
                        childType:child?.nodeName,
                        childId:child?.id,
                        parentNodeType:this?.nodeName,
                        parentNodeId:this?.id,
                        actualParentType:child?.parentNode?.nodeName,
                        actualParentId:child?.parentNode?.id,
                        includesV2:stack.includes('v2.js'),
                        includesHubspot:stack.includes('hubspot')
                    }, 'B');
                    // #endregion
                    
                    // ALWAYS suppress the error to prevent console noise
                    // Just return the child without removing - this prevents NotFoundError
                    return child;
                }
                
                // CRITICAL: Check if we're trying to remove the form or form container
                // If so, prevent removal to keep form visible
                if (child && typeof child === 'object') {
                    // More comprehensive form detection - check all forms in formData
                    let isForm = false;
                    let matchingFormData = null;
                    
                    // Check if this is a form element
                    if (child.nodeName === 'FORM' || 
                        (child.className && typeof child.className === 'string' && (child.className.includes('hs-form') || child.className.includes('form'))) ||
                        (child.id && typeof child.id === 'string' && (child.id.includes('form') || child.id === 'form1'))) {
                        isForm = true;
                    }
                    
                    // Check against all known form instances
                    if (typeof window !== 'undefined' && window.agileEdFormInstances) {
                        for (let instanceId in window.agileEdFormInstances) {
                            const instanceData = window.agileEdFormInstances[instanceId];
                            if (instanceData && instanceData.$form && instanceData.$form[0] === child) {
                                isForm = true;
                                matchingFormData = instanceData;
                                break;
                            }
                        }
                    }
                    
                    // Also check current formData
                    if (!matchingFormData && formData && formData.$form && formData.$form[0] === child) {
                        isForm = true;
                        matchingFormData = formData;
                    }
                    
                    if (isForm && matchingFormData) {
                        // CRITICAL: If email input is active, NEVER allow form removal
                        // This is the most important protection - form must stay during email editing
                        // ESPECIALLY for known emails where API calls trigger HubSpot DOM manipulation
                        if (matchingFormData.emailInputActive) {
                            debugWarn('BLOCKED form removal - email input is active (known email protection)');
                            
                            // CRITICAL: Immediately re-append form if it was removed
                            // This is a safety net in case removal somehow still happens
                            try {
                                if (child && child.parentNode !== matchingFormData.formParent) {
                                    // Form was removed - immediately restore it
                                    if (matchingFormData.formParent && matchingFormData.formParent.appendChild) {
                                        if (matchingFormData.formNextSibling && matchingFormData.formNextSibling.parentNode === matchingFormData.formParent) {
                                            matchingFormData.formParent.insertBefore(child, matchingFormData.formNextSibling);
                                        } else {
                                            matchingFormData.formParent.appendChild(child);
                                        }
                                        debugLog('Form immediately restored during email input');
                                    }
                                }
                            } catch (e) {
                                debugWarn('Error restoring form during email input:', e);
                            }
                            
                            // Update form position
                            try {
                                if (child.parentNode) {
                                    matchingFormData.formParent = child.parentNode;
                                    matchingFormData.formNextSibling = child.nextSibling;
                                }
                            } catch (e) {
                                // Ignore
                            }
                            
                            // Absolutely prevent removal - return child without removing
                            return child;
                        }
                        
                        // Check if we're in a restoration loop - if so, allow removal to break the loop
                        const timeSinceLastRestore = Date.now() - (matchingFormData.lastRestoreTime || 0);
                        if (matchingFormData.isRestoring || (matchingFormData.restoreCount > 3 && timeSinceLastRestore < 2000)) {
                            // Too many restorations in short time - allow removal to break loop
                            debugWarn('Allowing form removal to break restoration loop');
                            return originalRemoveChild.call(this, child);
                        }
                        
                        // CRITICAL: Update form position before preventing removal
                        try {
                            if (child.parentNode) {
                                matchingFormData.formParent = child.parentNode;
                                matchingFormData.formNextSibling = child.nextSibling;
                            }
                        } catch (e) {
                            // Ignore
                        }
                        
                        debugWarn('Prevented form removal by HubSpot');
                        // Don't remove the form - just return the child
                        return child;
                    }
                    
                    // Check if child contains a form
                    if (child.querySelector && child.querySelector('form, .hs-form, .hs-form-container')) {
                        // Check if this is our form
                        const formInChild = child.querySelector('form');
                        if (formInChild) {
                            // Check all form instances
                            let matchingFormData = null;
                            if (typeof window !== 'undefined' && window.agileEdFormInstances) {
                                for (let instanceId in window.agileEdFormInstances) {
                                    const instanceData = window.agileEdFormInstances[instanceId];
                                    if (instanceData && instanceData.$form && instanceData.$form[0] === formInChild) {
                                        matchingFormData = instanceData;
                                        break;
                                    }
                                }
                            }
                            if (!matchingFormData && formData && formData.$form && formData.$form[0] === formInChild) {
                                matchingFormData = formData;
                            }
                            
                            if (matchingFormData) {
                                // CRITICAL: If email input is active, NEVER allow container removal
                                if (matchingFormData.emailInputActive) {
                                    debugWarn('BLOCKED form container removal - email input is active');
                                    return child;
                                }
                                
                                const timeSinceLastRestore = Date.now() - (matchingFormData.lastRestoreTime || 0);
                                if (matchingFormData.isRestoring || (matchingFormData.restoreCount > 3 && timeSinceLastRestore < 2000)) {
                                    debugWarn('Allowing form container removal to break restoration loop');
                                    return originalRemoveChild.call(this, child);
                                }
                                debugWarn('Prevented form container removal by HubSpot');
                                return child;
                            }
                        }
                    }
                }
                
                // #region agent log
                debugInstrument('agile-ed-form-integration.js:1011', 'removeChild - calling original', {childType:child?.nodeName,parentNodeType:this?.nodeName}, 'E');
                // #endregion
                return originalRemoveChild.call(this, child);
            } catch (error) {
                // #region agent log
                debugInstrument('agile-ed-form-integration.js:1013', 'removeChild - error caught', {errorName:error?.name,errorMessage:error?.message,childType:child?.nodeName,parentNodeType:this?.nodeName}, 'E');
                // #endregion
                // CRITICAL: Suppress all NotFoundError from removeChild, especially from HubSpot
                const stack = new Error().stack || '';
                const errorMessage = error && error.message ? String(error.message) : '';
                const errorName = error && error.name ? String(error.name) : '';
                
                // #region agent log
                debugInstrument('agile-ed-form-integration.js:1018', 'removeChild - checking suppression conditions', {hasStack:!!stack,includesV2:stack.includes('v2.js'),includesHubspot:stack.includes('hubspot'),errorName,errorMessage,willSuppress:stack.includes('v2.js')||stack.includes('hubspot')||errorName==='NotFoundError'||errorMessage.includes('removeChild')||errorMessage.includes('not a child of this node')||errorMessage.includes('The node to be removed')||errorMessage.includes('Failed to execute')}, 'D');
                // #endregion
                // Suppress if it's from HubSpot OR if it's a NotFoundError about removeChild
                if (stack.includes('v2.js') || 
                    stack.includes('hubspot') ||
                    errorName === 'NotFoundError' ||
                    errorMessage.includes('removeChild') ||
                    errorMessage.includes('not a child of this node') ||
                    errorMessage.includes('The node to be removed') ||
                    errorMessage.includes('Failed to execute')) {
                    // Set flag to track HubSpot manipulation
                    if (formData) {
                        formData.hubspotManipulating = true;
                        clearTimeout(formData.hubspotManipulationTimeout);
                        formData.hubspotManipulationTimeout = setTimeout(() => {
                            formData.hubspotManipulating = false;
                        }, 1000);
                    }
                    
                    // #region agent log
                    debugInstrument('agile-ed-form-integration.js:1035', 'removeChild - suppressing error', {errorName,errorMessage}, 'D');
                    // #endregion
                    // Suppress the error silently - don't throw, don't log
                    return child;
                }
                // #region agent log
                debugInstrument('agile-ed-form-integration.js:1038', 'removeChild - rethrowing error', {errorName,errorMessage}, 'E');
                // #endregion
                throw error;
            }
        };
        
        // CRITICAL: Add MutationObserver to detect and prevent form removal
        // This watches for form being removed from DOM and restores it
        try {
            const formObserver = new MutationObserver(function(mutations) {
                mutations.forEach(function(mutation) {
                    if (mutation.type === 'childList' && mutation.removedNodes.length > 0) {
                        mutation.removedNodes.forEach(function(node) {
                            if (node && node.nodeType === 1) {
                                const isForm = node.nodeName === 'FORM' || 
                                            (node.className && typeof node.className === 'string' && (node.className.includes('hs-form') || node.className.includes('form'))) ||
                                            (node.id && typeof node.id === 'string' && (node.id.includes('form') || node.id === 'form1'));
                                
                                if (isForm && formData && formData.$form && formData.$form[0] === node) {
                                    // CRITICAL: Prevent infinite restoration loops
                                    const timeSinceLastRestore = Date.now() - (formData.lastRestoreTime || 0);
                                    if (formData.isRestoring || (formData.restoreCount > 5 && timeSinceLastRestore < 3000)) {
                                        debugWarn('Skipping form restoration - too many restorations detected (loop prevention)');
                                        return; // Exit to break the loop
                                    }
                                    
                                    // CRITICAL: IMMEDIATELY re-append form to prevent style loss
                                    // Don't wait for setTimeout - do it synchronously to preserve styles
                                    try {
                                        // Update form position if needed
                                        if (node.parentNode !== formData.formParent) {
                                            formData.formParent = node.parentNode;
                                        }
                                        
                                        // IMMEDIATELY re-append to exact same position
                                        if (formData.formParent && formData.formParent.appendChild) {
                                            // Temporarily disconnect observer to prevent loop
                                            try {
                                                formObserver.disconnect();
                                            } catch (e) {
                                                // Ignore
                                            }
                                            
                                            // Re-append form IMMEDIATELY to preserve styles
                                            if (formData.formNextSibling && formData.formNextSibling.parentNode === formData.formParent) {
                                                formData.formParent.insertBefore(node, formData.formNextSibling);
                                            } else {
                                                formData.formParent.appendChild(node);
                                            }
                                            
                                            // Update formData reference
                                            formData.$form = $(node);
                                            
                                            debugLog('Form IMMEDIATELY re-appended to preserve styles');
                                            
                                            // Reconnect observer after a short delay
                                            setTimeout(function() {
                                                try {
                                                    if ($form && $form.length && $form.parent().length) {
                                                        formObserver.observe($form.parent()[0], {
                                                            childList: true,
                                                            subtree: true
                                                        });
                                                    }
                                                } catch (e) {
                                                    debugWarn('Error reconnecting form observer:', e);
                                                }
                                            }, 100);
                                            
                                            return; // Exit early - form is already restored
                                        }
                                    } catch (e) {
                                        debugWarn('Error immediately re-appending form:', e);
                                    }
                                    
                                    // CRITICAL: Clone form with computed styles RIGHT BEFORE it's removed
                                    // This ensures we capture all HubSpot-applied styles
                                    if (formData.cloneFormWithComputedStyles && typeof formData.cloneFormWithComputedStyles === 'function') {
                                        try {
                                            formData.cloneFormWithComputedStyles();
                                        } catch (e) {
                                            debugWarn('Error cloning form before removal:', e);
                                        }
                                    }
                                    
                                    // Increment restore count and set flag
                                    formData.restoreCount = (formData.restoreCount || 0) + 1;
                                    formData.isRestoring = true;
                                    formData.lastRestoreTime = Date.now();
                                    
                                    debugWarn('Form was removed from DOM - attempting to restore (attempt ' + formData.restoreCount + ')');
                                    
                                    // CRITICAL: Temporarily disconnect observer to prevent loop
                                    try {
                                        formObserver.disconnect();
                                    } catch (e) {
                                        // Ignore
                                    }
                                    
                                    // CRITICAL: Store form's complete state before restoration
                                    const $formToRestore = formData.$form;
                                    const originalClasses = $formToRestore.attr('class') || '';
                                    const originalStyle = $formToRestore.attr('style') || '';
                                    const originalId = $formToRestore.attr('id') || '';
                                    const formHTML = formData.originalFormHTML || ($formToRestore[0] ? $formToRestore[0].outerHTML : null);
                                    
                                    // Try to restore form
                                    setTimeout(function() {
                                        try {
                                            let restored = false;
                                            let $restoredForm = null;
                                            
                                            // CRITICAL: Restore to exact same position to preserve styling
                                            if (formData.formParent && formData.formParent.appendChild) {
                                                // Restore to exact same position
                                                if (formData.formNextSibling && formData.formNextSibling.parentNode === formData.formParent) {
                                                    formData.formParent.insertBefore(node, formData.formNextSibling);
                                                } else {
                                                    formData.formParent.appendChild(node);
                                                }
                                                restored = true;
                                                $restoredForm = $(node);
                                                formData.$form = $restoredForm; // Update reference
                                                debugLog('Form restored to exact position in DOM');
                                            } else if (mutation.target && mutation.target.appendChild) {
                                                mutation.target.appendChild(node);
                                                restored = true;
                                                $restoredForm = $(node);
                                                formData.$form = $restoredForm; // Update reference
                                                debugLog('Form restored to DOM');
                                            } else if (formData.$form && formData.$form.length) {
                                                // Try to find form container and restore
                                                const $container = $form.closest('.form-holder, .form-outer, .form-div, body');
                                                if ($container && $container.length) {
                                                    $container.append(formData.$form);
                                                    restored = true;
                                                    $restoredForm = formData.$form;
                                                    debugLog('Form restored to container');
                                                }
                                            }
                                            
                                            if (restored && $restoredForm && $restoredForm.length) {
                                                // CRITICAL: If email input is active, we should NEVER have gotten here
                                                // But if we did, immediately re-create form using HubSpot API to restore styles
                                                if (formData.emailInputActive && formData.hubspotFormConfig && formData.hubspotFormConfig.formId && formData.hubspotFormConfig.portalId && typeof hbspt !== 'undefined' && hbspt.forms) {
                                                    debugWarn('CRITICAL: Form was removed during email input - re-creating via HubSpot API');
                                                    try {
                                                        const config = formData.hubspotFormConfig;
                                                        
                                                        // Store all current form values
                                                        const currentValues = {};
                                                        $restoredForm.find('input, select, textarea').each(function() {
                                                            const $field = $(this);
                                                            const fieldName = $field.attr('name') || $field.attr('id');
                                                            if (fieldName) {
                                                                const fieldType = $field.attr('type') || $field.prop('tagName').toLowerCase();
                                                                if (fieldType === 'checkbox' || fieldType === 'radio') {
                                                                    currentValues[fieldName] = $field.prop('checked');
                                                                } else {
                                                                    currentValues[fieldName] = $field.val();
                                                                }
                                                            }
                                                        });
                                                        
                                                        // Get target container
                                                        const $target = $restoredForm.closest('.form-holder, .form-outer, .form-div, #form1');
                                                        if ($target.length) {
                                                            $target.empty();
                                                            
                                                            // Re-create form immediately
                                                            hbspt.forms.create({
                                                                region: config.region || 'na1',
                                                                portalId: config.portalId,
                                                                formId: config.formId,
                                                                target: $target[0],
                                                                onFormReady: function($newForm, newCtx) {
                                                                    formData.$form = $newForm;
                                                                    formData.originalFormContext = newCtx;
                                                                    formData.isRestoring = false;
                                                                    
                                                                    // Restore values
                                                                    setTimeout(function() {
                                                                        Object.keys(currentValues).forEach(function(fieldName) {
                                                                            const $field = $newForm.find('[name="' + fieldName + '"], #' + fieldName);
                                                                            if ($field.length) {
                                                                                const value = currentValues[fieldName];
                                                                                const fieldType = $field.attr('type') || $field.prop('tagName').toLowerCase();
                                                                                if (fieldType === 'checkbox' || fieldType === 'radio') {
                                                                                    $field.prop('checked', value);
                                                                                } else {
                                                                                    $field.val(value);
                                                                                }
                                                                            }
                                                                        });
                                                                        // Re-initialize integration
                                                                        if (typeof agileEdIntegration !== 'undefined') {
                                                                            try {
                                                                                agileEdIntegration.initForm($newForm, newCtx);
                                                                            } catch (e) {
                                                                                debugWarn('Error re-initializing:', e);
                                                                            }
                                                                        }
                                                                    }, 500);
                                                                }
                                                            });
                                                            debugLog('Form re-created via HubSpot API during email input');
                                                            return; // Exit early
                                                        }
                                                    } catch (e) {
                                                        debugWarn('Error re-creating form during email input:', e);
                                                        // Fall through to normal restoration
                                                    }
                                                }
                                                
                                                // CRITICAL: If we have HubSpot config, re-create the form using HubSpot API
                                                // This ensures all styles are properly applied
                                                if (formData.hubspotFormConfig && formData.hubspotFormConfig.formId && formData.hubspotFormConfig.portalId && typeof hbspt !== 'undefined' && hbspt.forms) {
                                                    try {
                                                        const config = formData.hubspotFormConfig;
                                                        
                                                        // Store all current form values before re-creating
                                                        const currentValues = {};
                                                        $restoredForm.find('input, select, textarea').each(function() {
                                                            const $field = $(this);
                                                            const fieldName = $field.attr('name') || $field.attr('id');
                                                            if (fieldName) {
                                                                const fieldType = $field.attr('type') || $field.prop('tagName').toLowerCase();
                                                                if (fieldType === 'checkbox' || fieldType === 'radio') {
                                                                    currentValues[fieldName] = $field.prop('checked');
                                                                } else {
                                                                    currentValues[fieldName] = $field.val();
                                                                }
                                                            }
                                                        });
                                                        
                                                        // Get the target container
                                                        const $target = $restoredForm.closest('.form-holder, .form-outer, .form-div, #form1');
                                                        if ($target.length) {
                                                            // Clear the container
                                                            $target.empty();
                                                            
                                                            // Re-create the form using HubSpot API
                                                            debugLog('Re-creating form using HubSpot API to restore styles');
                                                            hbspt.forms.create({
                                                                region: config.region || 'na1',
                                                                portalId: config.portalId,
                                                                formId: config.formId,
                                                                target: $target[0],
                                                                onFormReady: function($newForm, newCtx) {
                                                                    debugLog('Form re-created by HubSpot API - styles should be restored');
                                                                    // Update formData reference
                                                                    formData.$form = $newForm;
                                                                    formData.originalFormContext = newCtx;
                                                                    formData.isRestoring = false;
                                                                    
                                                                    // Restore form values after a short delay to ensure form is ready
                                                                    setTimeout(function() {
                                                                        Object.keys(currentValues).forEach(function(fieldName) {
                                                                            const $field = $newForm.find('[name="' + fieldName + '"], #' + fieldName);
                                                                            if ($field.length) {
                                                                                const value = currentValues[fieldName];
                                                                                const fieldType = $field.attr('type') || $field.prop('tagName').toLowerCase();
                                                                                if (fieldType === 'checkbox' || fieldType === 'radio') {
                                                                                    $field.prop('checked', value);
                                                                                } else {
                                                                                    $field.val(value);
                                                                                }
                                                                            }
                                                                        });
                                                                        
                                                                        // Re-initialize our form integration
                                                                        // The page's onFormReady callback should handle this, but we'll trigger it manually
                                                                        if (typeof agileEdIntegration !== 'undefined') {
                                                                            try {
                                                                                agileEdIntegration.initForm($newForm, newCtx);
                                                                            } catch (e) {
                                                                                debugWarn('Error re-initializing form integration:', e);
                                                                            }
                                                                        }
                                                                    }, 500);
                                                                }
                                                            });
                                                            
                                                            // Reset restoration flag after a delay
                                                            setTimeout(function() {
                                                                formData.isRestoring = false;
                                                                // Reconnect observer
                                                                try {
                                                                    if ($form && $form.length && $form.parent().length) {
                                                                        formObserver.observe($form.parent()[0], {
                                                                            childList: true,
                                                                            subtree: true
                                                                        });
                                                                    }
                                                                } catch (e) {
                                                                    debugWarn('Error reconnecting form observer:', e);
                                                                }
                                                            }, 2000);
                                                            
                                                            return; // Exit early - form is being re-created
                                                        }
                                                    } catch (e) {
                                                        debugWarn('Error re-creating form with HubSpot API, falling back to HTML restoration:', e);
                                                    }
                                                }
                                                
                                                // CRITICAL: Restore form styling and trigger HubSpot to re-apply styles
                                                requestAnimationFrame(function() {
                                                    requestAnimationFrame(function() {
                                                        try {
                                                            // CRITICAL: If we have a cloned form with styles, use it instead
                                                            if (formData.formCloneWithStyles) {
                                                                try {
                                                                    const $parent = $restoredForm.parent();
                                                                    const $clonedForm = $(formData.formCloneWithStyles.cloneNode(true));
                                                                    
                                                                    // Restore form values from current form to cloned form
                                                                    $restoredForm.find('input, select, textarea').each(function() {
                                                                        const $currentField = $(this);
                                                                        const fieldName = $currentField.attr('name') || $currentField.attr('id');
                                                                        const fieldValue = $currentField.val();
                                                                        const fieldType = $currentField.attr('type') || $currentField.prop('tagName').toLowerCase();
                                                                        
                                                                        if (fieldName) {
                                                                            const $clonedField = $clonedForm.find('[name="' + fieldName + '"], #' + fieldName);
                                                                            if ($clonedField.length) {
                                                                                if (fieldType === 'checkbox' || fieldType === 'radio') {
                                                                                    $clonedField.prop('checked', $currentField.prop('checked'));
                                                                                } else {
                                                                                    $clonedField.val(fieldValue);
                                                                                }
                                                                            }
                                                                        }
                                                                    });
                                                                    
                                                                    // Replace current form with cloned form
                                                                    $restoredForm.replaceWith($clonedForm);
                                                                    $restoredForm = $clonedForm;
                                                                    formData.$form = $clonedForm;
                                                                    
                                                                    // CRITICAL: The cloned form already has all classes and attributes preserved
                                                                    // HubSpot's CSS will automatically apply based on classes
                                                                    // We just need to ensure HubSpot re-initializes the form
                                                                    debugLog('Form restored from clone with preserved HTML structure and classes');
                                                                } catch (e) {
                                                                    debugWarn('Error restoring from clone, falling back to HTML:', e);
                                                                }
                                                            }
                                                            
                                                            // Fallback: Restore original HTML structure to preserve all HubSpot styling
                                                            if (formHTML && $restoredForm[0] && formHTML !== $restoredForm[0].outerHTML && !formData.formCloneWithStyles) {
                                                                // Form structure changed - restore from original HTML
                                                                const $parent = $restoredForm.parent();
                                                                const $newForm = $(formHTML);
                                                                
                                                                // Preserve current form values
                                                                $restoredForm.find('input, select, textarea').each(function() {
                                                                    const $currentField = $(this);
                                                                    const fieldName = $currentField.attr('name') || $currentField.attr('id');
                                                                    const fieldValue = $currentField.val();
                                                                    const fieldType = $currentField.attr('type') || $currentField.prop('tagName').toLowerCase();
                                                                    
                                                                    if (fieldName) {
                                                                        const $newField = $newForm.find('[name="' + fieldName + '"], #' + fieldName);
                                                                        if ($newField.length) {
                                                                            if (fieldType === 'checkbox' || fieldType === 'radio') {
                                                                                $newField.prop('checked', $currentField.prop('checked'));
                                                                            } else {
                                                                                $newField.val(fieldValue);
                                                                            }
                                                                        }
                                                                    }
                                                                });
                                                                
                                                                $restoredForm.replaceWith($newForm);
                                                                $restoredForm = $newForm;
                                                                formData.$form = $newForm;
                                                                debugLog('Form HTML structure restored from original');
                                                            }
                                                            
                                                            // Restore original classes, id, and styles
                                                            if (originalClasses) {
                                                                $restoredForm.attr('class', originalClasses);
                                                            }
                                                            if (originalId) {
                                                                $restoredForm.attr('id', originalId);
                                                            }
                                                            if (originalStyle) {
                                                                $restoredForm.attr('style', originalStyle);
                                                            }
                                                            
                                                            // Ensure form is visible with proper display
                                                            $restoredForm.show().css({
                                                                'display': 'block',
                                                                'visibility': 'visible',
                                                                'opacity': '1'
                                                            });
                                                            
                                                            // Re-apply form container styling
                                                            $restoredForm.closest('.form-holder, .form-outer, .form-div').css({
                                                                'overflow': 'visible',
                                                                'padding-bottom': '40px'
                                                            });
                                                            
                                            // NEW APPROACH: Re-apply inline styles immediately after restoration
                                            // This is much more reliable than trying to trigger HubSpot's re-initialization
                                            try {
                                                if ($restoredForm && $restoredForm[0] && $restoredForm[0].isConnected) {
                                                    const formElement = $restoredForm[0];
                                                    const computedStyle = window.getComputedStyle(formElement);
                                                    
                                                    // Apply critical CSS properties as inline styles with !important
                                                    const criticalStyles = {
                                                        'display': computedStyle.display,
                                                        'visibility': computedStyle.visibility,
                                                        'opacity': computedStyle.opacity,
                                                        'position': computedStyle.position,
                                                        'width': computedStyle.width,
                                                        'max-width': computedStyle.maxWidth,
                                                        'margin': computedStyle.margin,
                                                        'padding': computedStyle.padding,
                                                        'background': computedStyle.backgroundColor,
                                                        'border': computedStyle.border,
                                                        'border-radius': computedStyle.borderRadius,
                                                        'box-shadow': computedStyle.boxShadow
                                                    };
                                    
                                                    let inlineStyle = formData.originalFormStyle || '';
                                                    if (inlineStyle && !inlineStyle.endsWith(';')) {
                                                        inlineStyle += ';';
                                                    }
                                    
                                                    for (const prop in criticalStyles) {
                                                        const value = criticalStyles[prop];
                                                        if (value && value !== 'none' && value !== 'auto' && value !== 'normal') {
                                                            inlineStyle += prop.replace(/-([a-z])/g, (g) => g[1].toUpperCase()) + ': ' + value + ' !important; ';
                                                        }
                                                    }
                                    
                                                    formElement.setAttribute('style', inlineStyle);
                                                    formData.inlineStylesApplied = true;
                                                    
                                                    debugLog('Form styles re-applied as inline styles after restoration');
                                                }
                                            } catch (e) {
                                                debugWarn('Error re-applying inline styles after restoration:', e);
                                            }
                                            
                                            // CRITICAL: Force HubSpot to re-apply styles by re-initializing the form
                                            if ($restoredForm[0]) {
                                                // Method 1: Try to access HubSpot's form instance and refresh it
                                                try {
                                                    const formElement = $restoredForm[0];
                                                    if (formElement.hsFormInstance) {
                                                        const formInstance = formElement.hsFormInstance;
                                                        // Try to refresh the form instance
                                                        if (formInstance.refresh && typeof formInstance.refresh === 'function') {
                                                            formInstance.refresh();
                                                            debugLog('HubSpot form instance refreshed');
                                                        }
                                                        // Try to re-apply styles
                                                        if (formInstance.applyStyles && typeof formInstance.applyStyles === 'function') {
                                                            formInstance.applyStyles();
                                                            debugLog('HubSpot form styles re-applied');
                                                        }
                                                    }
                                                } catch (e) {
                                                    debugWarn('Error accessing HubSpot form instance:', e);
                                                }
                                                                
                                                                // Method 2: Trigger multiple events to ensure HubSpot re-applies styles
                                                                const events = ['hsFormReady', 'hsFormLoad', 'DOMContentLoaded', 'load'];
                                                                events.forEach(function(eventName) {
                                                                    try {
                                                                        const event = new Event(eventName, { bubbles: true, cancelable: true });
                                                                        $restoredForm[0].dispatchEvent(event);
                                                                    } catch (e) {
                                                                        // Ignore event errors
                                                                    }
                                                                });
                                                                
                                                                // Also trigger jQuery events that HubSpot might use
                                                                if (typeof $ !== 'undefined' && $.fn) {
                                                                    $restoredForm.trigger('hsFormReady');
                                                                    $restoredForm.trigger('hsFormLoad');
                                                                    $restoredForm.trigger('load');
                                                                }
                                                                
                                                                // Method 3: Try to re-create form using HubSpot API if we have the config
                                                                // This is a last resort - only if form config is available
                                                                if (formData.hubspotFormConfig && formData.hubspotFormConfig.formId && formData.hubspotFormConfig.portalId && typeof hbspt !== 'undefined' && hbspt.forms) {
                                                                    try {
                                                                        const config = formData.hubspotFormConfig;
                                                                        // Get the target element
                                                                        const target = $restoredForm.closest('.form-holder, .form-outer, .form-div, #form1');
                                                                        if (target.length) {
                                                                            // Store current form values before re-creating
                                                                            const currentValues = {};
                                                                            $restoredForm.find('input, select, textarea').each(function() {
                                                                                const $field = $(this);
                                                                                const fieldName = $field.attr('name') || $field.attr('id');
                                                                                if (fieldName) {
                                                                                    const fieldType = $field.attr('type') || $field.prop('tagName').toLowerCase();
                                                                                    if (fieldType === 'checkbox' || fieldType === 'radio') {
                                                                                        currentValues[fieldName] = $field.prop('checked');
                                                                                    } else {
                                                                                        currentValues[fieldName] = $field.val();
                                                                                    }
                                                                                }
                                                                            });
                                                                            
                                                                            // Clear the target first
                                                                            target.empty();
                                                                            // Re-create the form
                                                                            hbspt.forms.create({
                                                                                region: config.region || 'na1',
                                                                                portalId: config.portalId,
                                                                                formId: config.formId,
                                                                                target: target[0],
                                                                                onFormReady: function($newForm, newCtx) {
                                                                                    // Re-initialize our integration
                                                                                    debugLog('Form re-created by HubSpot API');
                                                                                    // Update formData reference
                                                                                    formData.$form = $newForm;
                                                                                    formData.originalFormContext = newCtx;
                                                                                    // Restore form values
                                                                                    setTimeout(function() {
                                                                                        Object.keys(currentValues).forEach(function(fieldName) {
                                                                                            const $field = $newForm.find('[name="' + fieldName + '"], #' + fieldName);
                                                                                            if ($field.length) {
                                                                                                const value = currentValues[fieldName];
                                                                                                const fieldType = $field.attr('type') || $field.prop('tagName').toLowerCase();
                                                                                                if (fieldType === 'checkbox' || fieldType === 'radio') {
                                                                                                    $field.prop('checked', value);
                                                                                                } else {
                                                                                                    $field.val(value);
                                                                                                }
                                                                                            }
                                                                                        });
                                                                                    }, 500);
                                                                                    // Re-initialize our form integration
                                                                                    // Note: This will be called by the page's onFormReady callback
                                                                                }
                                                                            });
                                                                            debugLog('Attempting to re-create form using HubSpot API');
                                                                            return; // Exit early - form is being re-created
                                                                        }
                                                                    } catch (e) {
                                                                        debugWarn('Error re-creating form with HubSpot API:', e);
                                                                    }
                                                                }
                                                                
                                                                // Method 4: Force style recalculation by temporarily hiding/showing
                                                                try {
                                                                    const formElement = $restoredForm[0];
                                                                    const originalDisplay = formElement.style.display;
                                                                    formElement.style.display = 'none';
                                                                    // Force reflow
                                                                    void formElement.offsetHeight;
                                                                    formElement.style.display = originalDisplay || '';
                                                                    debugLog('Form display toggled to force style recalculation');
                                                                } catch (e) {
                                                                    debugWarn('Error toggling form display:', e);
                                                                }
                                                            }
                                                            
                                                            debugLog('Form styling restoration completed');
                                                            
                                                            // Reset restoration flag after a delay
                                                            setTimeout(function() {
                                                                formData.isRestoring = false;
                                                                // Reconnect observer after restoration completes
                                                                try {
                                                                    if ($form && $form.length && $form.parent().length) {
                                                                        formObserver.observe($form.parent()[0], {
                                                                            childList: true,
                                                                            subtree: true
                                                                        });
                                                                    }
                                                                } catch (e) {
                                                                    debugWarn('Error reconnecting form observer:', e);
                                                                }
                                                            }, 2000); // Wait 2 seconds before allowing another restoration
                                                        } catch (e) {
                                                            debugWarn('Error restoring form styling:', e);
                                                            // Reset flag even on error
                                                            setTimeout(function() {
                                                                formData.isRestoring = false;
                                                            }, 1000);
                                                        }
                                                    });
                                                });
                                            } else {
                                                // Reset flag if restoration failed
                                                formData.isRestoring = false;
                                            }
                                        } catch (e) {
                                            debugWarn('Error restoring form:', e);
                                            // Reset flag even on error
                                            formData.isRestoring = false;
                                        }
                                    }, 100);
                                }
                            }
                        });
                    }
                });
            });
            
            // Observe the form's parent for removals
            if ($form && $form.length && $form.parent().length) {
                formObserver.observe($form.parent()[0], {
                    childList: true,
                    subtree: true
                });
                // Store observer in formData for cleanup
                formData.formObserver = formObserver;
            }
        } catch (e) {
            debugWarn('Error setting up form MutationObserver:', e);
        }
        
        // Store form instance data
        if (!window.SecurlyForm.instances) {
            window.SecurlyForm.instances = new Map();
        }
        window.SecurlyForm.instances.set(formInstanceId, formData);
        
        // Set form reference for institution widget
        this.institutionWidget.setForm($form);
        
        // Store form context for HubSpot API access
        if (ctx) {
            this.institutionWidget.formContext = ctx;
        }
        
        // CRITICAL: Wrap populateHubSpotForm to check emailInputActive flag BEFORE any DOM manipulation
        // This must be done BEFORE initEmailField and initCompanyField so they can use the wrapped version
        const originalPopulateHubSpotForm = this.institutionWidget.populateHubSpotForm.bind(this.institutionWidget);
        const self = this; // Store reference to this for use in closure
        this.institutionWidget.populateHubSpotForm = function(institution) {
            // Check if email input is active in THIS form's formData
            const isEmailInputActive = formData && formData.emailInputActive;
            if (isEmailInputActive) {
                debugLog('Email input active - deferring populateHubSpotForm to prevent DOM conflicts (known email protection)');
                
                // CRITICAL: Clone form with styles before storing pending population
                // This ensures we have a perfect copy if HubSpot removes the form during known email editing
                if (formData && formData.cloneFormWithComputedStyles && typeof formData.cloneFormWithComputedStyles === 'function') {
                    try {
                        formData.cloneFormWithComputedStyles();
                        debugLog('Form cloned with styles before deferring population (known email)');
                    } catch (e) {
                        debugWarn('Error cloning form before deferring population:', e);
                    }
                }
                
                // Store for later population
                if (formData) {
                    formData.pendingFormPopulation = institution;
                }
                // Return a resolved promise that does nothing to prevent errors
                return Promise.resolve(null);
            }
            
            // Email input is not active - proceed with normal population
            // Wrap in try-catch to prevent any errors from breaking the form
            try {
                const result = originalPopulateHubSpotForm(institution);
                // If it returns a promise, catch any errors and re-inject CSS after completion
                if (result && typeof result.then === 'function') {
                    return result.then(function() {
                        // CRITICAL: Re-inject CSS after form population completes to prevent CSS loss
                        // HubSpot's form population can manipulate DOM and break CSS
                        if (formData && formData.injectHubSpotFormCSS && typeof formData.injectHubSpotFormCSS === 'function') {
                            formData.injectHubSpotFormCSS();
                            // #region agent log
                            debugInstrument('agile-ed-form-integration.js:3391', 'CSS re-injected after populateHubSpotForm (wrapped, immediate)', {hasFormData:!!formData}, 'CSS9');
                            // #endregion
                            
                            // Also re-inject after multiple delays to catch any delayed DOM manipulation
                            setTimeout(function() {
                                if (formData && formData.injectHubSpotFormCSS && typeof formData.injectHubSpotFormCSS === 'function') {
                                    formData.injectHubSpotFormCSS();
                                    // #region agent log
                                    debugInstrument('agile-ed-form-integration.js:3398', 'CSS re-injected after 200ms delay (wrapped)', {}, 'CSS9');
                                    // #endregion
                                }
                            }, 200);
                            
                            // Additional delayed re-injection to catch very delayed DOM manipulation
                            setTimeout(function() {
                                if (formData && formData.injectHubSpotFormCSS && typeof formData.injectHubSpotFormCSS === 'function') {
                                    formData.injectHubSpotFormCSS();
                                    // #region agent log
                                    debugInstrument('agile-ed-form-integration.js:3406', 'CSS re-injected after 500ms delay (wrapped)', {}, 'CSS9');
                                    // #endregion
                                }
                            }, 500);
                            
                            // Final delayed re-injection to catch extremely delayed DOM manipulation
                            setTimeout(function() {
                                if (formData && formData.injectHubSpotFormCSS && typeof formData.injectHubSpotFormCSS === 'function') {
                                    formData.injectHubSpotFormCSS();
                                    // #region agent log
                                    debugInstrument('agile-ed-form-integration.js:3414', 'CSS re-injected after 1000ms delay (wrapped)', {}, 'CSS9');
                                    // #endregion
                                }
                            }, 1000);
                        }
                    }).catch(error => {
                        // Suppress DOM manipulation errors silently
                        const errorMessage = error && error.message ? String(error.message) : '';
                        const errorName = error && error.name ? String(error.name) : '';
                        if (errorMessage.includes('insertBefore') || 
                            errorMessage.includes('removeChild') || 
                            errorMessage.includes('appendChild') ||
                            errorMessage.includes('NotFoundError') ||
                            errorName === 'NotFoundError') {
                            // Silently suppress - these are HubSpot timing issues
                            return null;
                        }
                        debugWarn('Error in populateHubSpotForm:', error);
                        return null; // Return null instead of throwing
                    });
                } else {
                    // Not a promise - re-inject CSS immediately
                    if (formData && formData.injectHubSpotFormCSS && typeof formData.injectHubSpotFormCSS === 'function') {
                        formData.injectHubSpotFormCSS();
                        // #region agent log
                        debugInstrument('agile-ed-form-integration.js:3420', 'CSS re-injected after populateHubSpotForm (sync)', {hasFormData:!!formData}, 'CSS9');
                        // #endregion
                    }
                }
                return result;
            } catch (error) {
                // Suppress DOM manipulation errors silently
                const errorMessage = error && error.message ? String(error.message) : '';
                const errorName = error && error.name ? String(error.name) : '';
                if (errorMessage.includes('insertBefore') || 
                    errorMessage.includes('removeChild') || 
                    errorMessage.includes('appendChild') ||
                    errorMessage.includes('NotFoundError') ||
                    errorName === 'NotFoundError') {
                    // Silently suppress - these are HubSpot timing issues
                    return Promise.resolve(null);
                }
                debugWarn('Error in populateHubSpotForm:', error);
                return Promise.resolve(null); // Return resolved promise instead of throwing
            }
        };
        
        // If institution was selected before form loaded, populate now
        if (window.SecurlyForm && window.SecurlyForm.pendingInstitutionData) {
            this.institutionWidget.populateHubSpotForm(window.SecurlyForm.pendingInstitutionData);
            window.SecurlyForm.pendingInstitutionData = null;
        }
        
        // Initialize email field integration (pass formData for isolation)
        this.initEmailField($form, formData);
        
        // Initialize company/school field integration (pass formData for isolation)
        this.initCompanyField($form, formData);
        
        // CRITICAL: Reset emailInputActive flag when form is submitted to allow submission
        // This prevents the flag from blocking form submission after API results
        $form.on('submit', function(e) {
            if (formData) {
                debugLog('Form submit event - resetting emailInputActive flag');
                formData.emailInputActive = false;
                
                // Stop continuous restore loop
                if (formData.continuousRestoreAnimationFrame) {
                    cancelAnimationFrame(formData.continuousRestoreAnimationFrame);
                    formData.continuousRestoreAnimationFrame = null;
                }
                
                // Stop CSS monitoring
                if (formData.stopCssMonitoring && typeof formData.stopCssMonitoring === 'function') {
                    formData.stopCssMonitoring();
                }
                
                // Clear email input reset timeout
                if (formData.emailInputResetTimeout) {
                    clearTimeout(formData.emailInputResetTimeout);
                    formData.emailInputResetTimeout = null;
                }
                
                // Unblock searches
                formData.blockAllSearches = false;
            }
        });
        
        // CRITICAL: Also reset flag when submit button is clicked (before form submit event)
        // This ensures the flag is reset even if form validation fails
        const submitButtons = $form.find('button[type="submit"], input[type="submit"], .hs-button, [class*="button"]');
        submitButtons.on('click', function(e) {
            if (formData) {
                debugLog('Submit button clicked - resetting emailInputActive flag');
                formData.emailInputActive = false;
                
                // Stop continuous restore loop
                if (formData.continuousRestoreAnimationFrame) {
                    cancelAnimationFrame(formData.continuousRestoreAnimationFrame);
                    formData.continuousRestoreAnimationFrame = null;
                }
                
                // Stop CSS monitoring
                if (formData.stopCssMonitoring && typeof formData.stopCssMonitoring === 'function') {
                    formData.stopCssMonitoring();
                }
                
                // Clear email input reset timeout
                if (formData.emailInputResetTimeout) {
                    clearTimeout(formData.emailInputResetTimeout);
                    formData.emailInputResetTimeout = null;
                }
                
                // Unblock searches
                formData.blockAllSearches = false;
            }
        });
    }
    
    /**
     * Initialize email field with autocomplete and search
     * @param {jQuery} $form - jQuery form element
     * @param {Object} formData - Form instance data for isolation
     */
    initEmailField($form, formData) {
        const self = this;
        const agileEdAPI = this.agileEdAPI;
        const institutionWidget = this.institutionWidget;
        
        // Find email field
        let emailField = null;
        for (const selector of this.emailSelectors) {
            emailField = $form.find(selector).first();
            if (emailField.length) {
                break;
            }
        }
        
        if (!emailField || !emailField.length) {
            return;
        }
        
        // Disable browser validation
        this.disableBrowserValidation(emailField, $form);
        
        // Hide "Did you mean" messages
        this.hideDidYouMeanMessages(emailField, $form);
        
        // Local state for this email field instance
        const activeTimeouts = [];
        const clearAllTimeouts = () => {
            activeTimeouts.forEach(id => clearTimeout(id));
            activeTimeouts.length = 0;
        };
        
        let emailSearchTimeout;
        let lastApiCallTime = 0;
        const MIN_API_CALL_INTERVAL = 1000;
        let isSearching = false;
        let lastSearchedEmail = null;
        let emailSearchSucceeded = false;
        let searchTriggeredFromInput = false;
        let currentRequestAbortController = null;
        
        // Store abort controller and lastSearchedEmail in formData so other handlers can access them
        if (formData) {
            formData.currentRequestAbortController = currentRequestAbortController;
            formData.lastSearchedEmail = lastSearchedEmail; // Store in formData for scope access
        }
        
        // Get email label reference
        const emailLabel = emailField.closest('.hs-form-field').find('label').first();
        let originalLabelHTML = '';
        if (emailLabel.length) {
            originalLabelHTML = emailLabel[0].outerHTML;
        }
        
        const emailFieldId = emailField.attr('id');
        let associatedLabel = emailLabel;
        if (emailFieldId && !associatedLabel.length) {
            associatedLabel = $form.find(`label[for="${emailFieldId}"]`);
            if (associatedLabel.length && !originalLabelHTML) {
                originalLabelHTML = associatedLabel[0].outerHTML;
            }
        }
        
        // Function to restore label
        const restoreLabel = function () {
            if (associatedLabel.length && originalLabelHTML) {
                associatedLabel.html(originalLabelHTML);
            } else if (associatedLabel.length) {
                const $original = $(originalLabelHTML || '<div>' + associatedLabel[0].outerHTML + '</div>');
                const originalText = $original.text().replace(/\s*\(searching\.\.\.\)\s*/g, '').trim();
                const originalRequired = $original.find('.hs-form-required, [class*="required"]').first();
                if (originalRequired.length) {
                    associatedLabel.html(originalText + ' ' + originalRequired[0].outerHTML);
                } else {
                    associatedLabel.text(originalText);
                }
            }
        };
        
        // Function to trigger email search
        const triggerEmailSearch = function (emailValue, skipDuplicateCheck = false) {
            // CRITICAL: Check if email input is active before triggering any API calls
            // This prevents Personnel API from running while user is editing email extension
            const isEmailInputActive = formData && formData.emailInputActive;
            if (isEmailInputActive) {
                debugLog('Email input active - skipping triggerEmailSearch to prevent DOM conflicts');
                return Promise.resolve(null);
            }
            
            if (!emailValue || !emailValue.includes('@') || !emailValue.includes('.')) {
                return Promise.resolve(null);
            }
            
            const normalizedEmail = emailValue.toLowerCase().trim();
            // CRITICAL: Use formData.lastSearchedEmail for consistency across scopes
            const previousSearchedEmail = formData && formData.lastSearchedEmail ? formData.lastSearchedEmail : lastSearchedEmail;
            if (!skipDuplicateCheck && previousSearchedEmail === normalizedEmail) {
                return Promise.resolve(null);
            }
            
            if (emailSearchTimeout) {
                clearTimeout(emailSearchTimeout);
                const index = activeTimeouts.indexOf(emailSearchTimeout);
                if (index > -1) activeTimeouts.splice(index, 1);
            }
            
            return new Promise(async (resolve, reject) => {
                if (emailSearchTimeout) {
                    const index = activeTimeouts.indexOf(emailSearchTimeout);
                    if (index > -1) activeTimeouts.splice(index, 1);
                    emailSearchTimeout = null;
                }
                
                const timeSinceLastCall = Date.now() - lastApiCallTime;
                if (timeSinceLastCall < MIN_API_CALL_INTERVAL) {
                    const waitTime = MIN_API_CALL_INTERVAL - timeSinceLastCall;
                    await new Promise(resolve => setTimeout(resolve, waitTime));
                }
                
                if (isSearching) {
                    isSearching = false;
                }
                
                lastApiCallTime = Date.now();
                lastSearchedEmail = normalizedEmail;
                // Also update formData to keep it in sync
                if (formData) {
                    formData.lastSearchedEmail = normalizedEmail;
                }
                searchTriggeredFromInput = false;
                isSearching = true;
                
                try {
                    // Removed label modification during search - keep label unchanged
                    
                    if (typeof window !== 'undefined') {
                        if (!window.SecurlyForm) {
                            window.SecurlyForm = {};
                        }
                        window.SecurlyForm.lastSearchedEmail = emailValue;
                    }
                    
                    const sanitizeEmail = (email) => {
                        if (!email || typeof email !== 'string') return '';
                        return email.replace(/[<>\"']/g, '').trim();
                    };
                    const sanitizedEmail = sanitizeEmail(emailValue);
                    
                    if (currentRequestAbortController) {
                        currentRequestAbortController.abort();
                    }
                    currentRequestAbortController = new AbortController();
                    
                    // Update formData reference
                    if (formData) {
                        formData.currentRequestAbortController = currentRequestAbortController;
                    }
                    
                    let results;
                    
                    try {
                        const timeoutPromise = new Promise((_, reject) => {
                            const timeoutId = setTimeout(() => {
                                reject(new Error('API request timeout (35 seconds)'));
                            }, 35000);
                            activeTimeouts.push(timeoutId);
                        });
                        
                        let personnelData;
                        try {
                            const personnelPromise = agileEdAPI.getPersonnelByEmail(sanitizedEmail);
                            personnelData = await Promise.race([personnelPromise, timeoutPromise]);
                        } catch (personnelError) {
                            const isSubscriptionError = personnelError.message && 
                                                      (personnelError.message.includes('SUBSCRIPTION') || 
                                                       personnelError.isSubscriptionError ||
                                                       personnelError.name === 'SubscriptionError');
                            
                            if (isSubscriptionError) {
                                // Subscription error - handle gracefully
                            } else {
                                if (personnelError.message.includes('500') || personnelError.message.includes('Server error')) {
                                    if (associatedLabel.length) {
                                        const $original = $(originalLabelHTML);
                                        const originalText = $original.text().replace(/\s*\(searching\.\.\.\)\s*/g, '').trim();
                                        const originalRequired = $original.find('.hs-form-required, [class*="required"]').first();
                                        let labelHTML = originalText;
                                        if (originalRequired.length) {
                                            labelHTML += ' ' + originalRequired[0].outerHTML;
                                        }
                                        labelHTML += ' <span style="color: #dc3545; font-weight: bold; font-size: 0.9em; display: inline-block; margin-left: 8px; padding: 2px 6px; background: #f8d7da; border-radius: 3px;">? Server Error - Check Console</span>';
                                        associatedLabel.html(labelHTML);
                                    }
                                }
                            }
                            personnelData = null;
                        }
                        
                        let personnel = null;
                        if (Array.isArray(personnelData) && personnelData.length > 0) {
                            personnel = personnelData[0];
                        } else if (personnelData && typeof personnelData === 'object' && !Array.isArray(personnelData)) {
                            personnel = personnelData;
                        } else {
                            emailSearchSucceeded = false;
                            // Fix: Use form-specific flag
                            if (formData) {
                                formData.emailSearchSucceeded = false;
                            }
                            results = null;
                        }
                        
                        if (personnel && (personnel.instUid || personnel.InstUid)) {
                            const personnelInstUid = personnel.instUid || personnel.InstUid;
                            const institutionType = 'K12';
                            const instUidForApi = parseInt(personnelInstUid) || personnelInstUid;
                            
                            try {
                                
                                debugLog('Calling Building API for email search:', {
                                    instUid: instUidForApi,
                                    personnelInstUid: personnelInstUid
                                });
                                
                                const institutionPromise = agileEdAPI.getBuildingInDistrict(instUidForApi);
                                const institutionData = await Promise.race([institutionPromise, timeoutPromise]);
                                
                                debugLog('Building API response for email search:', {
                                    instUid: instUidForApi,
                                    hasData: !!institutionData,
                                    isArray: Array.isArray(institutionData),
                                    dataType: typeof institutionData,
                                    dataLength: Array.isArray(institutionData) ? institutionData.length : 'N/A',
                                    isNull: institutionData === null,
                                    isUndefined: institutionData === undefined,
                                    isEmptyObject: institutionData && typeof institutionData === 'object' && !Array.isArray(institutionData) && Object.keys(institutionData).length === 0,
                                    hasKeys: institutionData && typeof institutionData === 'object' ? Object.keys(institutionData).slice(0, 5) : 'N/A',
                                    fullResponse: institutionData
                                });
                                
                                // Check if we have valid data (not null, not undefined, not empty object)
                                const hasValidData = institutionData !== null && 
                                                    institutionData !== undefined && 
                                                    !(typeof institutionData === 'object' && !Array.isArray(institutionData) && Object.keys(institutionData).length === 0);
                                
                                if (hasValidData) {
                                    let buildingData = null;
                                    let districtData = null;
                                    
                                    if (Array.isArray(institutionData)) {
                                        if (institutionData.length === 0) {
                                            results = {
                                                instUid: personnelInstUid,
                                                personnelUid: personnel.personnelUid || personnel.PersonnelUid || personnel.personnel_uid,
                                                personnelTitle: personnel.title || personnel.Title || personnel.jobTitle || personnel.job_title || personnel.position || personnel.Position || '',
                                                personnelFirstName: personnel.firstName || personnel.FirstName || personnel.first_name || '',
                                                personnelLastName: personnel.lastName || personnel.LastName || personnel.last_name || '',
                                                personnelDirectPhone: personnel.directPhone || personnel.DirectPhone || '',
                                                personnelFileType: personnel.fileType || personnel.FileType || '',
                                                personnelFileTypeText: personnel.fileTypeText || personnel.FileTypeText || ''
                                            };
                                        } else {
                                            const matchingBuilding = institutionData.find(b => 
                                                (b.instUid && b.instUid.toString() === instUidForApi.toString()) ||
                                                (b.uid && b.uid.toString() === instUidForApi.toString())
                                            );
                                            
                                            if (matchingBuilding) {
                                                buildingData = matchingBuilding;
                                            }
                                            
                                            districtData = institutionData.find(b => 
                                                b.parentUid && b.instUid && b.parentUid.toString() === b.instUid.toString()
                                            ) || institutionData[0];
                                            
                                            const finalData = buildingData || districtData;
                                            
                                            if (!finalData) {
                                                if (personnel) {
                                                    results = {
                                                        instUid: personnelInstUid,
                                                        personnelUid: personnel.personnelUid || personnel.PersonnelUid || personnel.personnel_uid,
                                                        personnelTitle: personnel.title || personnel.Title || personnel.jobTitle || personnel.job_title || personnel.position || personnel.Position || '',
                                                        personnelFirstName: personnel.firstName || personnel.FirstName || personnel.first_name || '',
                                                        personnelLastName: personnel.lastName || personnel.LastName || personnel.last_name || '',
                                                        personnelDirectPhone: personnel.directPhone || personnel.DirectPhone || '',
                                                        personnelFileType: personnel.fileType || personnel.FileType || '',
                                                        personnelFileTypeText: personnel.fileTypeText || personnel.FileTypeText || ''
                                                    };
                                                } else {
                                                    results = null;
                                                }
                                                return;
                                            }
                                            
                                            const districtStudents = (finalData && finalData.districtStudents) || (districtData && districtData.districtStudents) || null;
                                            const buildingStudents = (finalData && finalData.buildingStudents) || null;
                                            
                                            // Infer country from state if not provided
                                            const stateValue = (finalData && finalData.mailingState) || (districtData && districtData.mailingState) || (finalData && finalData.state) || (districtData && districtData.state) || null;
                                            let countryValue = (finalData && finalData.mailingCountry) || (districtData && districtData.mailingCountry) || (finalData && finalData.country) || (districtData && districtData.country) || null;
                                            
                                            // If no country but we have a US state, set country to US
                                            if (!countryValue && stateValue) {
                                                const usStates = ['AL', 'AK', 'AZ', 'AR', 'CA', 'CO', 'CT', 'DE', 'FL', 'GA', 'HI', 'ID', 'IL', 'IN', 'IA', 'KS', 'KY', 'LA', 'ME', 'MD', 'MA', 'MI', 'MN', 'MS', 'MO', 'MT', 'NE', 'NV', 'NH', 'NJ', 'NM', 'NY', 'NC', 'ND', 'OH', 'OK', 'OR', 'PA', 'RI', 'SC', 'SD', 'TN', 'TX', 'UT', 'VT', 'VA', 'WA', 'WV', 'WI', 'WY', 'DC'];
                                                if (usStates.includes(stateValue.toUpperCase())) {
                                                    countryValue = 'United States';
                                                }
                                            }
                                            
                                            const combinedData = {
                                                ...(finalData || {}),
                                                districtStudents: districtStudents,
                                                buildingStudents: buildingStudents,
                                                buildingType: (finalData && finalData.buildingType) || (districtData && districtData.buildingType) || null,
                                                mailingState: (finalData && finalData.mailingState) || (districtData && districtData.mailingState) || null,
                                                state: (finalData && finalData.state) || (districtData && districtData.state) || (finalData && finalData.mailingState) || (districtData && districtData.mailingState) || null,
                                                mailingCityProper: (finalData && finalData.mailingCityProper) || (districtData && districtData.mailingCityProper) || null,
                                                institutionNameProper: (finalData && finalData.institutionNameProper) || (districtData && districtData.institutionNameProper) || null,
                                                phone: (finalData && finalData.phone) || (districtData && districtData.phone) || null,
                                                mailingCountry: countryValue || (finalData && finalData.mailingCountry) || (districtData && districtData.mailingCountry) || null,
                                                country: countryValue || (finalData && finalData.country) || (districtData && districtData.country) || null,
                                                personnelUid: personnel.personnelUid || personnel.PersonnelUid || personnel.personnel_uid,
                                                personnelTitle: personnel.title || personnel.Title || personnel.jobTitle || personnel.job_title || personnel.position || personnel.Position || '',
                                                personnelFirstName: personnel.firstName || personnel.FirstName || personnel.first_name || '',
                                                personnelLastName: personnel.lastName || personnel.LastName || personnel.last_name || '',
                                                personnelDirectPhone: personnel.directPhone || personnel.DirectPhone || '',
                                                personnelFileType: personnel.fileType || personnel.FileType || '',
                                                personnelFileTypeText: personnel.fileTypeText || personnel.FileTypeText || '',
                                                instUid: personnel.instUid || personnel.InstUid || (finalData && finalData.instUid) || null
                                            };
                                            
                                            debugLog('Building API data combined for email search:', {
                                                institutionName: combinedData.institutionNameProper,
                                                state: combinedData.mailingState || combinedData.state,
                                                country: combinedData.mailingCountry || combinedData.country,
                                                city: combinedData.mailingCityProper,
                                                hasPersonnelData: !!(combinedData.personnelFirstName || combinedData.personnelLastName)
                                            });
                                            
                                            results = combinedData;
                                        }
                                    } else {
                                        buildingData = institutionData;
                                        
                                        // Infer country from state if not provided
                                        const stateValue = buildingData.mailingState || buildingData.state || null;
                                        let countryValue = buildingData.mailingCountry || buildingData.country || null;
                                        
                                        // If no country but we have a US state, set country to US
                                        if (!countryValue && stateValue) {
                                            const usStates = ['AL', 'AK', 'AZ', 'AR', 'CA', 'CO', 'CT', 'DE', 'FL', 'GA', 'HI', 'ID', 'IL', 'IN', 'IA', 'KS', 'KY', 'LA', 'ME', 'MD', 'MA', 'MI', 'MN', 'MS', 'MO', 'MT', 'NE', 'NV', 'NH', 'NJ', 'NM', 'NY', 'NC', 'ND', 'OH', 'OK', 'OR', 'PA', 'RI', 'SC', 'SD', 'TN', 'TX', 'UT', 'VT', 'VA', 'WA', 'WV', 'WI', 'WY', 'DC'];
                                            if (usStates.includes(stateValue.toUpperCase())) {
                                                countryValue = 'United States';
                                            }
                                        }
                                        
                                        const combinedData = {
                                            ...buildingData,
                                            districtStudents: buildingData.districtStudents || null,
                                            buildingStudents: buildingData.buildingStudents || null,
                                            buildingType: buildingData.buildingType || null,
                                            mailingState: buildingData.mailingState || null,
                                            state: buildingData.state || buildingData.mailingState || null,
                                            mailingCityProper: buildingData.mailingCityProper || null,
                                            institutionNameProper: buildingData.institutionNameProper || null,
                                            phone: buildingData.phone || null,
                                            mailingCountry: countryValue || buildingData.mailingCountry || null,
                                            country: countryValue || buildingData.country || null,
                                            personnelUid: personnel.personnelUid || personnel.PersonnelUid || personnel.personnel_uid,
                                            personnelTitle: personnel.title || personnel.Title || personnel.jobTitle || personnel.job_title || personnel.position || personnel.Position || '',
                                            personnelFirstName: personnel.firstName || personnel.FirstName || personnel.first_name || '',
                                            personnelLastName: personnel.lastName || personnel.LastName || personnel.last_name || '',
                                            personnelDirectPhone: personnel.directPhone || personnel.DirectPhone || '',
                                            personnelFileType: personnel.fileType || personnel.FileType || '',
                                            personnelFileTypeText: personnel.fileTypeText || personnel.FileTypeText || '',
                                            instUid: personnel.instUid || personnel.InstUid || (buildingData && buildingData.instUid) || null
                                        };
                                        
                                        debugLog('Building API data combined (non-array) for email search:', {
                                                institutionName: combinedData.institutionNameProper,
                                                state: combinedData.mailingState || combinedData.state,
                                                country: combinedData.mailingCountry || combinedData.country,
                                                city: combinedData.mailingCityProper,
                                                hasPersonnelData: !!(combinedData.personnelFirstName || combinedData.personnelLastName)
                                            });
                                        
                                        results = combinedData;
                                    }
                                    
                                    // CRITICAL: For known emails, also perform domain search to get all schools for the dropdown
                                    // This allows users to see and select from all schools in the domain/district
                                    try {
                                        const emailDomain = sanitizedEmail.split('@')[1];
                                        if (emailDomain && emailDomain.length >= 4 && emailDomain.includes('.')) {
                                            const domainParts = emailDomain.split('.');
                                            if (domainParts.length >= 2 && domainParts[0].length >= 1 && domainParts[domainParts.length - 1].length >= 2) {
                                                debugLog('Calling domain search for known email to populate school dropdown:', emailDomain);
                                                const domainSearchResults = await agileEdAPI.searchByDomain(emailDomain);
                                                
                                                // Store domain search results in formData for school dropdown
                                                if (formData && domainSearchResults && Array.isArray(domainSearchResults) && domainSearchResults.length > 0) {
                                                    formData.domainSearchResults = domainSearchResults;
                                                    formData.domainSearchEmail = sanitizedEmail;
                                                    debugLog('Domain search results stored for school dropdown:', {
                                                        domain: emailDomain,
                                                        resultsCount: domainSearchResults.length,
                                                        storedInFormData: true
                                                    });
                                                } else {
                                                    debugLog('Domain search returned no results or invalid data:', {
                                                        domain: emailDomain,
                                                        hasResults: !!domainSearchResults,
                                                        isArray: Array.isArray(domainSearchResults),
                                                        resultsCount: Array.isArray(domainSearchResults) ? domainSearchResults.length : 'N/A'
                                                    });
                                                }
                                            }
                                        }
                                    } catch (domainError) {
                                        debugWarn('Domain search failed for known email (non-critical - form will still populate):', domainError);
                                        // Don't throw - this is not critical, form population will still work
                                    }
                                    
                                    const cacheKey = `email:${sanitizedEmail.toLowerCase()}`;
                                    self.addToCache(cacheKey, {
                                        data: results,
                                        timestamp: Date.now()
                                    });
                                } else {
                                    // Building API returned null/undefined/empty - try domain search as fallback
                                    debugWarn('Building API returned null/undefined/empty for email search, trying domain search fallback:', {
                                        instUid: instUidForApi,
                                        personnelInstUid: personnelInstUid,
                                        email: sanitizedEmail,
                                        responseType: typeof institutionData,
                                        responseValue: institutionData
                                    });
                                    
                                    // Try to get institution data from domain search as fallback
                                    let domainSearchResults = null;
                                    try {
                                        const emailDomain = sanitizedEmail.split('@')[1];
                                        if (emailDomain && emailDomain.length >= 4 && emailDomain.includes('.')) {
                                            const domainParts = emailDomain.split('.');
                                            if (domainParts.length >= 2 && domainParts[0].length >= 1 && domainParts[domainParts.length - 1].length >= 2) {
                                                debugLog('Calling domain search as fallback for email search:', emailDomain);
                                                domainSearchResults = await agileEdAPI.searchByDomain(emailDomain);
                                                
                                    // Store domain search results in formData immediately so checkAndMarkSchool can access them
                                    if (formData && domainSearchResults && Array.isArray(domainSearchResults) && domainSearchResults.length > 0) {
                                        formData.domainSearchResults = domainSearchResults;
                                        formData.domainSearchEmail = sanitizedEmail;
                                        // Also store the merged results (with country/state) when available
                                        // This will be set later when results object is created
                                    }
                                                
                                                debugLog('Domain search fallback response:', {
                                                    domain: emailDomain,
                                                    hasResults: !!domainSearchResults,
                                                    isArray: Array.isArray(domainSearchResults),
                                                    resultsCount: Array.isArray(domainSearchResults) ? domainSearchResults.length : 'N/A',
                                                    storedInFormData: !!(formData && formData.domainSearchResults)
                                                });
                                            }
                                        }
                                    } catch (domainError) {
                                        logError('Domain search fallback failed:', domainError);
                                    }
                                    
                                    // Use domain search results if available, otherwise use personnel data only
                                    if (domainSearchResults && Array.isArray(domainSearchResults) && domainSearchResults.length > 0) {
                                        // Use first result from domain search and merge with personnel data
                                        const domainInstitution = domainSearchResults[0];
                                        
                                        // CRITICAL: If domain search result doesn't have country/state, try to get them from Building API
                                        // Domain search might not return full details, so we need to fetch them separately
                                        const domainInstUid = domainInstitution.instUid || domainInstitution.uid || personnelInstUid;
                                        const hasCountry = !!(domainInstitution.mailingCountry || domainInstitution.country);
                                        const hasState = !!(domainInstitution.mailingState || domainInstitution.state);
                                        
                                        // Infer country from state if state is a US state code
                                        const stateValue = domainInstitution.mailingState || domainInstitution.state;
                                        if (!hasCountry && stateValue) {
                                            const usStates = ['AL', 'AK', 'AZ', 'AR', 'CA', 'CO', 'CT', 'DE', 'FL', 'GA', 'HI', 'ID', 'IL', 'IN', 'IA', 'KS', 'KY', 'LA', 'ME', 'MD', 'MA', 'MI', 'MN', 'MS', 'MO', 'MT', 'NE', 'NV', 'NH', 'NJ', 'NM', 'NY', 'NC', 'ND', 'OH', 'OK', 'OR', 'PA', 'RI', 'SC', 'SD', 'TN', 'TX', 'UT', 'VT', 'VA', 'WA', 'WV', 'WI', 'WY', 'DC'];
                                            if (usStates.includes(stateValue.toUpperCase())) {
                                                domainInstitution.mailingCountry = 'United States';
                                                domainInstitution.country = 'United States';
                                                debugLog('Inferred country from US state code:', {
                                                    state: stateValue,
                                                    country: 'United States'
                                                });
                                            }
                                        }
                                        
                                        // If domain search doesn't have country/state, try Building API again with domain search's instUid
                                        if ((!hasCountry || !hasState) && domainInstUid) {
                                            try {
                                                debugLog('Domain search missing country/state - trying Building API with domain instUid:', domainInstUid);
                                                const buildingDataForCountryState = await agileEdAPI.getBuildingInDistrict(domainInstUid);
                                                
                                                if (buildingDataForCountryState) {
                                                    let buildingData = null;
                                                    if (Array.isArray(buildingDataForCountryState) && buildingDataForCountryState.length > 0) {
                                                        // Find matching building or use first item
                                                        buildingData = buildingDataForCountryState.find(b => 
                                                            (b.instUid && b.instUid.toString() === domainInstUid.toString()) ||
                                                            (b.uid && b.uid.toString() === domainInstUid.toString())
                                                        ) || buildingDataForCountryState[0];
                                                    } else if (buildingDataForCountryState && typeof buildingDataForCountryState === 'object') {
                                                        buildingData = buildingDataForCountryState;
                                                    }
                                                    
                                                    if (buildingData) {
                                                        // Merge country and state from Building API into domain institution
                                                        domainInstitution.mailingCountry = buildingData.mailingCountry || buildingData.country || domainInstitution.mailingCountry || domainInstitution.country;
                                                        domainInstitution.country = buildingData.country || buildingData.mailingCountry || domainInstitution.country || domainInstitution.mailingCountry;
                                                        domainInstitution.mailingState = buildingData.mailingState || buildingData.state || domainInstitution.mailingState || domainInstitution.state;
                                                        domainInstitution.state = buildingData.state || buildingData.mailingState || domainInstitution.state || domainInstitution.mailingState;
                                                        
                                                        // Also merge other useful fields
                                                        if (buildingData.phone) domainInstitution.phone = buildingData.phone;
                                                        if (buildingData.mailingCityProper) domainInstitution.mailingCityProper = buildingData.mailingCityProper;
                                                        if (buildingData.districtStudents) domainInstitution.districtStudents = buildingData.districtStudents;
                                                        if (buildingData.buildingStudents) domainInstitution.buildingStudents = buildingData.buildingStudents;
                                                        
                                                        debugLog('Successfully merged country/state from Building API:', {
                                                            country: domainInstitution.mailingCountry || domainInstitution.country,
                                                            state: domainInstitution.mailingState || domainInstitution.state
                                                        });
                                                    }
                                                }
                                            } catch (buildingError) {
                                                debugWarn('Failed to get country/state from Building API for domain search result:', buildingError);
                                            }
                                        }
                                        
                                        // Final check: Infer country from state if still missing (after Building API merge)
                                        const finalStateValue = domainInstitution.mailingState || domainInstitution.state;
                                        let finalCountryValue = domainInstitution.mailingCountry || domainInstitution.country;
                                        
                                        if (!finalCountryValue && finalStateValue) {
                                            const usStates = ['AL', 'AK', 'AZ', 'AR', 'CA', 'CO', 'CT', 'DE', 'FL', 'GA', 'HI', 'ID', 'IL', 'IN', 'IA', 'KS', 'KY', 'LA', 'ME', 'MD', 'MA', 'MI', 'MN', 'MS', 'MO', 'MT', 'NE', 'NV', 'NH', 'NJ', 'NM', 'NY', 'NC', 'ND', 'OH', 'OK', 'OR', 'PA', 'RI', 'SC', 'SD', 'TN', 'TX', 'UT', 'VT', 'VA', 'WA', 'WV', 'WI', 'WY', 'DC'];
                                            if (usStates.includes(finalStateValue.toUpperCase())) {
                                                finalCountryValue = 'United States';
                                                domainInstitution.mailingCountry = 'United States';
                                                domainInstitution.country = 'United States';
                                                debugLog('Final inference: Setting country to United States based on state:', finalStateValue);
                                            }
                                        }
                                        
                                        results = {
                                            ...domainInstitution,
                                            instUid: domainInstUid,
                                            personnelUid: personnel.personnelUid || personnel.PersonnelUid || personnel.personnel_uid,
                                            personnelTitle: personnel.title || personnel.Title || personnel.jobTitle || personnel.job_title || personnel.position || personnel.Position || '',
                                            personnelFirstName: personnel.firstName || personnel.FirstName || personnel.first_name || '',
                                            personnelLastName: personnel.lastName || personnel.LastName || personnel.last_name || '',
                                            personnelDirectPhone: personnel.directPhone || personnel.DirectPhone || '',
                                            fileType: personnel.fileType || personnel.FileType || '',
                                            fileTypeText: personnel.fileTypeText || personnel.FileTypeText || '',
                                            // Ensure country and state are explicitly set with proper fallbacks and inference
                                            mailingCountry: finalCountryValue || domainInstitution.mailingCountry || domainInstitution.country || null,
                                            country: finalCountryValue || domainInstitution.country || domainInstitution.mailingCountry || null,
                                            mailingState: finalStateValue || domainInstitution.mailingState || domainInstitution.state || null,
                                            state: finalStateValue || domainInstitution.state || domainInstitution.mailingState || null
                                        };
                                        
                                        debugLog('Using domain search results for email search (with country/state):', {
                                            institutionName: results.institutionNameProper || results.institutionName,
                                            state: results.mailingState || results.state,
                                            country: results.mailingCountry || results.country,
                                            hasCountry: !!(results.mailingCountry || results.country),
                                            hasState: !!(results.mailingState || results.state)
                                        });
                                        
                                        // CRITICAL: Store merged results (with country/state) in formData for later use
                                        // This ensures country/state are available when displaying domain results
                                        if (formData) {
                                            formData.mergedEmailResults = results;
                                            debugLog('Stored merged email results with country/state in formData', {
                                                country: results.mailingCountry || results.country,
                                                state: results.mailingState || results.state
                                            });
                                        }
                                    } else {
                                        // No domain search results - use personnel data only
                                        results = {
                                            instUid: personnel.instUid || personnel.InstUid,
                                            personnelUid: personnel.personnelUid || personnel.PersonnelUid || personnel.personnel_uid,
                                            personnelTitle: personnel.title || personnel.Title || personnel.jobTitle || personnel.job_title || personnel.position || personnel.Position || '',
                                            personnelFirstName: personnel.firstName || personnel.FirstName || personnel.first_name || '',
                                            personnelLastName: personnel.lastName || personnel.LastName || personnel.last_name || '',
                                            personnelDirectPhone: personnel.directPhone || personnel.DirectPhone || '',
                                            fileType: personnel.fileType || personnel.FileType || '',
                                            fileTypeText: personnel.fileTypeText || personnel.FileTypeText || ''
                                        };
                                    }
                                    
                                    const cacheKey = `email:${sanitizedEmail.toLowerCase()}`;
                                    self.addToCache(cacheKey, {
                                        data: results,
                                        timestamp: Date.now()
                                    });
                                }
                            } catch (institutionError) {
                                logError('Error calling Building API for email search:', {
                                        error: institutionError,
                                        instUid: instUidForApi,
                                        personnelInstUid: personnelInstUid,
                                        email: sanitizedEmail,
                                        errorMessage: institutionError.message,
                                        errorStack: institutionError.stack
                                    });
                                }
                                results = {
                                    instUid: personnelInstUid,
                                    personnelUid: personnel.personnelUid || personnel.PersonnelUid || personnel.personnel_uid,
                                    personnelTitle: personnel.title || personnel.Title || personnel.jobTitle || personnel.job_title || personnel.position || personnel.Position || '',
                                    personnelFirstName: personnel.firstName || personnel.FirstName || personnel.first_name || '',
                                    personnelLastName: personnel.lastName || personnel.LastName || personnel.last_name || '',
                                    personnelDirectPhone: personnel.directPhone || personnel.DirectPhone || '',
                                    fileType: personnel.fileType || personnel.FileType || '',
                                    fileTypeText: personnel.fileTypeText || personnel.FileTypeText || ''
                                };
                                
                                const cacheKey = `email:${sanitizedEmail.toLowerCase()}`;
                                self.addToCache(cacheKey, {
                                    data: results,
                                    timestamp: Date.now()
                                });
                            }
                        
                        if (results && typeof results === 'object') {
                            if (!results.instUid && !results.uid && !results.id) {
                                // Validation check
                            }
                        }
                    } catch (error) {
                        // CRITICAL: Never let API errors break form functionality
                        // Always handle errors gracefully to allow manual form filling
                        if (error.name === 'AbortError') {
                            return;
                        }
                        
                        // Log error but don't throw - allow form to work manually
                        // All API errors should be handled gracefully
                        restoreLabel();
                        resolve(null);
                        return;
                    } finally {
                        currentRequestAbortController = null;
                        // Update formData reference
                        if (formData) {
                            formData.currentRequestAbortController = null;
                        }
                    }
                    
                    if (typeof window !== 'undefined' && window.SecurlyForm) {
                        window.SecurlyForm.lastApiResponse = results;
                    }
                    
                    // CRITICAL: Check if email field has changed since API call started
                    // This prevents race conditions where user changes email while API is in progress
                    const currentEmailValue = emailField && emailField.length ? emailField.val().trim() : '';
                    const currentEmailNormalized = currentEmailValue.toLowerCase();
                    const apiCallEmailNormalized = sanitizedEmail.toLowerCase();
                    
                    if (currentEmailNormalized !== apiCallEmailNormalized) {
                        debugLog('Email field changed during API call - ignoring stale response', {
                            apiCallEmail: sanitizedEmail,
                            currentEmail: currentEmailValue,
                            apiCallEmailNormalized: apiCallEmailNormalized,
                            currentEmailNormalized: currentEmailNormalized
                        });
                        restoreLabel();
                        resolve(null);
                        return;
                    }
                    
                    if (results === null || results === undefined) {
                        emailSearchSucceeded = false;
                        // Fix: Use form-specific flag
                        if (formData) {
                            formData.emailSearchSucceeded = false;
                        }
                        
                        if (associatedLabel.length) {
                            const $original = $(originalLabelHTML);
                            const originalText = $original.text().replace(/\s*\(searching\.\.\.\)\s*/g, '').trim();
                            const originalRequired = $original.find('.hs-form-required, [class*="required"]').first();
                            let labelHTML = originalText;
                            if (originalRequired.length) {
                                labelHTML += ' ' + originalRequired[0].outerHTML;
                            }
                            labelHTML += ' <span style="color: #ff9800; font-weight: bold; font-size: 0.9em; display: inline-block; margin-left: 8px; padding: 2px 6px; background: #fff3cd; border-radius: 3px;">?? Not found - please fill manually</span>';
                            associatedLabel.html(labelHTML);
                            setTimeout(() => {
                                restoreLabel();
                            }, 10000);
                        }
                        
                        restoreLabel();
                        resolve(null);
                    } else if (Array.isArray(results)) {
                        if (results.length > 0) {
                            const institution = results[0];
                            
                            // CRITICAL: Check if email input is active before populating form
                            const isEmailInputActive = formData && formData.emailInputActive;
                            if (isEmailInputActive) {
                                debugLog('Email input active - deferring form population to prevent DOM conflicts');
                                // Store results to populate later when email input completes
                                if (formData) {
                                    formData.pendingFormPopulation = institution;
                                }
                                resolve(institution);
                                return;
                            }
                            
                            institutionWidget.populateHubSpotForm(institution);
                            
                            // Removed success indicator from label - keep label unchanged
                            resolve(institution);
                        } else {
                            restoreLabel();
                            resolve(null);
                        }
                    } else if (typeof results === 'object' && Object.keys(results).length > 0) {
                        emailSearchSucceeded = true;
                        // Fix: Use form-specific flag
                        if (formData) {
                            formData.emailSearchSucceeded = true;
                            
                            // CRITICAL: Immediately re-inject CSS when API succeeds
                            // This ensures CSS is intact before any subsequent email edits
                            if (formData.injectHubSpotFormCSS && typeof formData.injectHubSpotFormCSS === 'function') {
                                formData.injectHubSpotFormCSS();
                                // #region agent log
                                debugInstrument('agile-ed-form-integration.js:4328', 'CSS re-injected immediately after API success', {emailSearchSucceeded:true}, 'CSS10');
                                // #endregion
                                
                                // Also re-inject with delays to catch delayed DOM manipulation
                                setTimeout(function() {
                                    if (formData && formData.injectHubSpotFormCSS) {
                                        formData.injectHubSpotFormCSS();
                                        // #region agent log
                                        debugInstrument('agile-ed-form-integration.js:4335', 'CSS re-injected after 100ms (post-API success)', {}, 'CSS10');
                                        // #endregion
                                    }
                                }, 100);
                                
                                setTimeout(function() {
                                    if (formData && formData.injectHubSpotFormCSS) {
                                        formData.injectHubSpotFormCSS();
                                        // #region agent log
                                        debugInstrument('agile-ed-form-integration.js:4342', 'CSS re-injected after 300ms (post-API success)', {}, 'CSS10');
                                        // #endregion
                                    }
                                }, 300);
                                
                                setTimeout(function() {
                                    if (formData && formData.injectHubSpotFormCSS) {
                                        formData.injectHubSpotFormCSS();
                                        // #region agent log
                                        debugInstrument('agile-ed-form-integration.js:4349', 'CSS re-injected after 500ms (post-API success)', {}, 'CSS10');
                                        // #endregion
                                    }
                                }, 500);
                            }
                        }
                        
                        // CRITICAL: Check if email input is active before populating form
                        // This prevents DOM conflicts when user is editing email extension
                        const isEmailInputActive = formData && formData.emailInputActive;
                        if (isEmailInputActive) {
                            debugLog('Email input active - deferring form population to prevent DOM conflicts', {
                                hasResults: !!results,
                                hasCountry: !!(results && (results.mailingCountry || results.country)),
                                hasState: !!(results && (results.mailingState || results.state))
                            });
                            // Store results to populate later when email input completes
                            if (formData) {
                                formData.pendingFormPopulation = results;
                                debugLog('Stored pendingFormPopulation in formData', {
                                    hasPendingData: !!formData.pendingFormPopulation,
                                    pendingDataKeys: typeof formData.pendingFormPopulation === 'object' ? Object.keys(formData.pendingFormPopulation) : 'N/A'
                                });
                            }
                            resolve(results);
                            return;
                        }
                        
                        // CRITICAL: Double-check email hasn't changed before populating
                        // This is a second check in case email changed between first check and now
                        const currentEmailValue2 = emailField && emailField.length ? emailField.val().trim() : '';
                        const currentEmailNormalized2 = currentEmailValue2.toLowerCase();
                        if (currentEmailNormalized2 !== apiCallEmailNormalized) {
                            debugLog('Email field changed before form population - ignoring stale response', {
                                apiCallEmail: sanitizedEmail,
                                currentEmail: currentEmailValue2
                            });
                            restoreLabel();
                            resolve(null);
                            return;
                        }
                        
                        // Email input is NOT active - populate immediately
                        debugLog('Email input NOT active - populating form immediately', {
                            hasResults: !!results,
                            hasCountry: !!(results && (results.mailingCountry || results.country)),
                            hasState: !!(results && (results.mailingState || results.state)),
                            emailMatches: currentEmailNormalized2 === apiCallEmailNormalized
                        });
                        
                        // Populate form with results (country, state, etc.) but NOT the school field
                        // User must select school from dropdown
                        // Create a copy of results without the company field
                        const resultsWithoutCompany = { ...results };
                        delete resultsWithoutCompany.institutionNameProper;
                        delete resultsWithoutCompany.institutionName;
                        delete resultsWithoutCompany.company;
                        
                        debugLog('About to call populateHubSpotForm immediately', {
                            country: resultsWithoutCompany.mailingCountry || resultsWithoutCompany.country,
                            state: resultsWithoutCompany.mailingState || resultsWithoutCompany.state
                        });
                        
                        institutionWidget.populateHubSpotForm(resultsWithoutCompany).then(() => {
                            // CRITICAL: Re-inject CSS immediately after form population to prevent CSS loss
                            // HubSpot's form population can manipulate DOM and break CSS
                            if (formData && formData.injectHubSpotFormCSS && typeof formData.injectHubSpotFormCSS === 'function') {
                                formData.injectHubSpotFormCSS();
                                // #region agent log
                                debugInstrument('agile-ed-form-integration.js:4261', 'CSS re-injected after form population (immediate)', {hasFormData:!!formData}, 'CSS9');
                                // #endregion
                                
                                // Also re-inject after multiple delays to catch any delayed DOM manipulation
                                setTimeout(function() {
                                    if (formData && formData.injectHubSpotFormCSS && typeof formData.injectHubSpotFormCSS === 'function') {
                                        formData.injectHubSpotFormCSS();
                                        // #region agent log
                                        debugInstrument('agile-ed-form-integration.js:4268', 'CSS re-injected after 200ms delay', {}, 'CSS9');
                                        // #endregion
                                    }
                                }, 200);
                                
                                // Additional delayed re-injection to catch very delayed DOM manipulation
                                setTimeout(function() {
                                    if (formData && formData.injectHubSpotFormCSS && typeof formData.injectHubSpotFormCSS === 'function') {
                                        formData.injectHubSpotFormCSS();
                                        // #region agent log
                                        debugInstrument('agile-ed-form-integration.js:4276', 'CSS re-injected after 500ms delay', {}, 'CSS9');
                                        // #endregion
                                    }
                                }, 500);
                                
                                // Final delayed re-injection to catch extremely delayed DOM manipulation
                                setTimeout(function() {
                                    if (formData && formData.injectHubSpotFormCSS && typeof formData.injectHubSpotFormCSS === 'function') {
                                        formData.injectHubSpotFormCSS();
                                        // #region agent log
                                        debugInstrument('agile-ed-form-integration.js:4284', 'CSS re-injected after 1000ms delay', {}, 'CSS9');
                                        // #endregion
                                    }
                                }, 1000);
                            }
                            
                            // CRITICAL: Final check - verify email still matches before showing dropdown
                            const finalEmailCheck = emailField && emailField.length ? emailField.val().trim().toLowerCase() : '';
                            if (finalEmailCheck !== apiCallEmailNormalized) {
                                debugLog('Email field changed after form population - not showing school dropdown', {
                                    apiCallEmail: sanitizedEmail,
                                    currentEmail: emailField.val().trim()
                                });
                                return; // Don't show dropdown for stale data
                            }
                            debugLog('populateHubSpotForm completed - triggering school dropdown if domain results exist');
                            // After form population, trigger school dropdown if domain search results exist
                            if (formData && formData.domainSearchResults && Array.isArray(formData.domainSearchResults) && formData.domainSearchResults.length > 0) {
                                debugLog('Domain search results available - triggering school dropdown display', {
                                    resultsCount: formData.domainSearchResults.length,
                                    domainSearchEmail: formData.domainSearchEmail
                                });
                                formData.showDomainSearchResults = true;
                                
                                // Use multiple attempts with increasing delays to ensure dropdown shows
                                const triggerDropdown = function(attempt = 0) {
                                    let companyFieldForDropdown = null;
                                    for (const selector of self.companySelectors) {
                                        companyFieldForDropdown = $form.find(selector).first();
                                        if (companyFieldForDropdown.length) {
                                            break;
                                        }
                                    }
                                    
                                    if (companyFieldForDropdown && companyFieldForDropdown.length) {
                                        // IMPORTANT: Don't clear the field - keep the populated school name visible
                                        // Show dropdown with all domain results so user can see and select from list
                                        const currentValue = companyFieldForDropdown.val() || '';
                                        
                                        // Focus the field to ensure dropdown appears
                                        companyFieldForDropdown.focus();
                                        
                                        // Trigger input event to show school dropdown with domain results
                                        // The dropdown will show all domain results, allowing user to select a different school
                                        debugLog('Triggering dropdown to show all domain results (keeping populated value: "' + currentValue + '")');
                                        
                                        // Call searchDistricts directly with empty string to show ALL domain results
                                        // This bypasses the field value check and shows all schools from the domain
                                        if (typeof searchDistricts === 'function') {
                                            searchDistricts('');
                                        } else {
                                            companyFieldForDropdown.trigger('input');
                                        }
                                        
                                        // Check if dropdown appeared, if not try again
                                        if (attempt === 0) {
                                            setTimeout(() => {
                                                const $autocompleteContainer = $form.find('.institution-autocomplete');
                                                if (!$autocompleteContainer.is(':visible') && formData.domainSearchResults) {
                                                    debugLog('Dropdown not visible after trigger - retrying');
                                                    if (typeof searchDistricts === 'function') {
                                                        searchDistricts('');
                                                    } else {
                                                        companyFieldForDropdown.trigger('input');
                                                    }
                                                }
                                            }, 500);
                                        }
                                    } else if (attempt < 3) {
                                        // Retry if field not found (might be still loading)
                                        setTimeout(() => triggerDropdown(attempt + 1), 500);
                                    }
                                };
                                
                                // Initial trigger after form population
                                setTimeout(() => triggerDropdown(0), 500);
                                // Backup trigger in case first one doesn't work
                                setTimeout(() => triggerDropdown(1), 1500);
                            } else {
                                debugLog('No domain search results available - school dropdown will not be shown automatically', {
                                    hasFormData: !!formData,
                                    hasDomainResults: !!(formData && formData.domainSearchResults),
                                    isArray: formData && formData.domainSearchResults ? Array.isArray(formData.domainSearchResults) : false,
                                    resultsCount: formData && formData.domainSearchResults && Array.isArray(formData.domainSearchResults) ? formData.domainSearchResults.length : 0
                                });
                            }
                        }).catch(e => {
                            debugWarn('Error in immediate populateHubSpotForm:', e);
                        });
                        
                        // IMPORTANT: Don't clear the school field when email populates it
                        // Instead, keep the populated value AND show the dropdown so user can select from list
                        // The dropdown will show all schools from the domain, allowing user to change selection
                        
                        // Immediately check if school field was populated and mark it to prevent dropdown
                        // Check multiple times to catch async population
                        const checkAndMarkSchool = () => {
                            // Find company field using the same selectors
                            let companyField = null;
                            for (const selector of self.companySelectors) {
                                companyField = $form.find(selector).first();
                                if (companyField.length) {
                                    break;
                                }
                            }
                            
                            if (!companyField || !companyField.length) {
                                return false;
                            }
                            
                            const populatedSchoolName = companyField.val().trim();
                            // Don't check if populated - we want to show dropdown even if field is empty
                            if (false && populatedSchoolName && populatedSchoolName.length > 0) {
                                // School was populated from email search
                                // IMPORTANT: Don't hide the dropdown - we want to show all domain search results
                                // so the user can select a different school if needed
                                
                                // Get email domain if email field exists
                                if (emailField && emailField.length) {
                                    const emailValue = emailField.val().trim();
                                    if (emailValue && emailValue.includes('@')) {
                                        // Store in formData for access by initCompanyField
                                        if (formData) {
                                            formData.lastEmailDomainWhenSchoolSelected = emailValue.split('@')[1] || '';
                                            formData.lastSelectedSchoolName = populatedSchoolName;
                                            // Don't set schoolSelectedFromAutocomplete to true here - we want to show dropdown
                                            formData.schoolPopulatedFromEmail = true; // Mark that it was populated from email
                                        }
                                    }
                                }
                                
                                // Domain search results are already stored in formData above
                                // Now trigger showing the dropdown with all domain results
                                if (formData && formData.domainSearchResults && Array.isArray(formData.domainSearchResults) && formData.domainSearchResults.length > 0) {
                                    
                                    // Show all domain search results in dropdown after a short delay
                                    // to allow form population to complete
                                    setTimeout(() => {
                                        // Find autocomplete container and show all domain results
                                        const $autocompleteContainer = $form.find('.institution-autocomplete');
                                        if ($autocompleteContainer && $autocompleteContainer.length) {
                                            // Find company field
                                            let companyFieldForSearch = null;
                                            for (const selector of self.companySelectors) {
                                                companyFieldForSearch = $form.find(selector).first();
                                                if (companyFieldForSearch.length) {
                                                    break;
                                                }
                                            }
                                            
                                            if (companyFieldForSearch && companyFieldForSearch.length) {
                                                // Store a flag to indicate we want to show all domain results
                                                if (formData) {
                                                    formData.showDomainSearchResults = true;
                                                }
                                                // Call searchDistricts with empty string to show all domain results
                                                // This will use the stored domainSearchResults
                                                if (typeof searchDistricts === 'function') {
                                                    searchDistricts('');
                                                } else {
                                                    // If searchDistricts is not in scope, trigger input event
                                                    companyFieldForSearch.trigger('input');
                                                }
                                            }
                                        }
                                    }, 500); // Increased delay to ensure form is fully populated
                                }
                                
                                return true;
                            }
                            return false;
                        };
                        
                        // Check immediately
                        checkAndMarkSchool();
                        
                        // Also check after delays to catch async population
                        setTimeout(() => checkAndMarkSchool(), 100);
                        setTimeout(() => checkAndMarkSchool(), 300);
                        setTimeout(() => checkAndMarkSchool(), 600);
                        setTimeout(() => checkAndMarkSchool(), 1000);
                        
                        setTimeout(() => {
                            const jobtitleField = institutionWidget.$form.find('input[name="jobtitle"], textarea[name="jobtitle"], select[name="jobtitle"], [name="jobtitle"]');
                            if (jobtitleField.length) {
                                const jobtitleValue = jobtitleField.val();
                                if (jobtitleValue && jobtitleValue !== 'HIDDEN') {
                                    // Title populated successfully
                                } else {
                                    // Title not populated
                                }
                            } else {
                                // Job title field not found
                            }
                        }, 500);
                        
                        // Removed success indicator from label - keep label unchanged
                        resolve(results);
                    } else {
                        emailSearchSucceeded = false;
                        // Fix: Use form-specific flag
                        if (formData) {
                            formData.emailSearchSucceeded = false;
                        }
                        restoreLabel();
                        resolve(null);
                    }
                } catch (error) {
                    // CRITICAL: All API errors should be handled gracefully
                    // Never block form functionality - allow manual data entry
                    const errorMessage = error.message || error.toString() || '';
                    
                    // Handle rate limit errors
                    if (errorMessage.includes('limit exceeded') || errorMessage.includes('CALL LIMIT EXCEEDED')) {
                        if (associatedLabel.length) {
                            const $original = $(originalLabelHTML);
                            const originalText = $original.text().replace(/\s*\(searching\.\.\.\)\s*/g, '').trim();
                            const originalRequired = $original.find('.hs-form-required, [class*="required"]').first();
                            let labelHTML = originalText;
                            if (originalRequired.length) {
                                labelHTML += ' ' + originalRequired[0].outerHTML;
                            }
                            labelHTML += ' <span style="color: #ff9800; font-size: 0.9em;">(API limit reached - please fill manually)</span>';
                            associatedLabel.html(labelHTML);
                            setTimeout(() => {
                                restoreLabel();
                            }, 5000);
                        }
                        restoreLabel();
                        resolve(null);
                        return;
                    }
                    
                    // Handle subscription errors
                    if (errorMessage.includes('SUBSCRIPTION')) {
                        restoreLabel();
                        resolve(null);
                        return;
                    }
                    
                    // Handle timeout errors
                    if (errorMessage.includes('timed out') || errorMessage.includes('timeout')) {
                        restoreLabel();
                        resolve(null); // Don't reject - allow form to work manually
                        return;
                    }
                    
                    // Handle network errors
                    if (errorMessage.includes('Failed to fetch') || errorMessage.includes('Network error') || errorMessage.includes('fetch')) {
                        restoreLabel();
                        resolve(null); // Don't reject - allow form to work manually
                        return;
                    }
                    
                    // For all other errors, resolve with null instead of rejecting
                    // This ensures the form remains functional even if API fails
                    restoreLabel();
                    resolve(null);
                } finally {
                    isSearching = false;
                }
            });
        };
        
        // Event handlers
        const emailBlurHandler = function (e) {
            const relatedTarget = e.relatedTarget || document.activeElement;
            if (relatedTarget && ($(relatedTarget).closest('.email-autocomplete').length > 0 || $(relatedTarget).hasClass('email-autocomplete-item'))) {
                return;
            }
            
            if (window.SecurlyForm && window.SecurlyForm.schoolSelected) {
                window.SecurlyForm.schoolSelected = false;
                window.SecurlyForm.interactingWithAutocomplete = false;
                return;
            }
            
            const emailValue = $(this).val().trim();
            
            if (searchTriggeredFromInput) {
                searchTriggeredFromInput = false;
                return;
            }
            
            // CRITICAL: Check if domain change timeout is already scheduled
            // If so, don't trigger another API call - let the domain change handler do it
            if (formData && formData.domainChangeTimeout) {
                debugLog('Domain change timeout already scheduled - skipping blur-triggered API call');
                return;
            }
            
            // CRITICAL: Wait for emailInputActive flag to reset before triggering search
            // This ensures HubSpot has finished all DOM operations
            const waitForEmailInputComplete = function(attempt = 0) {
                if (window.SecurlyForm && window.SecurlyForm.schoolSelected) {
                    return;
                }
                
                // Check again if domain change timeout was scheduled during the wait
                if (formData && formData.domainChangeTimeout) {
                    debugLog('Domain change timeout scheduled during wait - skipping blur-triggered API call');
                    return;
                }
                
                const isEmailInputActive = formData && formData.emailInputActive;
                if (isEmailInputActive) {
                    // Still active - wait longer and check again
                    if (attempt < 10) { // Try up to 10 times (10 seconds max)
                        debugLog('Email input still active on blur - waiting... (attempt ' + (attempt + 1) + ')');
                        setTimeout(() => {
                            waitForEmailInputComplete(attempt + 1);
                        }, 1000);
                        return;
                    } else {
                        // Max attempts reached - proceed anyway
                        debugLog('Max wait time reached - proceeding with email search');
                    }
                }
                
                // Email input is complete - trigger search
                debugLog('Email input complete - triggering Personnel API search');
                triggerEmailSearch(emailValue);
            };
            
            // Start waiting after a short initial delay
            setTimeout(() => {
                waitForEmailInputComplete(0);
            }, 500);
        };
        
        emailField.on('blur', emailBlurHandler);
        
        const emailKeypressHandler = function (e) {
            if (e.key === 'Enter') {
                e.preventDefault();
                const emailValue = $(this).val().trim();
                
                if (!emailValue || !emailValue.includes('@') || !emailValue.includes('.')) {
                    return;
                }
                
                // CRITICAL: Check if domain change timeout is already scheduled
                // If so, clear it and trigger immediately since user pressed Enter
                if (formData && formData.domainChangeTimeout) {
                    debugLog('Domain change timeout scheduled - clearing and triggering API call immediately (Enter pressed)');
                    clearTimeout(formData.domainChangeTimeout);
                    formData.domainChangeTimeout = null;
                }
                
                // Wait for emailInputActive flag to reset before triggering search
                const waitForEmailInputComplete = function(attempt = 0) {
                    const isEmailInputActive = formData && formData.emailInputActive;
                    if (isEmailInputActive) {
                        // Still active - wait longer and check again
                        if (attempt < 10) { // Try up to 10 times (10 seconds max)
                            setTimeout(() => {
                                waitForEmailInputComplete(attempt + 1);
                            }, 1000);
                            return;
                        } else {
                            // Max attempts reached - proceed anyway
                            debugLog('Max wait time reached - proceeding with email search');
                        }
                    }
                    
                    // Email input is complete - trigger search
                    clearTimeout(emailSearchTimeout);
                    triggerEmailSearch(emailValue);
                };
                
                // Start waiting after a short initial delay
                setTimeout(() => {
                    waitForEmailInputComplete(0);
                }, 500);
            }
        };
        
        emailField.on('keypress', emailKeypressHandler);
        
        // Email field styling (no autocomplete - moved to School field)
        const $emailFieldContainer = emailField.closest('.hs-form-field');
        
        emailField.css({
            'width': '100%',
            'max-width': '100%',
            'box-sizing': 'border-box'
        });
        
        $emailFieldContainer.find('.input, .hs-input').css({
            'width': '100%',
            'max-width': '100%',
            'box-sizing': 'border-box'
        });
        
        // Email field only triggers search, no autocomplete (autocomplete moved to School field)
        
        // CRITICAL: Store triggerEmailSearch in formData so initCompanyField can call it when domain changes
        if (formData) {
            formData.triggerEmailSearch = triggerEmailSearch;
        }
        
        // Cleanup function
        const cleanup = function() {
            clearAllTimeouts();
            emailField.off('blur', emailBlurHandler);
            emailField.off('keypress', emailKeypressHandler);
            emailField.off('input');
            if (currentRequestAbortController) {
                currentRequestAbortController.abort();
            }
            // Also clear from formData
            if (formData && formData.currentRequestAbortController) {
                try {
                    formData.currentRequestAbortController.abort();
                } catch (e) {
                    // Ignore
                }
                formData.currentRequestAbortController = null;
            }
            // Clear domain change timeout if exists
            if (formData && formData.domainChangeTimeout) {
                clearTimeout(formData.domainChangeTimeout);
                formData.domainChangeTimeout = null;
            }
        };
        
        $(window).on('beforeunload', cleanup);
        
        if (typeof window !== 'undefined') {
            if (!window.SecurlyForm) {
                window.SecurlyForm = {};
            }
            window.SecurlyForm.cleanup = cleanup;
        }
    }
    
    /**
     * Initialize company/school field with autocomplete
     * @param {jQuery} $form - jQuery form element
     * @param {Object} formData - Form instance data for isolation
     */
    initCompanyField($form, formData) {
        const self = this;
        const agileEdAPI = this.agileEdAPI;
        const institutionWidget = this.institutionWidget;
        
        // Debug logging
        debugLog('initCompanyField called', {
            formId: $form.attr('id'),
            companySelectors: this.companySelectors
        });
        
        // Find company field
        let companyField = null;
        for (const selector of this.companySelectors) {
            companyField = $form.find(selector).first();
            if (companyField.length) {
                debugLog('Company field found with selector:', selector);
                break;
            }
        }
        
        if (!companyField || !companyField.length) {
            debugWarn('Company field not found! Selectors tried:', this.companySelectors);
            return;
        }
        
        let autocompleteTimeout;
        let positionTimeout; // Store position timeout for cleanup
        let autocompleteResults = [];
        let selectedIndex = -1;
        let schoolSelectedFromAutocomplete = false;
        let lastSelectedSchoolName = ''; // Track the last selected school name
        let lastEmailDomainWhenSchoolSelected = ''; // Track email domain when school was selected
        let emailInputActive = false; // Flag to prevent DOM manipulation during email input (prevents HubSpot conflicts)
        let districtSearchAbortController = null; // AbortController for canceling district search requests
        
        // Cache for API responses to prevent duplicate calls
        let apiCache = {
            domainSearch: new Map(), // Cache for domain searches
            stateSearch: new Map()   // Cache for state searches
        };
        // Increased cache duration to 15 minutes for better performance (school data doesn't change frequently)
        const CACHE_DURATION = 15 * 60 * 1000; // 15 minutes (increased from 5 minutes)
        const MAX_CACHE_SIZE = 100; // Limit cache size to prevent memory issues
        
        // Helper function to limit cache size (LRU - remove oldest entries)
        const limitCacheSize = function(cache, maxSize) {
            if (cache.size > maxSize) {
                // Remove oldest entries (first in Map)
                const entriesToRemove = cache.size - maxSize;
                let count = 0;
                for (const key of cache.keys()) {
                    if (count >= entriesToRemove) break;
                    cache.delete(key);
                    count++;
                }
            }
        };
        
        // Create autocomplete dropdown container with proper scrolling and visibility
        const $autocompleteContainer = $('<div class="institution-autocomplete" style="position: absolute; background: white; border: 1px solid #e0e0e0; border-radius: 6px; max-height: 300px !important; overflow-y: auto !important; overflow-x: hidden !important; z-index: 99999 !important; display: none; box-shadow: 0 4px 12px rgba(0,0,0,0.15); font-family: -apple-system, BlinkMacSystemFont, \'Segoe UI\', Roboto, Oxygen, Ubuntu, Cantarell, sans-serif; width: 100%; min-width: 300px; box-sizing: border-box; padding-top: 8px !important; padding-bottom: 16px !important; padding-right: 4px !important; -webkit-overflow-scrolling: touch !important; scroll-behavior: smooth !important;"></div>');
        
        // Helper function to safely get company field container
        const getCompanyFieldContainer = () => {
            try {
                // Re-find company field in case DOM changed
                let currentCompanyField = null;
                for (const selector of self.companySelectors) {
                    currentCompanyField = $form.find(selector).first();
                    if (currentCompanyField.length) {
                        break;
                    }
                }
                
                if (!currentCompanyField || !currentCompanyField.length) {
                    return null;
                }
                
                // Check if field is still in DOM (support iframes and shadow DOM)
                const fieldElement = currentCompanyField[0];
                if (!fieldElement) {
                    return null;
                }
                
                // Check if element is connected (works for iframes, shadow DOM, and regular DOM)
                if (!fieldElement.isConnected) {
                    // Element might be in an iframe - check ownerDocument
                    const ownerDoc = fieldElement.ownerDocument;
                    if (ownerDoc && ownerDoc !== document) {
                        // Element is in an iframe - this is OK, continue
                    } else {
                        // Element is not connected and not in iframe - skip
                        return null;
                    }
                }
                
                // Try multiple container selectors - HubSpot forms may use different structures
                // Try more specific selectors first, then more general ones
                let container = null;
                
                // Try .hs-form-field first (most common HubSpot structure)
                container = currentCompanyField.closest('.hs-form-field');
                if (container.length && (container[0].isConnected || document.body.contains(container[0]))) {
                    return container;
                }
                
                // Try .hs-fieldtype-text
                container = currentCompanyField.closest('.hs-fieldtype-text');
                if (container.length && (container[0].isConnected || document.body.contains(container[0]))) {
                    return container;
                }
                
                // Try .input wrapper
                container = currentCompanyField.closest('.input');
                if (container.length && (container[0].isConnected || document.body.contains(container[0]))) {
                    return container;
                }
                
                // Try .hs-input wrapper
                container = currentCompanyField.closest('.hs-input');
                if (container.length && (container[0].isConnected || document.body.contains(container[0]))) {
                    return container;
                }
                
                // Try finding parent with class containing 'field' or 'input'
                container = currentCompanyField.parent();
                while (container.length && container[0] && container[0] !== document.body) {
                    const className = container.attr('class') || '';
                    if (className.includes('field') || className.includes('input') || className.includes('form')) {
                        if (container[0].isConnected || document.body.contains(container[0])) {
                            return container;
                        }
                    }
                    container = container.parent();
                }
                
                // Final fallback: return the field's immediate parent
                const parent = currentCompanyField.parent();
                if (parent.length && (parent[0].isConnected || document.body.contains(parent[0]))) {
                    return parent;
                }
                
                return null;
            } catch (e) {
                return null;
            }
        };
        
        let $companyFieldContainer = getCompanyFieldContainer();
        
        // If container not found, use field's parent as fallback
        if (!$companyFieldContainer || !$companyFieldContainer.length) {
            debugWarn('Company field container not found with getCompanyFieldContainer, using parent as fallback');
            // Fallback: use the field's parent as container
            $companyFieldContainer = companyField.parent();
            debugLog('Fallback container check:', {
                containerExists: !!$companyFieldContainer,
                containerLength: $companyFieldContainer ? $companyFieldContainer.length : 0,
                containerElement: $companyFieldContainer ? $companyFieldContainer[0] : null,
                companyFieldElement: companyField[0]
            });
        }
        if (!$companyFieldContainer || !$companyFieldContainer.length) {
            logError('Company field container not found! Cannot attach autocomplete. Field exists but container missing.');
            return;
        }
        
        debugLog('Company field container found, proceeding with autocomplete setup', {
            containerElement: $companyFieldContainer[0],
            containerClass: $companyFieldContainer.attr('class'),
            containerLength: $companyFieldContainer.length
        });
        
        // Ensure parent container has relative positioning for absolute dropdown
        // Use try-catch to handle DOM changes
        try {
            if ($companyFieldContainer && $companyFieldContainer.length) {
                $companyFieldContainer.css({
                    'position': 'relative',
                    'overflow': 'visible',
                    'z-index': '1'
                });
                
                // Also ensure all parent containers have overflow: visible to prevent clipping
                $companyFieldContainer.parents('.hs-form-field, .hs-form, .hs-form-container, .form-div, .form-outer, .form-holder').css({
                    'overflow': 'visible',
                    'overflow-x': 'visible',
                    'overflow-y': 'visible'
                });
                
                // Also ensure all parent containers up to the form allow overflow (padding will be set dynamically)
                $companyFieldContainer.parents('.hs-form, .hs-form-container, .form-div, .form-outer, .form-holder').css({
                    'overflow': 'visible'
                });
            }
        } catch (e) {
            // DOM manipulation error - log but don't break
            logError('Error setting container styles:', e);
        }
        
        // Field container padding will be set dynamically based on dropdown height
        
        companyField.css({
            'width': '100%',
            'max-width': '100%',
            'box-sizing': 'border-box'
        });
        
        // Only apply styles if container exists
        if ($companyFieldContainer && $companyFieldContainer.length) {
            $companyFieldContainer.find('.input, .hs-input').css({
                'width': '100%',
                'max-width': '100%',
                'box-sizing': 'border-box'
            });
        }
        
        // Ensure window.SecurlyForm exists
        if (!window.SecurlyForm) {
            window.SecurlyForm = {};
        }
        
        // Append to field container (not body) for absolute positioning
        // Safely append with error handling to prevent DOM errors
        if ($autocompleteContainer.parent().length === 0) {
            try {
                // Re-get container in case DOM changed
                $companyFieldContainer = getCompanyFieldContainer();
                if (!$companyFieldContainer || !$companyFieldContainer.length) {
                    // Fallback: use company field's parent
                    $companyFieldContainer = companyField.parent();
                }
                // Check if container is valid and in DOM (support iframes with isConnected)
                const containerIsValid = $companyFieldContainer && 
                                       $companyFieldContainer.length && 
                                       $companyFieldContainer[0] &&
                                       ($companyFieldContainer[0].isConnected || document.body.contains($companyFieldContainer[0]));
                
                if (containerIsValid) {
                    // Detach from any previous parent first (safely handle removeChild errors)
                    if ($autocompleteContainer.parent().length) {
                        try {
                            const autocompleteElement = $autocompleteContainer[0];
                            const currentParent = $autocompleteContainer.parent()[0];
                            // Only detach if element is actually a child of the parent (prevents removeChild errors)
                            if (currentParent && autocompleteElement && currentParent.contains(autocompleteElement)) {
                                $autocompleteContainer.detach();
                            } else {
                                // Parent mismatch - element might already be removed, just clear jQuery reference
                                $autocompleteContainer = $('<div class="institution-autocomplete"></div>');
                                formData.autocompleteContainer = $autocompleteContainer;
                            }
                        } catch (detachError) {
                            // Ignore detach errors - element might already be removed, recreate container
                            debugWarn('Error detaching autocomplete container (recreating):', detachError);
                            $autocompleteContainer = $('<div class="institution-autocomplete"></div>');
                            formData.autocompleteContainer = $autocompleteContainer;
                        }
                    }
                    $companyFieldContainer.append($autocompleteContainer);
                    debugLog('Autocomplete container appended to DOM initially', {
                        parentElement: $companyFieldContainer[0],
                        containerInDOM: $autocompleteContainer[0] && ($autocompleteContainer[0].isConnected || document.body.contains($autocompleteContainer[0]))
                    });
                } else {
                    // Try one more time with a small delay in case DOM is still loading
                    setTimeout(() => {
                        $companyFieldContainer = getCompanyFieldContainer();
                        if (!$companyFieldContainer || !$companyFieldContainer.length) {
                            $companyFieldContainer = companyField.parent();
                        }
                        if ($companyFieldContainer && $companyFieldContainer.length && 
                            ($companyFieldContainer[0].isConnected || document.body.contains($companyFieldContainer[0]))) {
                            if ($autocompleteContainer.parent().length === 0) {
                                $companyFieldContainer.append($autocompleteContainer);
                                debugLog('Autocomplete container appended after delay');
                            }
                        }
                    }, 100);
                }
            } catch (e) {
                // DOM manipulation error - log and continue (form will still work)
                logError('Error appending autocomplete container:', e);
            }
        } else {
            debugLog('Autocomplete container already has parent:', {
                parentElement: $autocompleteContainer.parent()[0],
                containerInDOM: document.body.contains($autocompleteContainer[0])
            });
        }
        
        // Fix: Store reference per form instance, not globally
        formData.autocompleteContainer = $autocompleteContainer;
        
        // Function to dynamically update container padding based on dropdown height
        const updateContainerPadding = function() {
            try {
                // Re-get container in case DOM changed
                const currentContainer = getCompanyFieldContainer();
                if (!currentContainer || !currentContainer.length) {
                    return; // Container no longer exists
                }
                
                if (!$autocompleteContainer || !$autocompleteContainer.length || !$autocompleteContainer.is(':visible')) {
                    // Dropdown is hidden, remove extra padding - use minimal padding for form spacing
                    const minimalPadding = 20; // Minimal padding for form spacing when dropdown is hidden
                    currentContainer.css('padding-bottom', minimalPadding + 'px');
                    currentContainer.parents('.hs-form, .hs-form-container, .form-div, .form-outer, .form-holder').css('padding-bottom', minimalPadding + 'px');
                    return;
                }
                
                // Get actual dropdown height
                const dropdownHeight = $autocompleteContainer.outerHeight() || $autocompleteContainer.height() || 0;
                
                if (dropdownHeight > 0) {
                    // Calculate adaptive padding: dropdown height + small gap (no extra buffer)
                    // This prevents button overlap while minimizing empty space
                    const gap = 4; // Small gap between dropdown and next element
                    // Use exact dropdown height + gap - no extra buffer to prevent excessive spacing
                    const paddingValue = dropdownHeight + gap;
                    
                    // Apply padding to field container and parent containers
                    currentContainer.css('padding-bottom', paddingValue + 'px');
                    currentContainer.parents('.hs-form, .hs-form-container, .form-div, .form-outer, .form-holder').css('padding-bottom', paddingValue + 'px');
                } else {
                    // No height yet, use minimal padding
                    const minimalPadding = 20;
                    currentContainer.css('padding-bottom', minimalPadding + 'px');
                    currentContainer.parents('.hs-form, .hs-form-container, .form-div, .form-outer, .form-holder').css('padding-bottom', minimalPadding + 'px');
                }
            } catch (e) {
                // Error - log but don't break
                logError('Error updating container padding:', e);
            }
        };
        
        // Function to position dropdown below the field
        const positionDropdown = function() {
            if (!$autocompleteContainer || !$autocompleteContainer.length) {
                return;
            }
            
            try {
                // Ensure parent container has relative positioning (re-check in case DOM changed)
                if ($companyFieldContainer && $companyFieldContainer.length) {
                    $companyFieldContainer.css({
                        'position': 'relative',
                        'overflow': 'visible'
                    });
                }
                
                // Get field dimensions and position
                const fieldHeight = companyField.outerHeight() || companyField.height() || 40;
                const fieldWidth = companyField.outerWidth() || companyField.width() || 300;
                
                // Detect mobile device
                const isMobile = window.innerWidth <= 767;
                const isTablet = window.innerWidth > 767 && window.innerWidth <= 1024;
                
                // Calculate position: dropdown should be directly below the input field
                // Get the field's position relative to its container
                const fieldOffset = companyField.position(); // position() gives offset relative to parent
                const fieldTop = fieldOffset.top || 0;
                
                // Position dropdown directly below the field (fieldTop + fieldHeight)
                // Add small gap (4px) between field and dropdown
                const gap = 4;
                const topPosition = fieldTop + fieldHeight + gap;
                
                // Position absolutely relative to the field container (which has position: relative)
                // Top position: directly below the field
                // Left position: align with field (0 = same as field's left edge)
                $autocompleteContainer.css({
                    'position': 'absolute',
                    'top': topPosition + 'px',
                    'left': '0',
                    'width': fieldWidth + 'px',
                    'min-width': fieldWidth + 'px',
                    'max-width': fieldWidth + 'px',
                    'display': 'block',
                    'visibility': 'visible',
                    'z-index': '99999',
                    'opacity': '1',
                    'margin-top': '0', // Remove any margin
                    'margin-bottom': '0',
                    'padding-top': '8px' // Add small top padding to ensure first item is fully visible
                });
                
                // On mobile, ensure dropdown doesn't exceed viewport
                // Height is calculated in displayAutocompleteResults, but we need to respect viewport limits here
                if (isMobile) {
                    const viewportHeight = window.innerHeight;
                    const fieldTop = companyField.offset().top - $(window).scrollTop();
                    const mobileGap = 4; // Gap between field and dropdown
                    const availableSpace = viewportHeight - fieldTop - fieldHeight - mobileGap - 20; // 20px buffer
                    const maxHeight = Math.min(300, availableSpace); // Use 300px or available space, whichever is smaller
                    
                    if (maxHeight > 0) {
                        // Just update max-height to respect viewport, height is set in displayAutocompleteResults
                        const currentHeight = parseInt($autocompleteContainer.css('height')) || 300;
                        const adjustedHeight = Math.min(currentHeight, maxHeight);
                        $autocompleteContainer.css({
                            'max-height': maxHeight + 'px',
                            'height': 'auto', // Let content determine height, but cap at max-height
                            'overflow-y': 'auto' // Ensure scrolling works
                        });
                    }
                }
                // Desktop: Height is set dynamically in displayAutocompleteResults based on number of results
                // No need to set it here as it will be calculated when results are displayed
            } catch (e) {
                // Positioning error - continue anyway
            }
        };
        
        // Function to search for districts/schools
        let isDistrictSearching = false;
        let lastDistrictSearchTime = 0;
        let lastSearchedStateValue = null; // Track last searched state to allow immediate search if state changed
        const MIN_DISTRICT_SEARCH_INTERVAL = 2000; // 2 seconds between searches for same state
        const MIN_SEARCH_LENGTH = 2; // Minimum characters before making API calls
        const DEBOUNCE_DELAY = 700; // Wait 700ms after user stops typing (increased from 400ms to reduce API calls)
        
        // Find email field for domain search
        let emailField = null;
        for (const selector of self.emailSelectors) {
            emailField = $form.find(selector).first();
            if (emailField.length) {
                break;
            }
        }
        
        // Find state field for state-based search
        // Try multiple selectors to find state field - HubSpot forms may use different field names
        let stateField = $form.find('select[name="us_states"]').first();
        if (!stateField.length) {
            stateField = $form.find('select[name="ca_provinces"]').first();
        }
        if (!stateField.length) {
            stateField = $form.find('select[name="uk_regions"]').first();
        }
        // Also try finding by label text or other attributes
        if (!stateField.length) {
            stateField = $form.find('select').filter(function() {
                const label = $(this).closest('.hs-form-field').find('label').text().toLowerCase();
                return label.includes('state') || label.includes('province') || label.includes('region');
            }).first();
        }
        
        // Find country field for country-based filtering
        let countryField = $form.find('select[name="country__new_"]').first();
        if (!countryField.length) {
            countryField = $form.find('select').filter(function() {
                const label = $(this).closest('.hs-form-field').find('label').text().toLowerCase();
                return label.includes('country') || label.includes('district country');
            }).first();
        }
        
        // Track last selected country/state to detect changes
        let lastSelectedCountry = countryField.length ? countryField.val() : null;
        let lastSelectedState = stateField.length ? stateField.val() : null;
        
        // Handle country/state changes - trigger school search for new state
        const handleCountryStateChange = function() {
            // CRITICAL: Check if email input is active before handling changes
            const isEmailInputActive = formData && formData.emailInputActive;
            if (isEmailInputActive) {
                debugLog('Email input active - deferring country/state change handling');
                return;
            }
            
            const currentCountry = countryField.length ? countryField.val() : null;
            const currentState = stateField.length ? stateField.val() : null;
            
            // Check if country or state actually changed
            const countryChanged = currentCountry !== lastSelectedCountry;
            const stateChanged = currentState !== lastSelectedState;
            
            if (countryChanged || stateChanged) {
                debugLog('Country/State changed - clearing old school results and triggering new search', {
                    previousCountry: lastSelectedCountry,
                    currentCountry: currentCountry,
                    previousState: lastSelectedState,
                    currentState: currentState,
                    countryChanged: countryChanged,
                    stateChanged: stateChanged
                });
                
                // Clear old school results
                $autocompleteContainer.hide().empty();
                updateContainerPadding();
                
                // Clear cached state search results (state changed, so cache is invalid)
                if (stateChanged && apiCache.stateSearch) {
                    apiCache.stateSearch.clear();
                    debugLog('Cleared state search cache due to state change');
                }
                
                // Clear domain search results if country changed (different country = different domains)
                // Also clear for unknown emails to ensure state search works
                if (countryChanged && formData) {
                    formData.domainSearchResults = null;
                    formData.showDomainSearchResults = false;
                    formData.blockStateSearch = false; // Ensure state search is not blocked
                    debugLog('Cleared domain search results due to country change');
                }
                
                // For unknown emails, ensure domain search flags don't block state search
                if (formData) {
                    // If no domain results exist (unknown email), ensure state search can run
                    const hasDomainResults = formData.domainSearchResults && Array.isArray(formData.domainSearchResults) && formData.domainSearchResults.length > 0;
                    if (!hasDomainResults) {
                        formData.showDomainSearchResults = false;
                        formData.blockStateSearch = false;
                        debugLog('No domain results (unknown email) - ensuring state search can run');
                    }
                }
                
                // Reset school selection flags
                schoolSelectedFromAutocomplete = false;
                lastSelectedSchoolName = '';
                
                // Update tracked values
                lastSelectedCountry = currentCountry;
                lastSelectedState = currentState;
                
                // If state is selected and country is US, trigger school search for that state
                const isUSCountry = currentCountry === 'United States' || currentCountry === 'US' || currentCountry === 'USA';
                if (currentState && isUSCountry) {
                    debugLog('State selected - triggering school search for state:', currentState);
                    // Clear company field to show all schools for the state (only if field is empty or was populated from old state)
                    const currentSchoolValue = companyField.val().trim();
                    if (!currentSchoolValue || currentSchoolValue === lastSelectedSchoolName) {
                        companyField.val('');
                    }
                    // Trigger search with empty string to show all schools for the state
                    // This allows user to see all schools and then type to filter
                    // Use longer delay to ensure form is ready and flags are cleared
                    setTimeout(() => {
                        // Double-check flags are cleared before triggering search
                        if (formData) {
                            formData.showDomainSearchResults = false;
                            formData.blockStateSearch = false;
                        }
                        debugLog('Triggering state search for unknown email with country/state selected');
                        searchDistricts('');
                    }, 500); // Increased delay to ensure DOM and flags are ready
                } else if (!isUSCountry) {
                    debugLog('Country is not US - clearing school dropdown');
                    $autocompleteContainer.hide().empty();
                    updateContainerPadding();
                } else if (!currentState) {
                    // State was cleared - hide dropdown
                    debugLog('State cleared - hiding school dropdown');
                    $autocompleteContainer.hide().empty();
                    updateContainerPadding();
                }
            }
        };
        
        // Add change event listeners to country and state fields
        if (countryField.length) {
            countryField.on('change', function() {
                debugLog('Country field changed:', $(this).val());
                handleCountryStateChange();
            });
        }
        
        if (stateField.length) {
            stateField.on('change', function() {
                debugLog('State field changed:', $(this).val());
                handleCountryStateChange();
            });
        }
        
        const searchDistricts = async function(searchValue) {
            // CRITICAL: If email input is active OR HubSpot is manipulating DOM, skip ALL operations
            // This prevents insertBefore errors that cause the form to disappear
            // Check both local variable and formData flag
            const isEmailInputActive = emailInputActive || (formData && formData.emailInputActive);
            const isHubSpotManipulating = formData && formData.hubspotManipulating;
            const isBlockingAllSearches = formData && formData.blockAllSearches;
            if (isEmailInputActive || isHubSpotManipulating || isBlockingAllSearches) {
                debugLog('Skipping searchDistricts - email input active, HubSpot manipulating DOM, or searches blocked', {
                    emailInputActive: isEmailInputActive,
                    hubspotManipulating: isHubSpotManipulating,
                    blockAllSearches: isBlockingAllSearches
                });
                return; // Exit immediately, don't touch the DOM
            }
            
            // Normalize searchValue - use current field value if not provided
            const currentValue = companyField.val().trim();
            const wasCalledFromInput = searchValue !== undefined && searchValue !== null;
            
            if (!wasCalledFromInput || searchValue === '') {
                searchValue = currentValue;
            } else {
                searchValue = String(searchValue).trim();
            }
            
            // CRITICAL: If function was called from input handler (user is typing), check if school was selected
            // Only allow search if user is typing something different from the selected school
            if (wasCalledFromInput) {
                // CRITICAL: If field is cleared (empty), reset flags to allow dropdown to show when typing starts
                if (!searchValue || searchValue.length === 0) {
                    debugLog('School field cleared - resetting selection flags to allow dropdown when typing starts');
                    schoolSelectedFromAutocomplete = false;
                    lastSelectedSchoolName = '';
                }
                
                // User is actively typing - check if it matches the selected school
                if (schoolSelectedFromAutocomplete && searchValue === lastSelectedSchoolName) {
                    // User is typing the same school name that was selected - don't show dropdown
                    debugLog('searchDistricts: Blocked - school was selected and value matches');
                    $autocompleteContainer.hide().empty();
                    updateContainerPadding();
                    return;
                }
                
                // User is typing something different - reset flags and allow search
                if (schoolSelectedFromAutocomplete && searchValue !== lastSelectedSchoolName) {
                    debugLog('User typing different text - resetting selection flags');
                    schoolSelectedFromAutocomplete = false;
                    lastSelectedSchoolName = '';
                }
            } else {
                // Called from elsewhere (e.g., email field change, state change) - check if we should block
                // CRITICAL: If field is empty, don't block - allow dropdown to show
                if (currentValue && currentValue.length > 0 && schoolSelectedFromAutocomplete && currentValue === lastSelectedSchoolName) {
                    // School was selected and matches - don't show dropdown
                    debugLog('searchDistricts: Blocked - school was selected and value matches (non-input call)');
                    $autocompleteContainer.hide().empty();
                    updateContainerPadding();
                    return;
                }
                
                // If field is empty, reset flags to allow dropdown
                if (!currentValue || currentValue.length === 0) {
                    debugLog('School field empty (non-input call) - resetting selection flags');
                    schoolSelectedFromAutocomplete = false;
                    lastSelectedSchoolName = '';
                }
            }
            
            // Note: countryField and stateField are defined in outer scope
            // Re-find them if not available (handles cases where DOM might have changed)
            if (!countryField || !countryField.length) {
                countryField = $form.find('select[name="country__new_"]').first();
                if (!countryField.length) {
                    countryField = $form.find('select').filter(function() {
                        const label = $(this).closest('.hs-form-field').find('label').text().toLowerCase();
                        return label.includes('country') || label.includes('district country');
                    }).first();
                }
            }
            if (!stateField || !stateField.length) {
                stateField = $form.find('select[name="us_states"]').first();
                if (!stateField.length) {
                    stateField = $form.find('select[name="ca_provinces"]').first();
                }
                if (!stateField.length) {
                    stateField = $form.find('select[name="uk_regions"]').first();
                }
                if (!stateField.length) {
                    stateField = $form.find('select').filter(function() {
                        const label = $(this).closest('.hs-form-field').find('label').text().toLowerCase();
                        return label.includes('state') || label.includes('province') || label.includes('region');
                    }).first();
                }
            }
            
            // Standard practice: Only make API calls if:
            // 1. Email domain search is available (domain-based search doesn't need minimum length)
            // 2. OR user has typed at least MIN_SEARCH_LENGTH characters
            // 3. OR state is selected (state search can run even with fewer characters)
            // This prevents excessive API calls on every keystroke
            const hasEmailDomain = emailField && emailField.length && emailField.val().trim().includes('@');
            const hasMinimumLength = searchValue.length >= MIN_SEARCH_LENGTH;
            const hasStateSelected = stateField.length && stateField.val();
            
            // CRITICAL: Enforce minimum character requirement for API calls (unless state is selected)
            // This prevents API calls on single character input
            if (!hasEmailDomain && !hasMinimumLength && !hasStateSelected) {
                debugLog('searchDistricts: Skipping API call - minimum length not met and no state selected', {
                    searchValue: searchValue,
                    searchValueLength: searchValue.length,
                    MIN_SEARCH_LENGTH: MIN_SEARCH_LENGTH
                });
                // Hide dropdown if user is typing but hasn't met minimum length
                if (searchValue.length > 0) {
                    $autocompleteContainer.hide().empty();
                    updateContainerPadding();
                }
                return; // Exit early - don't make API call
            }
            
            // Debug logging
            debugLog('searchDistricts called:', {
                searchValue: searchValue,
                wasCalledFromInput: wasCalledFromInput,
                hasEmailDomain: hasEmailDomain,
                hasMinimumLength: hasMinimumLength,
                hasStateSelected: hasStateSelected,
                stateFieldLength: stateField.length,
                stateFieldValue: stateField.val(),
                stateFieldSelector: 'select[name="us_states"], select[name="ca_provinces"], select[name="uk_regions"]'
            });
            
            // Check if we should show domain search results (when field was populated from email)
            const shouldShowDomainResults = formData && formData.showDomainSearchResults && formData.domainSearchResults && Array.isArray(formData.domainSearchResults) && formData.domainSearchResults.length > 0;
            
            // If we should show domain results, filter them based on search value
            if (shouldShowDomainResults) {
                debugLog('Filtering domain search results based on user input:', {
                    totalDomainResults: formData.domainSearchResults.length,
                    searchValue: searchValue,
                    searchValueLength: searchValue ? searchValue.length : 0
                });
                
                // Filter domain results based on search value if user is typing
                let resultsToShow = formData.domainSearchResults;
                
                if (searchValue && searchValue.length > 0) {
                    // User is typing - filter results to match what they typed
                    const searchLower = searchValue.toLowerCase();
                    resultsToShow = formData.domainSearchResults.filter(result => {
                        const name = (result.institutionNameProper || result.institutionName || '').toLowerCase();
                        const city = (result.mailingCityProper || result.mailingCity || result.city || '').toLowerCase();
                        return name.includes(searchLower) || city.includes(searchLower);
                    });
                    debugLog('Filtered domain results based on search:', {
                        totalAvailable: formData.domainSearchResults.length,
                        resultsToShow: resultsToShow.length,
                        searchValue: searchValue
                    });
                } else {
                    // No search value - show all domain results
                    debugLog('No search value - showing all domain results:', {
                        totalAvailable: formData.domainSearchResults.length,
                        resultsToShow: resultsToShow.length
                    });
                }
                
                debugLog('Domain results to display:', {
                    totalAvailable: formData.domainSearchResults.length,
                    resultsToShow: resultsToShow.length,
                    filtered: searchValue && searchValue.length > 0
                });
                
                if (resultsToShow.length > 0) {
                    autocompleteResults = resultsToShow;
                    
                    // CRITICAL: Ensure displayAutocompleteResults is called and doesn't fail silently
                    try {
                        debugLog('Calling displayAutocompleteResults with domain results:', {
                            resultsCount: resultsToShow.length,
                            firstResult: resultsToShow[0] ? (resultsToShow[0].institutionNameProper || resultsToShow[0].institutionName || 'N/A') : 'N/A'
                        });
                        
                        // CRITICAL: Populate country and state from the merged results (pendingFormPopulation, mergedEmailResults, or domain results)
                        // This ensures country/state are populated even if deferred population didn't execute
                        // First, try to get country/state from pendingFormPopulation (merged results with country/state)
                        let countryValue = null;
                        let stateValue = null;
                        
                        if (formData && formData.pendingFormPopulation) {
                            const pendingData = formData.pendingFormPopulation;
                            countryValue = pendingData.mailingCountry || pendingData.country;
                            stateValue = pendingData.mailingState || pendingData.state;
                            debugLog('Using country/state from pendingFormPopulation:', {
                                country: countryValue,
                                state: stateValue
                            });
                        }
                        
                        // If not found in pendingFormPopulation, try mergedEmailResults
                        if ((!countryValue || !stateValue) && formData && formData.mergedEmailResults) {
                            const mergedData = formData.mergedEmailResults;
                            countryValue = countryValue || mergedData.mailingCountry || mergedData.country;
                            stateValue = stateValue || mergedData.mailingState || mergedData.state;
                            debugLog('Using country/state from mergedEmailResults:', {
                                country: countryValue,
                                state: stateValue
                            });
                        }
                        
                        // If still not found, try first domain search result
                        if ((!countryValue || !stateValue) && resultsToShow.length > 0 && resultsToShow[0]) {
                            const firstResult = resultsToShow[0];
                            countryValue = countryValue || firstResult.mailingCountry || firstResult.country;
                            stateValue = stateValue || firstResult.mailingState || firstResult.state;
                            debugLog('Using country/state from first domain search result:', {
                                country: countryValue,
                                state: stateValue
                            });
                        }
                        
                        if (countryValue || stateValue) {
                            debugLog('Populating country/state in form:', {
                                country: countryValue,
                                state: stateValue
                            });
                            
                            // Create data object for form population (without company field)
                            const domainDataForPopulation = {
                                mailingCountry: countryValue,
                                country: countryValue,
                                mailingState: stateValue,
                                state: stateValue
                            };
                            
                            // Populate form with country and state
                            setTimeout(() => {
                                try {
                                    debugLog('Calling populateHubSpotForm with country/state data');
                                    institutionWidget.populateHubSpotForm(domainDataForPopulation).then(() => {
                                        debugLog('populateHubSpotForm completed for country/state');
                                        // CRITICAL: Re-inject CSS immediately after form population to prevent CSS loss
                                        // HubSpot's form population can manipulate DOM and break CSS
                                        if (formData && formData.injectHubSpotFormCSS && typeof formData.injectHubSpotFormCSS === 'function') {
                                            formData.injectHubSpotFormCSS();
                                            // #region agent log
                                            debugInstrument('agile-ed-form-integration.js:5501', 'CSS re-injected after populateHubSpotForm (domain search, immediate)', {hasFormData:!!formData}, 'CSS9');
                                            // #endregion
                                            
                                            // Also re-inject after multiple delays to catch any delayed DOM manipulation
                                            setTimeout(() => {
                                                if (formData && formData.injectHubSpotFormCSS) {
                                                    formData.injectHubSpotFormCSS();
                                                    // #region agent log
                                                    debugInstrument('agile-ed-form-integration.js:5508', 'CSS re-injected after 200ms (domain search)', {}, 'CSS9');
                                                    // #endregion
                                                }
                                            }, 200);
                                            
                                            // Additional delayed re-injection to catch very delayed DOM manipulation
                                            setTimeout(() => {
                                                if (formData && formData.injectHubSpotFormCSS) {
                                                    formData.injectHubSpotFormCSS();
                                                    // #region agent log
                                                    debugInstrument('agile-ed-form-integration.js:5516', 'CSS re-injected after 500ms (domain search)', {}, 'CSS9');
                                                    // #endregion
                                                }
                                            }, 500);
                                            
                                            // Final delayed re-injection to catch extremely delayed DOM manipulation
                                            setTimeout(() => {
                                                if (formData && formData.injectHubSpotFormCSS) {
                                                    formData.injectHubSpotFormCSS();
                                                    // #region agent log
                                                    debugInstrument('agile-ed-form-integration.js:5524', 'CSS re-injected after 1000ms (domain search)', {}, 'CSS9');
                                                    // #endregion
                                                }
                                            }, 1000);
                                        }
                                        // Verify fields were populated
                                        if ($form && $form.length) {
                                            const countryField = $form.find('[name="country__new_"]').first();
                                            const stateField = $form.find('[name="us_states"]').first();
                                            debugLog('Form field values after country/state population:', {
                                                countryFieldValue: countryField.length ? countryField.val() : 'field not found',
                                                stateFieldValue: stateField.length ? stateField.val() : 'field not found'
                                            });
                                        }
                                    }).catch(e => {
                                        debugWarn('Error populating country/state:', e);
                                    });
                                } catch (e) {
                                    debugWarn('Error calling populateHubSpotForm for country/state:', e);
                                }
                            }, 500); // Small delay to ensure form is ready
                        } else {
                            debugWarn('No country/state found in pendingFormPopulation or domain results');
                        }
                        
                        displayAutocompleteResults(resultsToShow);
                        
                        // IMPORTANT: Don't clear showDomainSearchResults flag yet - keep it to prevent state search from overwriting
                        // Only clear it when user actually selects a school or starts typing something different
                        // This ensures the dropdown stays visible with all domain results
                        debugLog('Domain results displayed - keeping showDomainSearchResults flag to prevent state search override', {
                            resultsCount: resultsToShow.length,
                            flagValue: formData ? formData.showDomainSearchResults : 'N/A'
                        });
                    } catch (displayError) {
                        logError('Error displaying domain results:', displayError);
                    }
                    
                    // CRITICAL: Return here to prevent state search from running
                    // Also set a flag to completely block state search
                    if (formData) {
                        formData.blockStateSearch = true;
                    }
                    return;
                }
            }
            
            // If no email domain, not enough characters, AND no state selected, hide dropdown and return
            if (!hasEmailDomain && !hasMinimumLength && !hasStateSelected) {
                debugLog('searchDistricts: Blocked - no email domain, not enough chars, no state selected');
                $autocompleteContainer.hide().empty();
                return;
            }
            
            // Priority 1: Check if email is entered, search by domain
            // IMPORTANT: Skip domain search if user is typing in school field AND state is selected
            // This ensures state search runs immediately when user types, without waiting for domain search
            let domainSearchSucceeded = false;
            const shouldSkipDomainSearch = wasCalledFromInput && hasStateSelected && searchValue && searchValue.length > 0;
            
            debugLog('Domain search check:', {
                hasEmailField: !!emailField && emailField.length,
                shouldSkipDomainSearch: shouldSkipDomainSearch,
                wasCalledFromInput: wasCalledFromInput,
                hasStateSelected: hasStateSelected,
                searchValue: searchValue
            });
            
            // Skip domain search if user is typing in school field with state selected
            // Domain search should only run when email field changes, not when school field changes
            if (!shouldSkipDomainSearch && emailField && emailField.length) {
                const emailValue = emailField.val().trim();
                // Check if email has a complete domain (with TLD)
                const hasCompleteDomain = emailValue && emailValue.includes('@') && emailValue.includes('.') && 
                    emailValue.split('@').length === 2 && emailValue.split('@')[1].includes('.');
                
                if (hasCompleteDomain) {
                    const domain = emailValue.split('@')[1];
                    // Domain must have at least 4 characters (e.g., "a.co") and include a dot
                    if (domain && domain.length >= 4 && domain.includes('.')) {
                        const domainParts = domain.split('.');
                        // Must have at least domain name + TLD (e.g., "example.com" = 2 parts)
                        if (domainParts.length >= 2 && domainParts[0].length >= 1 && domainParts[domainParts.length - 1].length >= 2) {
                            // Check cache first
                            const cacheKey = `domain:${domain}`;
                            const cached = apiCache.domainSearch.get(cacheKey);
                            if (cached && (Date.now() - cached.timestamp) < CACHE_DURATION) {
                                // Use cached results
                                const schools = cached.data;
                                if (schools && Array.isArray(schools) && schools.length > 0) {
                                    // Filter by search value if provided
                                    let filtered = schools;
                                    if (searchValue && searchValue.length >= 2) {
                                        filtered = schools.filter(s => {
                                            const name = s.institutionNameProper || s.institutionName || s.name || s.buildingName || s.districtName || '';
                                            return name.toLowerCase().includes(searchValue.toLowerCase());
                                        });
                                    }
                                    
                                    // Always show results if we have schools
                                    const resultsToShow = (filtered.length > 0) ? filtered : schools;
                                    if (resultsToShow.length > 0) {
                                        autocompleteResults = resultsToShow;
                                        domainSearchSucceeded = true; // Mark that domain search found results
                                        displayAutocompleteResults(resultsToShow);
                                        return; // Domain search succeeded, don't try state search
                                    }
                                    // No results in cache - continue to API call
                                }
                            }
                            
                            try {
                                debugLog('Calling domain search API:', domain);
                                
                                const response = await agileEdAPI.searchByDomain(domain);
                                
                                debugLog('Domain search API response:', {
                                    domain: domain,
                                    response: response,
                                    isNull: response === null,
                                    isUndefined: response === undefined
                                });
                                
                                // Handle null/undefined responses - API returns null when no results found (204 No Content)
                                // The API proxy returns data.data, which can be null
                                if (response === null || response === undefined) {
                                    // No schools found for this domain - continue to country/state search as fallback
                                    // Don't hide container or return - let it fall through to country/state search below
                                    // The state search will handle showing/hiding the dropdown
                                    debugLog('Domain search returned null/undefined - falling through to state search');
                                } else {
                                    // The API proxy returns data.data, so response should already be an array
                                    // But handle cases where it might be wrapped
                                    let schools = null;
                                    if (Array.isArray(response)) {
                                        schools = response;
                                    } else if (response && response.data !== null && response.data !== undefined) {
                                        if (Array.isArray(response.data)) {
                                            schools = response.data;
                                        } else if (response.data && Array.isArray(response.data.data)) {
                                            schools = response.data.data;
                                        }
                                    } else if (response && response.success && response.data !== null && Array.isArray(response.data)) {
                                        schools = response.data;
                                    }
                                    
                                    if (schools && Array.isArray(schools) && schools.length > 0) {
                                        // IMPORTANT: Only hide dropdown if school was selected from autocomplete AND matches
                                        // If user is typing in school field, always show dropdown even if field has value
                                        // This allows users to change the school even after it was auto-populated
                                        let currentSchoolValue = companyField.val().trim();
                                        
                                        // IMPORTANT: When school is populated from email API, ALWAYS show dropdown
                                        // This allows user to see all schools from the domain and select a different one
                                        // Only hide dropdown if:
                                        // 1. School field has a value AND
                                        // 2. School was selected from autocomplete (not from Personnel API) AND
                                        // 3. User is NOT actively typing (wasCalledFromInput is false) AND
                                        // 4. NOT populated from email (schoolPopulatedFromEmail is false)
                                        const isPopulatedFromEmail = formData && formData.schoolPopulatedFromEmail === true;
                                        
                                        if (currentSchoolValue && currentSchoolValue.length > 0 && 
                                            schoolSelectedFromAutocomplete && 
                                            currentSchoolValue === lastSelectedSchoolName &&
                                            !wasCalledFromInput &&
                                            !isPopulatedFromEmail) {
                                        // School was selected from autocomplete and user is not typing - don't show dropdown
                                        // BUT: If populated from email, always show dropdown so user can select
                                        debugLog('Skipping dropdown - school already selected from autocomplete');
                                        
                                        // Cache the results anyway for future use
                                        apiCache.domainSearch.set(cacheKey, {
                                            data: schools,
                                            timestamp: Date.now()
                                        });
                                        limitCacheSize(apiCache.domainSearch, MAX_CACHE_SIZE);
                                        $autocompleteContainer.hide().empty();
                                        updateContainerPadding();
                                        return;
                                    }
                                    
                                    // If we get here, show the dropdown (either field is empty, or user is typing, or school wasn't from autocomplete)
                                    
                                    // Don't hide dropdown - keep it visible for user to select
                                    // User must select from dropdown, so we don't hide it automatically
                                    
                                        // Filter by search value if provided (but show all if searchValue is empty)
                                        let filtered = schools;
                                        if (searchValue && searchValue.length >= 2) {
                                            filtered = schools.filter(s => {
                                                const name = s.institutionNameProper || s.institutionName || s.name || s.buildingName || s.districtName || '';
                                                return name.toLowerCase().includes(searchValue.toLowerCase());
                                            });
                                        }
                                        
                                        // Always show results if we have schools (even if filtered is empty, show all)
                                        const resultsToShow = (filtered.length > 0) ? filtered : schools;
                                        debugLog('Domain search results processed:', {
                                            schoolsCount: schools.length,
                                            filteredCount: filtered.length,
                                            resultsToShowCount: resultsToShow.length,
                                            searchValue: searchValue
                                        });
                                        if (resultsToShow.length > 0) {
                                                // Cache the results
                                            apiCache.domainSearch.set(cacheKey, {
                                                data: schools,
                                                timestamp: Date.now()
                                            });
                                            // Fix: Limit cache size to prevent memory issues
                                            limitCacheSize(apiCache.domainSearch, MAX_CACHE_SIZE);
                                            
                                            autocompleteResults = resultsToShow;
                                            domainSearchSucceeded = true; // Mark that domain search found results
                                            
                                            debugLog('Calling displayAutocompleteResults for domain search:', {
                                                resultsCount: resultsToShow.length
                                            });
                                            
                                            // Force show the dropdown
                                            displayAutocompleteResults(resultsToShow);
                                            return; // Domain search succeeded, don't try state search
                                        } else {
                                            debugLog('Domain search filtered to empty, will try state search');
                                        }
                                    } else {
                                        // No schools found or empty/null response - continue to fallback search
                                        // Don't hide container - let state search handle showing/hiding
                                    }
                                }
                            } catch (error) {
                                // Fall through to country/state search
                                // Don't hide container here - let state search handle it
                                // Error logged but continue to state search
                                logError('Domain search error - falling through to state search:', error);
                            }
                        } // Close: domainParts check
                    } // Close: domain length check
                } // Close: hasCompleteDomain check
            } // Close: if (!shouldSkipDomainSearch && emailField && emailField.length)
            
            // Priority 2: Check country and state, search by state
            // State search should work even if only state is selected (country is optional)
            // IMPORTANT: Always run state search when state is selected and user is typing,
            // regardless of whether domain search was attempted or succeeded
            // (stateField and countryField already declared at top of function)
            
            debugLog('Reached state search section:', {
                    domainSearchSucceeded: domainSearchSucceeded,
                    stateFieldLength: stateField.length,
                    stateFieldValue: stateField.val(),
                    searchValue: searchValue
                });
            
            // Only require state to be selected (country is optional for state-based search)
            // BUT: Don't run state search if we're showing domain results (for known emails)
            // This prevents state search from overwriting domain results dropdown
            const hasDomainResults = formData && formData.domainSearchResults && Array.isArray(formData.domainSearchResults) && formData.domainSearchResults.length > 0;
            const isShowingDomainResults = formData && formData.showDomainSearchResults && hasDomainResults;
            const isBlockingStateSearch = formData && formData.blockStateSearch;
            
            // CRITICAL: If we have domain results and should show them, display filtered results instead of state search
            if (hasDomainResults && (isShowingDomainResults || isBlockingStateSearch)) {
                debugLog('Blocking state search - showing filtered domain results instead', {
                    isShowingDomainResults: isShowingDomainResults,
                    isBlockingStateSearch: isBlockingStateSearch,
                    domainResultsCount: formData.domainSearchResults.length,
                    searchValue: searchValue
                });
                
                // Filter domain results based on search value
                let filteredDomainResults = formData.domainSearchResults;
                if (searchValue && searchValue.length > 0) {
                    const searchLower = searchValue.toLowerCase();
                    filteredDomainResults = formData.domainSearchResults.filter(result => {
                        const name = (result.institutionNameProper || result.institutionName || '').toLowerCase();
                        const city = (result.mailingCityProper || result.mailingCity || result.city || '').toLowerCase();
                        return name.includes(searchLower) || city.includes(searchLower);
                    });
                    debugLog('Filtered domain results for search:', {
                        totalDomainResults: formData.domainSearchResults.length,
                        filteredResults: filteredDomainResults.length,
                        searchValue: searchValue
                    });
                }
                
                // Display filtered domain results
                if (filteredDomainResults.length > 0) {
                    autocompleteResults = filteredDomainResults;
                    displayAutocompleteResults(filteredDomainResults);
                    // Ensure flag is set so domain results continue to show
                    if (formData) {
                        formData.showDomainSearchResults = true;
                    }
                    return; // Exit early - don't run state search
                } else {
                    // No matching domain results - hide dropdown
                    debugLog('No matching domain results for search - hiding dropdown');
                    $autocompleteContainer.hide().empty();
                    updateContainerPadding();
                    return; // Exit early - don't run state search
                }
            }
            
            if (stateField.length && stateField.val() && !isShowingDomainResults && !isBlockingStateSearch) {
                // CRITICAL: Re-read state field value to ensure we have the latest value
                // This is important when state field changes from one country to another
                const currentStateValue = stateField.val();
                
                // CRITICAL: Check country field - only do US state searches if country is United States
                const countryValue = countryField.length ? countryField.val() : null;
                const isUSCountry = countryValue === 'United States' || countryValue === 'US' || countryValue === 'USA';
                
                // CRITICAL: For US state searches, ensure we're using the US states field
                // If country is US but state field is not us_states, try to find the correct field
                let actualStateField = stateField;
                let actualStateValue = currentStateValue;
                
                if (isUSCountry) {
                    // For US, we need us_states field
                    const usStateField = $form.find('select[name="us_states"]').first();
                    if (usStateField.length && usStateField.val()) {
                        actualStateField = usStateField;
                        actualStateValue = usStateField.val();
                        debugLog('Using US states field for state search:', {
                            usStateValue: actualStateValue,
                            previousStateValue: currentStateValue
                        });
                    }
                }
                
                const stateValue = actualStateValue;
                
                debugLog('State search section entered:', {
                    stateValue: stateValue,
                    countryValue: countryValue,
                    isUSCountry: isUSCountry,
                    searchValue: searchValue,
                    domainSearchSucceeded: domainSearchSucceeded,
                    stateFieldName: actualStateField.attr('name')
                });
                
                // CRITICAL: Only proceed with US state search if country is United States
                // For other countries, skip state-based search (they may not have state/province data)
                if (!isUSCountry) {
                    debugLog('Skipping state search - country is not United States:', countryValue);
                    $autocompleteContainer.hide().empty();
                    isDistrictSearching = false;
                    lastSearchedStateValue = null;
                    return;
                }
                
                // Only apply rate limiting if searching the same state
                // Allow immediate search if state changed or if user is typing in school field
                const timeSinceLastSearch = Date.now() - lastDistrictSearchTime;
                const stateChanged = lastSearchedStateValue !== stateValue;
                
                // Allow search if:
                // 1. State changed (different state selected), OR
                // 2. User is typing in school field (searchValue provided and not empty), OR
                // 3. Enough time has passed since last search
                // IMPORTANT: Always allow search when user is typing (searchValue is not empty)
                const isUserTyping = searchValue && searchValue.length > 0;
                
                debugLog('State search rate limiting check:', {
                        stateChanged: stateChanged,
                        isUserTyping: isUserTyping,
                        timeSinceLastSearch: timeSinceLastSearch,
                        MIN_DISTRICT_SEARCH_INTERVAL: MIN_DISTRICT_SEARCH_INTERVAL,
                        isDistrictSearching: isDistrictSearching
                    });
                
                if (!stateChanged && !isUserTyping && timeSinceLastSearch < MIN_DISTRICT_SEARCH_INTERVAL) {
                    // Rate limit only if user is NOT typing
                    debugLog('State search blocked by rate limiting');
                    return;
                }
                
                // Only block if currently searching the same state AND user is not typing
                // Always allow search when user is typing in school field
                if (isDistrictSearching && !stateChanged && !isUserTyping) {
                    debugLog('State search blocked - already searching');
                    return;
                }
                
                // Update last searched state
                lastSearchedStateValue = stateValue;
                
                isDistrictSearching = true;
                lastDistrictSearchTime = Date.now();
                
                // CRITICAL: Declare stateCode in outer scope so it's accessible in catch block
                let stateCode = null;
                
                try {
                    stateCode = institutionWidget.getStateCode(stateValue);
                    
                    debugLog('State code conversion:', {
                        stateValue: stateValue,
                        stateCode: stateCode
                    });
                    
                    // Validate state code before making API call
                    if (!stateCode || typeof stateCode !== 'string' || stateCode.length !== 2) {
                        // This is expected for non-US states (e.g., Canadian provinces, other countries)
                        // Don't treat it as an error, just skip the search
                        debugWarn('State code not valid for US search (may be non-US state/province):', stateCode);
                        $autocompleteContainer.hide().empty();
                        isDistrictSearching = false;
                        // CRITICAL: Reset lastSearchedStateValue to null so that when a valid state is selected,
                        // the code will recognize it as a state change and trigger a new search
                        lastSearchedStateValue = null;
                        return;
                    }
                    
                    // Check cache first
                    const cacheKey = `state:${stateCode}`;
                    const cached = apiCache.stateSearch.get(cacheKey);
                    
                    debugLog('Cache check:', {
                            cacheKey: cacheKey,
                            hasCached: !!cached,
                            cacheAge: cached ? (Date.now() - cached.timestamp) : null,
                            CACHE_DURATION: CACHE_DURATION,
                            cacheValid: cached && (Date.now() - cached.timestamp) < CACHE_DURATION
                        });
                    
                    if (cached && (Date.now() - cached.timestamp) < CACHE_DURATION) {
                        // Use cached results
                        const districts = cached.data;
                        if (Array.isArray(districts) && districts.length > 0) {
                            // Filter by search value if provided (allow filtering with 1+ characters)
                            // CRITICAL: Ensure searchValue is trimmed and case-insensitive matching works correctly
                            let filtered = districts;
                            if (searchValue && searchValue.length >= 1) {
                                const searchLower = String(searchValue).trim().toLowerCase();
                                filtered = districts.filter(d => {
                                    const name = (d.institutionNameProper || d.institutionName || d.name || d.districtName || d.DistrictName || '').toString();
                                    const nameLower = name.toLowerCase();
                                    // Check if search text appears anywhere in the name
                                    return nameLower.includes(searchLower);
                                });
                                debugLog('Filtered cached results:', {
                                    searchValue: searchValue,
                                    searchLower: searchLower,
                                    totalDistricts: districts.length,
                                    filteredCount: filtered.length
                                });
                            }
                            
                            // CRITICAL: If user is typing (searchValue provided), show only filtered results
                            // If user is NOT typing (searchValue empty), show all districts
                            // This ensures typing filters results correctly - don't show all if nothing matches
                            const resultsToShow = (searchValue && searchValue.length >= 1) ? filtered : districts;
                            
                            // If user is typing and no results match, hide dropdown
                            if (searchValue && searchValue.length >= 1 && filtered.length === 0) {
                                debugLog('No schools match search value (cached) - hiding dropdown', {
                                    searchValue: searchValue,
                                    totalDistricts: districts.length
                                });
                                $autocompleteContainer.hide().empty();
                                updateContainerPadding();
                                isDistrictSearching = false;
                                return;
                            }
                            
                            if (resultsToShow.length > 0) {
                                debugLog('Using cached results:', {
                                    resultsCount: resultsToShow.length,
                                    filteredCount: filtered.length,
                                    totalDistricts: districts.length,
                                    searchValue: searchValue,
                                    filtered: searchValue && searchValue.length >= 1,
                                    firstResult: resultsToShow[0] ? (resultsToShow[0].institutionNameProper || resultsToShow[0].institutionName || 'N/A') : 'N/A'
                                });
                                
                                // CRITICAL: Check if we should block state search (domain results are being shown)
                                const shouldBlockStateSearch = formData && (formData.showDomainSearchResults || formData.blockStateSearch);
                                
                                if (shouldBlockStateSearch) {
                                    debugLog('Blocking cached state search results - domain results are being shown instead', {
                                        searchValue: searchValue
                                    });
                                    // Don't show state search results - domain results are already showing
                                    return;
                                }
                                
                                autocompleteResults = resultsToShow;
                                displayAutocompleteResults(resultsToShow);
                                return;
                            } else {
                                debugLog('Cached results filtered to empty, will fetch from API', {
                                    searchValue: searchValue,
                                    totalDistricts: districts.length,
                                    filteredCount: filtered.length
                                });
                            }
                        } else {
                            debugLog('Cache has no districts array or empty array');
                        }
                    } else {
                        debugLog('No valid cache, will fetch from API');
                    }
                    
                    debugLog('Calling getDistrictsInState API:', stateCode);
                    
                    // Create new AbortController for this request
                    // Cancel any previous request
                    if (districtSearchAbortController) {
                        districtSearchAbortController.abort();
                    }
                    districtSearchAbortController = new AbortController();
                    const abortSignal = districtSearchAbortController.signal;
                    
                    // Add retry logic for timeout errors
                    let districts = null;
                    let lastError = null;
                    const maxRetries = 2; // Retry up to 2 times
                    
                    for (let attempt = 0; attempt <= maxRetries; attempt++) {
                        try {
                            // Check if request was aborted before retry
                            if (abortSignal.aborted) {
                                debugLog('District search request was aborted');
                                return; // Exit early if aborted
                            }
                            
                            if (attempt > 0) {
                                debugLog(`Retrying getDistrictsInState API (attempt ${attempt + 1}/${maxRetries + 1}):`, stateCode);
                                // Exponential backoff: wait 2 seconds, then 4 seconds
                                await new Promise(resolve => setTimeout(resolve, 2000 * attempt));
                                
                                // Check again if aborted after backoff
                                if (abortSignal.aborted) {
                                    debugLog('District search request was aborted during retry');
                                    return; // Exit early if aborted
                                }
                            }
                            
                            districts = await agileEdAPI.getDistrictsInState(stateCode, abortSignal);
                            lastError = null; // Success - clear error
                            break; // Exit retry loop on success
                        } catch (error) {
                            // Don't retry if request was aborted
                            if (error.name === 'AbortError' || abortSignal.aborted) {
                                debugLog('District search request was aborted');
                                return; // Exit early if aborted
                            }
                            
                            lastError = error;
                            const errorMessage = error.message || error.toString() || '';
                            const isTimeoutError = errorMessage.includes('timed out') || errorMessage.includes('timeout');
                            const isServerError = errorMessage.includes('500') || errorMessage.includes('Internal Server Error') || errorMessage.includes('Server error');
                            
                            // Retry on timeout or server errors (500)
                            if ((isTimeoutError || isServerError) && attempt < maxRetries) {
                                debugWarn(`API request failed (${isTimeoutError ? 'timeout' : 'server error'}) (attempt ${attempt + 1}), will retry...`);
                                continue; // Retry on timeout or server error
                            } else {
                                // Not a retryable error, or max retries reached - throw the error
                                throw error;
                            }
                        }
                    }
                    
                    // If we still have an error after all retries, throw it
                    if (lastError) {
                        // Clean up abort controller on error
                        districtSearchAbortController = null;
                        throw lastError;
                    }
                    
                    // Clean up abort controller on success
                    districtSearchAbortController = null;
                    
                    debugLog('State search API response received:', {
                        stateCode: stateCode,
                        districtsType: typeof districts,
                        isArray: Array.isArray(districts),
                        districts: districts
                    });
                    
                    // Handle different response formats
                    let districtsArray = null;
                    if (Array.isArray(districts)) {
                        districtsArray = districts;
                    } else if (districts && Array.isArray(districts.data)) {
                        districtsArray = districts.data;
                    } else if (districts && districts.success && Array.isArray(districts.data)) {
                        districtsArray = districts.data;
                    }
                    
                    debugLog('State search results processed:', {
                        districtsArray: districtsArray,
                        arrayLength: districtsArray ? districtsArray.length : 0,
                        searchValue: searchValue
                    });
                    
                    if (districtsArray && districtsArray.length > 0) {
                        // Filter by search value if provided (allow filtering with 1+ characters)
                        // CRITICAL: Ensure searchValue is trimmed and case-insensitive matching works correctly
                        let filtered = districtsArray;
                        if (searchValue && searchValue.length >= 1) {
                            const searchLower = String(searchValue).trim().toLowerCase();
                            filtered = districtsArray.filter(d => {
                                const name = (d.institutionNameProper || d.institutionName || d.name || d.districtName || d.DistrictName || '').toString();
                                const nameLower = name.toLowerCase();
                                // Check if search text appears anywhere in the name
                                return nameLower.includes(searchLower);
                            });
                            debugLog('Filtered API results:', {
                                searchValue: searchValue,
                                searchLower: searchLower,
                                totalDistricts: districtsArray.length,
                                filteredCount: filtered.length
                            });
                        }
                        
                        // CRITICAL: If user is typing (searchValue provided), show only filtered results
                        // If user is NOT typing (searchValue empty), show all districts
                        // This ensures typing filters results correctly - don't show all if nothing matches
                        // IMPORTANT: When state is selected and searchValue is empty, show ALL districts
                        // This allows user to see all schools for the state and select from the dropdown
                        const resultsToShow = (searchValue && searchValue.length >= 1) ? filtered : districtsArray;
                        
                        // If user is typing and no results match, hide dropdown
                        if (searchValue && searchValue.length >= 1 && filtered.length === 0) {
                            debugLog('No schools match search value - hiding dropdown', {
                                searchValue: searchValue,
                                totalDistricts: districtsArray.length
                            });
                            $autocompleteContainer.hide().empty();
                            updateContainerPadding();
                            isDistrictSearching = false;
                            return;
                        }
                        
                        // IMPORTANT: When state is selected and searchValue is empty (showing all schools),
                        // always display the dropdown so user can see and select from the list
                        // This matches the behavior when email populates the field
                        if (resultsToShow.length > 0) {
                            // Cache the results
                            apiCache.stateSearch.set(cacheKey, {
                                data: districtsArray,
                                timestamp: Date.now()
                            });
                            // Fix: Limit cache size to prevent memory issues
                            limitCacheSize(apiCache.stateSearch, MAX_CACHE_SIZE);
                            
                            // CRITICAL: Check if we should block state search (domain results are being shown)
                            const shouldBlockStateSearch = formData && (formData.showDomainSearchResults || formData.blockStateSearch);
                            
                            if (shouldBlockStateSearch) {
                                debugLog('Blocking state search results - domain results are being shown instead', {
                                    stateResultsCount: resultsToShow.length,
                                    domainResultsCount: formData && formData.domainSearchResults ? formData.domainSearchResults.length : 0,
                                    searchValue: searchValue
                                });
                                // Don't show state search results - domain results are already showing
                                return;
                            }
                            
                            debugLog('Displaying state search results:', {
                                resultsCount: resultsToShow.length,
                                searchValue: searchValue,
                                filtered: searchValue && searchValue.length >= 1,
                                firstResult: resultsToShow[0] ? (resultsToShow[0].institutionNameProper || resultsToShow[0].institutionName || 'N/A') : 'N/A'
                            });
                            
                            autocompleteResults = resultsToShow;
                            displayAutocompleteResults(resultsToShow);
                        } else {
                            $autocompleteContainer.hide().empty();
                            updateContainerPadding();
                        }
                    } else {
                        $autocompleteContainer.hide().empty();
                        updateContainerPadding();
                    }
                } catch (error) {
                    // Clean up abort controller on error
                    districtSearchAbortController = null;
                    
                    // Don't log abort errors as errors
                    if (error.name === 'AbortError' || (error.message && error.message.includes('aborted'))) {
                        debugLog('District search request was aborted (expected)');
                        return; // Exit early if aborted
                    }
                    
                    logError('Error in state search:', error);
                    
                    // CRITICAL: On API failure, try to use cached results if available
                    // This ensures autocomplete continues working even when API fails
                    const cacheKey = `state:${stateCode}`;
                    const cached = apiCache.stateSearch.get(cacheKey);
                    
                    if (cached && (Date.now() - cached.timestamp) < CACHE_DURATION) {
                        const districts = cached.data;
                        if (Array.isArray(districts) && districts.length > 0) {
                            debugLog('API failed but using cached results to keep autocomplete working', {
                                cacheKey: cacheKey,
                                cachedResultsCount: districts.length
                            });
                            
                            // Filter by search value if provided (allow filtering with 1+ characters)
                            // CRITICAL: Ensure searchValue is trimmed and case-insensitive matching works correctly
                            let filtered = districts;
                            if (searchValue && searchValue.length >= 1) {
                                const searchLower = String(searchValue).trim().toLowerCase();
                                filtered = districts.filter(d => {
                                    const name = (d.institutionNameProper || d.institutionName || d.name || d.districtName || d.DistrictName || '').toString();
                                    const nameLower = name.toLowerCase();
                                    // Check if search text appears anywhere in the name
                                    return nameLower.includes(searchLower);
                                });
                                debugLog('Filtered error fallback cache results:', {
                                    searchValue: searchValue,
                                    searchLower: searchLower,
                                    totalDistricts: districts.length,
                                    filteredCount: filtered.length
                                });
                            }
                            
                            const resultsToShow = (searchValue && searchValue.length >= 1) ? filtered : districts;
                            
                            // If user is typing and no results match, hide dropdown
                            if (searchValue && searchValue.length >= 1 && filtered.length === 0) {
                                debugLog('No schools match search value (cached fallback) - hiding dropdown');
                                $autocompleteContainer.hide().empty();
                                updateContainerPadding();
                            } else if (resultsToShow.length > 0) {
                                // Show cached results even though API failed
                                autocompleteResults = resultsToShow;
                                displayAutocompleteResults(resultsToShow);
                                debugLog('Showing cached results despite API failure');
                            } else {
                                $autocompleteContainer.hide().empty();
                                updateContainerPadding();
                            }
                        } else {
                            // No cached results - hide dropdown
                            debugLog('API failed and no cached results available');
                            $autocompleteContainer.hide().empty();
                            updateContainerPadding();
                        }
                    } else {
                        // No cache available - hide dropdown
                        debugLog('API failed and no valid cache available');
                        $autocompleteContainer.hide().empty();
                        updateContainerPadding();
                    }
                    
                    // Reset state tracking on error to allow retry
                    lastSearchedStateValue = null;
                } finally {
                    isDistrictSearching = false;
                    debugLog('State search finally block - isDistrictSearching set to false');
                }
            } else {
                // No country/state selected, hide autocomplete
                $autocompleteContainer.hide().empty();
            }
        };
        
        // Function to display autocomplete results
        const displayAutocompleteResults = function(results) {
            // CRITICAL: If email input is active OR HubSpot is manipulating DOM, skip ALL DOM manipulation
            // This prevents insertBefore errors that cause the form to disappear
            // Check both local variable and formData flag
            const isEmailInputActive = emailInputActive || (formData && formData.emailInputActive);
            const isHubSpotManipulating = formData && formData.hubspotManipulating;
            if (isEmailInputActive || isHubSpotManipulating) {
                debugLog('Skipping displayAutocompleteResults - email input active or HubSpot manipulating DOM', {
                    emailInputActive: isEmailInputActive,
                    hubspotManipulating: isHubSpotManipulating
                });
                return; // Exit immediately, don't touch the DOM
            }
            
            // CRITICAL: Wrap ALL operations in try-catch to prevent any errors from breaking the form
            // This is a safety net in case emailInputActive flag doesn't catch everything
            try {
                debugLog('displayAutocompleteResults called:', {
                resultsCount: results ? (Array.isArray(results) ? results.length : 'not array') : 'null/undefined',
                containerExists: !!$autocompleteContainer && $autocompleteContainer.length > 0,
                containerInDOM: $autocompleteContainer && $autocompleteContainer.length && document.body.contains($autocompleteContainer[0]),
                containerParent: $autocompleteContainer && $autocompleteContainer.length ? $autocompleteContainer.parent()[0] : null,
                emailInputActive: emailInputActive
            });
            
            // Ensure container exists
            if (!$autocompleteContainer || !$autocompleteContainer.length) {
                logError('displayAutocompleteResults: Container does not exist!');
                return;
            }
            
            // CRITICAL: Check if container is in DOM - if not, append it
            // But if it's already in DOM (even if in wrong parent), don't move it to avoid conflicts with HubSpot
            // IMPORTANT: If container is in DOM OR email input is active, skip ALL DOM manipulation to prevent insertBefore errors
            const containerInDOM = $autocompleteContainer[0] && 
                                 ($autocompleteContainer[0].isConnected || 
                                  document.body.contains($autocompleteContainer[0]));
            
            // If container is already in DOM OR email input is active, skip all append/move operations to prevent HubSpot conflicts
            if (!containerInDOM && !emailInputActive) {
                debugWarn('Container not in DOM, attempting to append it', {
                        containerElement: $autocompleteContainer[0],
                        hasParent: $autocompleteContainer.parent().length > 0,
                        containerTag: $autocompleteContainer[0] ? $autocompleteContainer[0].tagName : 'N/A',
                        containerId: $autocompleteContainer[0] ? $autocompleteContainer[0].id : 'N/A',
                        containerClass: $autocompleteContainer[0] ? $autocompleteContainer[0].className : 'N/A'
                    });
                    try {
                    // Re-get the container in case DOM changed
                    $companyFieldContainer = getCompanyFieldContainer();
                    if (!$companyFieldContainer || !$companyFieldContainer.length) {
                        // Fallback: use company field's parent
                        $companyFieldContainer = companyField.parent();
                        debugLog('Using company field parent as fallback container', {
                            parentElement: $companyFieldContainer[0],
                            parentInDOM: $companyFieldContainer.length && document.body.contains($companyFieldContainer[0])
                        });
                    }
                    
                    // Check if container exists and is valid (use isConnected for better iframe/shadow DOM support)
                    const containerIsValid = $companyFieldContainer && 
                                           $companyFieldContainer.length && 
                                           $companyFieldContainer[0] &&
                                           ($companyFieldContainer[0].isConnected || 
                                            document.body.contains($companyFieldContainer[0]) ||
                                            $companyFieldContainer[0].ownerDocument === document);
                    
                    if (containerIsValid) {
                        // Check if container is already in the correct parent
                        const currentParent = $autocompleteContainer.parent().length ? $autocompleteContainer.parent()[0] : null;
                        const isInCorrectParent = currentParent === $companyFieldContainer[0];
                        
                        // Use double requestAnimationFrame to ensure HubSpot's DOM updates are complete
                        // This prevents insertBefore errors when HubSpot is manipulating the DOM
                        requestAnimationFrame(() => {
                            requestAnimationFrame(() => {
                                try {
                                    const autocompleteElement = $autocompleteContainer[0];
                                    const targetParent = $companyFieldContainer[0];
                                    
                                    // Double-check element is still not in DOM before appending
                                    const stillNotInDOM = !autocompleteElement || 
                                                         (!autocompleteElement.isConnected && 
                                                          !document.body.contains(autocompleteElement));
                                    
                                    if (stillNotInDOM && autocompleteElement && targetParent) {
                                        // Append directly - jQuery will handle it
                                        $companyFieldContainer.append($autocompleteContainer);
                                        debugLog('Container appended to DOM via double requestAnimationFrame');
                                    } else {
                                        debugLog('Container already in DOM or invalid - skipping append');
                                    }
                                } catch (appendError) {
                                    // Ignore append errors - HubSpot may have moved it already
                                    debugWarn('Error appending container (HubSpot may have moved it):', appendError);
                                }
                            });
                        });
                        
                        // Don't return early - continue to show results even if append is async
                        // The container will be appended asynchronously, and if it fails, we'll handle it gracefully
                        debugLog('Container append scheduled - continuing to show results');
                    } else {
                        // Try to append anyway - sometimes the check fails but append works
                        if ($companyFieldContainer && $companyFieldContainer.length && $companyFieldContainer[0]) {
                            debugWarn('Container check failed but attempting append anyway', {
                                companyFieldContainer: $companyFieldContainer[0],
                                isConnected: $companyFieldContainer[0].isConnected,
                                inBody: document.body.contains($companyFieldContainer[0]),
                                ownerDocument: $companyFieldContainer[0].ownerDocument === document
                            });
                            
                            // Use requestAnimationFrame to defer DOM manipulation and avoid conflicts with HubSpot
                            requestAnimationFrame(() => {
                                try {
                                    // Don't detach - just append directly (jQuery will move it automatically)
                                    // This avoids removeChild errors when HubSpot is also manipulating the DOM
                                    const autocompleteElement = $autocompleteContainer[0];
                                    const targetParent = $companyFieldContainer[0];
                                    
                                    // Check if element is still valid before moving
                                    if (autocompleteElement && targetParent) {
                                        // Append directly - jQuery will handle moving it from old parent
                                        $companyFieldContainer.append($autocompleteContainer);
                                        debugLog('Container moved to correct parent via append (fallback)');
                                    } else {
                                        debugWarn('Cannot move container - element or target not valid');
                                    }
                                } catch (appendError) {
                                    // Ignore append errors - HubSpot may have moved it already
                                    debugWarn('Error moving container (HubSpot may have moved it):', appendError);
                                }
                            });
                            
                            // Note: The rest of the code below will run before requestAnimationFrame executes
                            // So we need to check if container was moved after a short delay
                            setTimeout(() => {
                                try {
                                    // Check if it worked
                                    if ($autocompleteContainer.parent().length > 0) {
                                        debugLog('Container appended successfully despite check failure', {
                                            containerParent: $autocompleteContainer.parent()[0]
                                        });
                                    } else {
                                        debugWarn('Container append may have failed - no parent after append');
                                        // Don't return - just log, allow code to continue
                                    }
                                } catch (checkError) {
                                    debugWarn('Error checking container status:', checkError);
                                }
                            }, 50); // Small delay to allow requestAnimationFrame to execute
                            
                            // Don't return early - continue to show results even if append is async
                            // The container will be appended asynchronously
                            debugLog('Container append scheduled (fallback) - continuing to show results');
                        } else {
                            debugWarn('Cannot append container - companyFieldContainer not found', {
                                companyFieldContainer: $companyFieldContainer,
                                companyFieldContainerLength: $companyFieldContainer ? $companyFieldContainer.length : 0,
                                companyField: companyField[0]
                            });
                            // Don't return - continue anyway, container might still work
                        }
                    }
                } catch (e) {
                    debugWarn('Error attempting to append container to DOM:', {
                        error: e,
                        errorMessage: e.message
                    });
                    // Don't return - continue anyway, container might still work
                }
            } else {
                // Container is already in DOM - skip ALL DOM manipulation to prevent HubSpot conflicts
                // This prevents insertBefore errors when HubSpot is manipulating the form
                debugLog('Container already in DOM - skipping all DOM manipulation to prevent HubSpot conflicts', {
                    containerParent: $autocompleteContainer.parent()[0],
                    containerInBody: document.body.contains($autocompleteContainer[0]),
                    containerIsConnected: $autocompleteContainer[0] ? $autocompleteContainer[0].isConnected : false
                });
            }
            
            // Double-check container is in DOM before proceeding (use isConnected for better iframe/shadow DOM support)
            // Note: containerInBody might be false if form is in iframe, but isConnected should be true
            // Use the containerInDOM variable already declared above
            
            // Even if containerInBody is false (iframe case), if isConnected is true, we can proceed
            const canProceed = $autocompleteContainer[0] && 
                              ($autocompleteContainer[0].isConnected || 
                               $autocompleteContainer.parent().length > 0);
            
            if (!canProceed) {
                // Container might be appended asynchronously - don't return early
                // This prevents form from disappearing when email is entered
                debugWarn('Container not yet in DOM - may be appended asynchronously, continuing anyway', {
                    containerElement: $autocompleteContainer[0],
                    containerIsConnected: $autocompleteContainer[0] ? $autocompleteContainer[0].isConnected : false,
                    containerInBody: $autocompleteContainer[0] ? document.body.contains($autocompleteContainer[0]) : false,
                    containerParent: $autocompleteContainer.parent()[0],
                    containerHasParent: $autocompleteContainer.parent().length > 0
                });
                // Don't return - continue to show results, container will be appended asynchronously
            }
            
            // Log if container is in iframe (containerInBody false but isConnected true)
            const container = $autocompleteContainer[0];
            const isInIframe = container && container.isConnected && !document.body.contains(container);
            if (isInIframe) {
                debugLog('Container is in iframe/shadow DOM - proceeding anyway', {
                        isConnected: $autocompleteContainer[0].isConnected,
                        inBody: document.body.contains($autocompleteContainer[0]),
                        hasParent: $autocompleteContainer.parent().length > 0
                    });
            }
            
            // Ensure results is an array
            if (!results || !Array.isArray(results)) {
                debugLog('displayAutocompleteResults: Invalid results, hiding container');
                $autocompleteContainer.hide().empty();
                updateContainerPadding(); // Reset padding when no results
                return;
            }
            
            // Check if a school was selected and current field value matches
            const currentValue = companyField.val().trim();
            
            // If user typed something different from selected school, reset the flag to allow dropdown
            // This must happen FIRST before any blocking checks
            if (schoolSelectedFromAutocomplete && currentValue !== lastSelectedSchoolName) {
                schoolSelectedFromAutocomplete = false;
                lastSelectedSchoolName = '';
            }
            
            // IMPORTANT: If this function is called with results, it means user is typing and we have results
            // Always show the dropdown when we have results - don't block based on schoolSelectedFromAutocomplete
            // The blocking should only happen in searchDistricts, not here
            
            $autocompleteContainer.empty();
            
            if (results.length === 0) {
                $autocompleteContainer.hide();
                return;
            }
            
            // Calculate and set height based on number of results
            // Each item is approximately 54px (12px top + 12px bottom padding + ~30px for text)
            // Container has 8px top padding and 16px bottom padding
            // Last item has extra 12px bottom padding (24px total instead of 12px)
            // Strategy: Adapt height dynamically - small for few items, scrollable for many items
            const itemHeight = 54; // Approximate height per item (12px top + 12px bottom + ~30px content)
            const containerPaddingTop = 8; // Container padding-top
            const containerPaddingBottom = 16; // Container padding-bottom
            const lastItemExtraPadding = 12; // Extra padding on last item (24px - 12px = 12px extra)
            const maxHeight = 300; // Maximum height before scrolling (shows ~5-6 items)
            
            // Calculate ideal height based on number of results
            // Formula: containerPaddingTop + (items * itemHeight) + lastItemExtraPadding + containerPaddingBottom
            const calculateHeight = (itemCount) => {
                if (itemCount === 0) return 0;
                if (itemCount === 1) {
                    // 1 item: container padding + 1 item (54px) + container bottom padding
                    return containerPaddingTop + itemHeight + containerPaddingBottom;
                } else {
                    // 2+ items: container padding + items * itemHeight + extra padding on last item + container bottom padding
                    return containerPaddingTop + (itemCount * itemHeight) + lastItemExtraPadding + containerPaddingBottom;
                }
            };
            
            const idealHeight = calculateHeight(results.length);
            
            // Determine actual height dynamically:
            // - If 1-5 items: use calculated height (fits perfectly, no scroll)
            // - If 6+ items: use maxHeight and enable scrolling
            let actualHeight;
            let needsScrolling = false;
            
            if (idealHeight <= maxHeight) {
                // For 1-5 items, use calculated height (fits perfectly, no scroll needed)
                actualHeight = idealHeight;
                needsScrolling = false;
            } else {
                // For 6+ items, use max height and enable scrolling
                actualHeight = maxHeight;
                needsScrolling = true;
            }
            
            // Set height dynamically based on number of results
            // This ensures dropdown looks good whether there are 1 school or 20 schools
            // CRITICAL: Use calculated height to ensure all items are fully visible, including last item with extra padding
            $autocompleteContainer.css({
                'height': actualHeight + 'px', // Set specific height based on results (includes container padding and last item extra padding)
                'max-height': maxHeight + 'px', // Cap at max for scrolling
                'overflow-y': needsScrolling ? 'auto' : 'hidden', // Only scroll if needed
                'overflow-x': 'hidden',
                'min-height': actualHeight + 'px' // Ensure minimum height matches calculated height
            });
            
            debugLog('Dropdown height calculated:', {
                resultsCount: results.length,
                idealHeight: idealHeight,
                actualHeight: actualHeight,
                needsScrolling: needsScrolling,
                containerPaddingTop: containerPaddingTop,
                containerPaddingBottom: containerPaddingBottom,
                lastItemExtraPadding: lastItemExtraPadding
            });
            
            results.forEach((item, index) => {
                // Fix: Sanitize HTML to prevent XSS attacks
                const escapeHtml = function(text) {
                    if (!text || typeof text !== 'string') return '';
                    const div = document.createElement('div');
                    div.textContent = text;
                    return div.innerHTML;
                };
                
                const name = escapeHtml(item.institutionNameProper || item.institutionName || item.name || item.buildingName || item.districtName || 'Unknown');
                const city = escapeHtml(item.mailingCityProper || item.city || '');
                const state = escapeHtml(item.mailingState || item.state || '');
                const address = escapeHtml(item.mailingAddr1Proper || item.address || '');
                
                // Add extra padding to last item to ensure it's fully visible when scrolling
                const isLastItem = index === results.length - 1;
                const itemPadding = isLastItem ? '12px 16px 24px 16px' : '12px 16px'; // Extra bottom padding (24px) on last item to ensure full visibility when scrolled to bottom
                const borderBottom = isLastItem ? 'none' : '1px solid #f0f0f0';
                
                const $item = $('<div class="autocomplete-item" style="padding: ' + itemPadding + '; cursor: pointer; border-bottom: ' + borderBottom + '; transition: background-color 0.2s ease; font-size: 14px; line-height: 1.4;" data-index="' + index + '"><div style="font-weight: 600; color: #333; margin-bottom: 4px;">' + name + '</div>' + ((city || state || address) ? '<div style="font-size: 12px; color: #666; margin-top: 2px;">' + [address, city, state].filter(Boolean).join(', ') + '</div>' : '') + '</div>');
                
                $item.on('mouseenter', function() {
                    $autocompleteContainer.find('.autocomplete-item').removeClass('selected');
                    $(this).addClass('selected').css({
                        'background-color': '#f8f9fa'
                    });
                    selectedIndex = index;
                });
                
                $item.on('mouseleave', function() {
                    $(this).css({
                        'background-color': ''
                    });
                });
                
                // Support both mouse and touch events for better mobile compatibility
                const handleItemSelection = function(e) {
                    e.preventDefault();
                    e.stopPropagation();
                    
                    // Validate results array and index before accessing
                    if (!results || !Array.isArray(results) || index < 0 || index >= results.length) {
                        return; // Invalid selection, exit early
                    }
                    
                    const selectedInstitution = results[index];
                    
                    schoolSelectedFromAutocomplete = true;
                    lastSelectedSchoolName = name; // Store the selected school name
                    
                    // Store the email domain when school was selected (if email exists)
                    let emailValue = '';
                    if (emailField && emailField.length) {
                        emailValue = emailField.val().trim();
                        if (emailValue && emailValue.includes('@')) {
                            lastEmailDomainWhenSchoolSelected = emailValue.split('@')[1] || '';
                        } else {
                            lastEmailDomainWhenSchoolSelected = '';
                        }
                    } else {
                        lastEmailDomainWhenSchoolSelected = '';
                    }
                    
                    // Fix: Clear interaction flag for this form instance only
                    if (formData) {
                        formData.interactingWithAutocomplete = false;
                        // Clear any flags that might trigger dropdown to show again
                        formData.showDomainSearchResults = false;
                        formData.schoolPopulatedFromEmail = false;
                    }
                    
                    // Hide dropdown immediately and ensure it stays hidden
                    $autocompleteContainer.hide().empty();
                    updateContainerPadding(); // Reset padding when dropdown is hidden
                    
                    // Clear any pending timeouts that might trigger search
                    clearTimeout(autocompleteTimeout);
                    
                    companyField.val(name);
                    
                    // CRITICAL: Always populate country and state from selected institution, regardless of email
                    // The email is only used to get additional personnel data (title, first name, last name)
                    institutionWidget.populateHubSpotForm(selectedInstitution);
                    
                    if (emailValue && emailValue.includes('@') && emailValue.includes('.')) {
                        // Fix: Track if form still exists to prevent race conditions
                        let formStillExists = true;
                        const checkFormExists = function() {
                            if (!$form || !$form.length || !$form[0].parentNode || !document.body.contains($form[0])) {
                                formStillExists = false;
                                return false;
                            }
                            return true;
                        };
                        
                        // Call Personnel API first, then populate form
                        (async () => {
                            try {
                                const personnelResult = await agileEdAPI.getPersonnelByEmail(emailValue);
                                
                                // Fix: Check if form still exists before DOM manipulation
                                if (!checkFormExists() || !formStillExists) {
                                    return;
                                }
                                
                                if (personnelResult && Array.isArray(personnelResult) && personnelResult.length > 0) {
                                    const personnelData = personnelResult[0];
                                    
                                    const mergedData = {
                                        ...selectedInstitution,
                                        personnelTitle: personnelData.title || personnelData.Title || personnelData.jobTitle || '',
                                        personnelFirstName: personnelData.firstName || personnelData.FirstName || '',
                                        personnelLastName: personnelData.lastName || personnelData.LastName || '',
                                        personnelUid: personnelData.personnelUid || personnelData.PersonnelUid || '',
                                        instUid: personnelData.instUid || personnelData.instUid || selectedInstitution.instUid
                                    };
                                    
                                    institutionWidget.populateHubSpotForm(mergedData);
                                    
                                    // Also get building details
                                    if (mergedData.instUid && checkFormExists() && formStillExists) {
                                        try {
                                            const buildingData = await agileEdAPI.getBuildingInDistrict(mergedData.instUid);
                                            
                                            // Fix: Check form exists before processing
                                            if (!checkFormExists() || !formStillExists) {
                                                return;
                                            }
                                            
                                            let finalData = buildingData;
                                            if (Array.isArray(buildingData) && buildingData.length > 0) {
                                                const matchingBuilding = buildingData.find(b => 
                                                    (b.instUid && b.instUid.toString() === mergedData.instUid.toString()) ||
                                                    (b.uid && b.uid.toString() === mergedData.instUid.toString())
                                                );
                                                
                                                const districtData = buildingData.find(b => 
                                                    b.parentUid && b.parentUid.toString() === mergedData.instUid.toString()
                                                ) || buildingData[0];
                                                
                                                finalData = {
                                                    ...(matchingBuilding || districtData),
                                                    ...mergedData
                                                };
                                            } else if (buildingData && typeof buildingData === 'object') {
                                                finalData = {
                                                    ...buildingData,
                                                    ...mergedData
                                                };
                                            } else {
                                                finalData = mergedData;
                                            }
                                            
                                            // Fix: Check form exists before populating
                                            if (checkFormExists() && formStillExists) {
                                                institutionWidget.populateHubSpotForm(finalData);
                                            }
                                        } catch (err) {
                                            // Error getting building data, continue with merged data
                                        }
                                    }
                                } else {
                                    // No personnel data, just populate with institution
                                    // Fix: Check form exists before populating
                                    if (checkFormExists() && formStillExists) {
                                        institutionWidget.populateHubSpotForm(selectedInstitution);
                                    }
                                    
                                    // Get building details
                                    if ((selectedInstitution.instUid || selectedInstitution.uid) && checkFormExists() && formStillExists) {
                                        const instUid = selectedInstitution.instUid || selectedInstitution.uid;
                                        try {
                                            const buildingData = await agileEdAPI.getBuildingInDistrict(instUid);
                                            
                                            // Fix: Check form exists before processing
                                            if (!checkFormExists() || !formStillExists) {
                                                return;
                                            }
                                            
                                            let finalData = buildingData;
                                            if (Array.isArray(buildingData) && buildingData.length > 0) {
                                                const matchingBuilding = buildingData.find(b => 
                                                    (b.instUid && b.instUid.toString() === instUid.toString()) ||
                                                    (b.uid && b.uid.toString() === instUid.toString())
                                                );
                                                
                                                const districtData = buildingData.find(b => 
                                                    b.parentUid && b.parentUid.toString() === instUid.toString()
                                                ) || buildingData[0];
                                                
                                                finalData = {
                                                    ...(matchingBuilding || districtData),
                                                    ...selectedInstitution
                                                };
                                            } else if (buildingData && typeof buildingData === 'object') {
                                                finalData = {
                                                    ...buildingData,
                                                    ...selectedInstitution
                                                };
                                            } else {
                                                finalData = selectedInstitution;
                                            }
                                            
                                            // Fix: Check form exists before populating
                                            if (checkFormExists() && formStillExists) {
                                                institutionWidget.populateHubSpotForm(finalData);
                                            }
                                        } catch (err) {
                                            // Error handled - log for debugging
                                            logError('Error fetching building data:', err);
                                        }
                                    }
                                }
                            } catch (err) {
                                // Personnel API failed, just populate with institution
                                // Fix: Check form exists before populating
                                if (checkFormExists() && formStillExists) {
                                    institutionWidget.populateHubSpotForm(selectedInstitution);
                                }
                                
                                // Get building details
                                if ((selectedInstitution.instUid || selectedInstitution.uid) && checkFormExists() && formStillExists) {
                                    const instUid = selectedInstitution.instUid || selectedInstitution.uid;
                                    try {
                                        const buildingData = await agileEdAPI.getBuildingInDistrict(instUid);
                                        
                                        // Fix: Check form exists before processing
                                        if (!checkFormExists() || !formStillExists) {
                                            return;
                                        }
                                        
                                        let finalData = buildingData;
                                        if (Array.isArray(buildingData) && buildingData.length > 0) {
                                            const matchingBuilding = buildingData.find(b => 
                                                (b.instUid && b.instUid.toString() === instUid.toString()) ||
                                                (b.uid && b.uid.toString() === instUid.toString())
                                            );
                                            
                                            const districtData = buildingData.find(b => 
                                                b.parentUid && b.parentUid.toString() === instUid.toString()
                                            ) || buildingData[0];
                                            
                                            finalData = {
                                                ...(matchingBuilding || districtData),
                                                ...selectedInstitution
                                            };
                                        } else if (buildingData && typeof buildingData === 'object') {
                                            finalData = {
                                                ...buildingData,
                                                ...selectedInstitution
                                            };
                                        } else {
                                            finalData = selectedInstitution;
                                        }
                                        
                                        // Fix: Check form exists before populating
                                        if (checkFormExists() && formStillExists) {
                                            institutionWidget.populateHubSpotForm(finalData);
                                        }
                                    } catch (error) {
                                        // Error handled - log for debugging
                                        logError('Error fetching building data:', error);
                                    }
                                }
                            }
                        })();
                    } else {
                        // No email, just populate with institution and get building details
                        // Fix: Check form exists before populating
                        if ($form && $form.length && $form[0].parentNode && document.body.contains($form[0])) {
                            institutionWidget.populateHubSpotForm(selectedInstitution);
                        }
                        
                        if ((selectedInstitution.instUid || selectedInstitution.uid) && $form && $form.length && $form[0].parentNode && document.body.contains($form[0])) {
                            const instUid = selectedInstitution.instUid || selectedInstitution.uid;
                            
                            agileEdAPI.getBuildingInDistrict(instUid).then(buildingData => {
                                // Fix: Check form exists before processing
                                if (!$form || !$form.length || !$form[0].parentNode || !document.body.contains($form[0])) {
                                    return;
                                }
                                let finalData = buildingData;
                                if (Array.isArray(buildingData) && buildingData.length > 0) {
                                    const matchingBuilding = buildingData.find(b => 
                                        (b.instUid && b.instUid.toString() === instUid.toString()) ||
                                        (b.uid && b.uid.toString() === instUid.toString())
                                    );
                                    
                                    const districtData = buildingData.find(b => 
                                        b.parentUid && b.parentUid.toString() === instUid.toString()
                                    ) || buildingData[0];
                                    
                                    finalData = {
                                        ...(matchingBuilding || districtData),
                                        ...selectedInstitution
                                    };
                                } else if (buildingData && typeof buildingData === 'object') {
                                    finalData = {
                                        ...buildingData,
                                        ...selectedInstitution
                                    };
                                } else {
                                    finalData = selectedInstitution;
                                }
                                
                                // Fix: Check form exists before populating
                                if ($form && $form.length && $form[0].parentNode && document.body.contains($form[0])) {
                                    institutionWidget.populateHubSpotForm(finalData);
                                }
                            }).catch(error => {
                                // Error handled - log for debugging
                                logError('Error fetching building data:', error);
                            });
                        }
                    }
                    
                    // Don't reset the flag here - it will be reset when user types something different
                };
                
                // Attach both mouse and touch events for better mobile support
                $item.on('mousedown touchstart', function(e) {
                    // Fix: Set flag for this form instance only
                    if (formData) {
                        formData.interactingWithAutocomplete = true;
                    }
                    handleItemSelection.call(this, e);
                });
                
                $autocompleteContainer.append($item);
            });
            
            // Ensure container is in DOM (should be in field container for absolute positioning)
            // Only append if container is not in DOM or doesn't have a parent
            if (!document.body.contains($autocompleteContainer[0]) || $autocompleteContainer.parent().length === 0) {
                // Safely append autocomplete container
                try {
                    // Re-get container in case DOM changed
                    $companyFieldContainer = getCompanyFieldContainer();
                    if (!$companyFieldContainer || !$companyFieldContainer.length) {
                        // Fallback: use company field's parent
                        $companyFieldContainer = companyField.parent();
                    }
                    
                    // Use isConnected for iframe/shadow DOM support
                    // Container might be in an iframe, so check ownerDocument instead of document.body.contains
                    let containerElement = $companyFieldContainer && $companyFieldContainer[0];
                    const containerIsValid = containerElement && 
                                           (containerElement.isConnected || 
                                            (containerElement.ownerDocument && containerElement.ownerDocument.body && 
                                             containerElement.ownerDocument.body.contains(containerElement)));
                    
                    if (!containerIsValid) {
                        // Try to re-find the container
                        $companyFieldContainer = getCompanyFieldContainer();
                        const retryContainerElement = $companyFieldContainer && $companyFieldContainer[0];
                        const retryIsValid = retryContainerElement && 
                                           (retryContainerElement.isConnected || 
                                            (retryContainerElement.ownerDocument && retryContainerElement.ownerDocument.body && 
                                             retryContainerElement.ownerDocument.body.contains(retryContainerElement)));
                        
                        if (!retryIsValid) {
                            // Only log error if retry also fails
                            debugWarn('Cannot append autocomplete container - companyFieldContainer not found or not in DOM', {
                                hasContainer: !!$companyFieldContainer,
                                containerLength: $companyFieldContainer ? $companyFieldContainer.length : 0,
                                isConnected: retryContainerElement ? retryContainerElement.isConnected : false,
                                hasOwnerDocument: retryContainerElement && retryContainerElement.ownerDocument ? true : false,
                                ownerDocumentBody: retryContainerElement && retryContainerElement.ownerDocument && retryContainerElement.ownerDocument.body ? true : false
                            });
                            return; // Container no longer exists
                        } else {
                            // Update containerElement with retry result
                            containerElement = retryContainerElement;
                        }
                    }
                    
                    // Check if autocomplete is already appended to this container (use isConnected for iframe/shadow DOM support)
                    const autocompleteElement = $autocompleteContainer[0];
                    const containerDoc = containerElement ? (containerElement.ownerDocument || document) : document;
                    const alreadyAppended = $autocompleteContainer.parent().length && 
                                          $autocompleteContainer.parent()[0] === containerElement &&
                                          (autocompleteElement.isConnected || 
                                           (containerDoc.body && containerDoc.body.contains(autocompleteElement)));
                    
                    if (alreadyAppended) {
                        // Already in correct position and in DOM - don't touch it!
                        debugLog('Container already in correct position - skipping DOM manipulation');
                    } else {
                        // Define currentParent in outer scope so it's accessible in the append section
                        const currentParent = $autocompleteContainer.parent().length ? $autocompleteContainer.parent()[0] : null;
                        
                        // CRITICAL: Skip ALL DOM manipulation if email input is active
                        if (emailInputActive) {
                            debugLog('Email input active - skipping all DOM manipulation to prevent conflicts');
                        } else {
                            // Only detach if container is in a DIFFERENT parent (not the target parent)
                            // This prevents unnecessary DOM manipulation that can break HubSpot's form structure
                            const needsDetach = currentParent && currentParent !== containerElement;
                            
                            if (needsDetach) {
                                // Container is in wrong parent - detach safely
                                try {
                                    // Use jQuery detach which is safer than removeChild
                                    // Only detach if element is actually a child (prevents removeChild errors)
                                    if (currentParent && autocompleteElement && currentParent.contains(autocompleteElement)) {
                                        $autocompleteContainer.detach();
                                        debugLog('Container detached from previous parent');
                                    } else {
                                        // Element is not actually a child - it might have been moved by HubSpot
                                        // Just clear the jQuery reference, don't try to remove it
                                        debugWarn('Container parent mismatch - element may have been moved by HubSpot');
                                    }
                                } catch (detachError) {
                                    // Ignore detach errors - element might already be removed or moved by HubSpot
                                    debugWarn('Error detaching autocomplete container (non-critical, HubSpot may have moved it):', detachError);
                                    // Don't throw - just continue without detaching
                                }
                            } else if (!currentParent) {
                                // Container has no parent - it was already removed, which is fine
                                debugLog('Container has no parent - will append to target container');
                            } else {
                                // Container is already in the target parent but check failed - skip detach
                                debugLog('Container appears to be in target parent - skipping detach');
                            }
                            
                            // CRITICAL: Skip append if email input is active
                            if (emailInputActive) {
                                debugLog('Email input active - skipping append to prevent DOM conflicts');
                            } else {
                                // Verify container is still valid before appending
                                const containerIsStillValid = containerElement && 
                                                             (containerElement.isConnected || 
                                                              (containerDoc.body && containerDoc.body.contains(containerElement)));
                                
                                if (containerIsStillValid) {
                                // Double-check: if container is already in the correct parent, don't append again
                                const isAlreadyInTarget = currentParent === containerElement &&
                                                          (autocompleteElement.isConnected || 
                                                           (containerDoc.body && containerDoc.body.contains(autocompleteElement)));
                                
                                    if (isAlreadyInTarget) {
                                        debugLog('Container already in target parent - skipping append to prevent DOM errors');
                                    } else {
                                        // Append to current container (handle iframe cases)
                                        try {
                                            if (containerDoc !== document && containerElement) {
                                                // Container is in an iframe - use native appendChild
                                                containerElement.appendChild(autocompleteElement);
                                            } else {
                                                // Regular DOM - use jQuery append
                                                $companyFieldContainer.append($autocompleteContainer);
                                            }
                                            
                                            // Verify it was actually appended
                                            const isNowAppended = autocompleteElement.isConnected || 
                                                                 (containerDoc.body && containerDoc.body.contains(autocompleteElement));
                                            
                                            if (!isNowAppended) {
                                                debugWarn('Container append verification failed - container may be in iframe');
                                            } else {
                                                debugLog('Container appended to DOM successfully', {
                                                    parentElement: containerElement,
                                                    containerInDOM: containerDoc.body && containerDoc.body.contains(autocompleteElement)
                                                });
                                            }
                                        } catch (appendError) {
                                            // Fallback: try native appendChild
                                            try {
                                                if (containerElement && autocompleteElement) {
                                                    containerElement.appendChild(autocompleteElement);
                                                } else {
                                                    debugWarn('Cannot append - elements not available');
                                                    // Don't return - just log and continue to prevent form disappearance
                                                }
                                            } catch (nativeAppendError) {
                                                // Don't throw - just log and continue to prevent form disappearance
                                                debugWarn('Error appending autocomplete container (both methods failed, continuing anyway):', {
                                                    jqueryError: appendError,
                                                    nativeError: nativeAppendError
                                                });
                                                // Don't return - allow code to continue
                                            }
                                        }
                                    }
                                } else {
                                    debugWarn('Container not valid - cannot append', {
                                        hasContainer: !!containerElement,
                                        isConnected: containerElement ? containerElement.isConnected : false,
                                        hasOwnerDocument: containerElement && containerElement.ownerDocument ? true : false
                                    });
                                    // Don't return - just log and continue
                                }
                            }
                        }
                    }
                } catch (appendContainerError) {
                    // Ignore append errors - HubSpot may have moved it already
                    debugWarn('Error appending container (HubSpot may have moved it):', appendContainerError);
                }
            }
            
            // Final check - container must be in DOM before showing
            // Use isConnected for iframe support (containerInBody might be false in iframes)
            const containerIsInDOM = $autocompleteContainer[0] && 
                                   ($autocompleteContainer[0].isConnected || 
                                    document.body.contains($autocompleteContainer[0]) ||
                                    $autocompleteContainer.parent().length > 0);
            
            if (!containerIsInDOM) {
                logError('Container not in DOM after all append attempts - cannot show dropdown', {
                    isConnected: $autocompleteContainer[0] ? $autocompleteContainer[0].isConnected : false,
                    inBody: $autocompleteContainer[0] ? document.body.contains($autocompleteContainer[0]) : false,
                    hasParent: $autocompleteContainer.parent().length > 0
                });
                return;
            }
            
            // Force show the dropdown - use jQuery show() first, then apply styles
            debugLog('Showing autocomplete dropdown:', {
                resultsCount: results.length,
                containerElement: $autocompleteContainer[0],
                containerParent: $autocompleteContainer.parent()[0],
                containerInDOM: document.body.contains($autocompleteContainer[0])
            });
            
            // CRITICAL: Show the container - this fixes the display: none issue
            // Use multiple methods to ensure it's visible
            $autocompleteContainer.show();
            $autocompleteContainer.css('display', 'block');
            $autocompleteContainer.css('visibility', 'visible');
            $autocompleteContainer.css('opacity', '1');
            
            // Force show with inline styles using !important to override any CSS
            if ($autocompleteContainer[0]) {
                // Remove display: none if it exists, then set to block
                $autocompleteContainer[0].style.removeProperty('display');
                $autocompleteContainer[0].style.removeProperty('visibility');
                $autocompleteContainer[0].style.removeProperty('opacity');
                $autocompleteContainer[0].style.setProperty('display', 'block', 'important');
                $autocompleteContainer[0].style.setProperty('visibility', 'visible', 'important');
                $autocompleteContainer[0].style.setProperty('opacity', '1', 'important');
                $autocompleteContainer[0].style.setProperty('z-index', '99999', 'important');
                
                // Immediate check and force if needed
                const forceDisplay = () => {
                    if ($autocompleteContainer[0]) {
                        const computedStyle = window.getComputedStyle($autocompleteContainer[0]);
                        if (computedStyle.display === 'none' || computedStyle.visibility === 'hidden' || computedStyle.opacity === '0') {
                            // Still hidden - force it again
                            $autocompleteContainer[0].style.setProperty('display', 'block', 'important');
                            $autocompleteContainer[0].style.setProperty('visibility', 'visible', 'important');
                            $autocompleteContainer[0].style.setProperty('opacity', '1', 'important');
                            debugWarn('Dropdown was hidden - forcing display again', {
                                display: computedStyle.display,
                                visibility: computedStyle.visibility,
                                opacity: computedStyle.opacity
                            });
                        }
                        
                        debugLog('Dropdown styles applied:', {
                            display: computedStyle.display,
                            visibility: computedStyle.visibility,
                            opacity: computedStyle.opacity,
                            zIndex: computedStyle.zIndex,
                            position: computedStyle.position,
                            top: computedStyle.top,
                            left: computedStyle.left,
                            isVisible: computedStyle.display !== 'none' && computedStyle.visibility !== 'hidden' && computedStyle.opacity !== '0'
                        });
                    }
                };
                
                // Check immediately
                forceDisplay();
                
                // Check again after a short delay
                setTimeout(forceDisplay, 10);
                setTimeout(forceDisplay, 50);
                setTimeout(forceDisplay, 100);
                
                // Final verification after all checks
                setTimeout(() => {
                    if ($autocompleteContainer[0]) {
                        const finalStyle = window.getComputedStyle($autocompleteContainer[0]);
                        const isVisible = finalStyle.display !== 'none' && 
                                         finalStyle.visibility !== 'hidden' && 
                                         finalStyle.opacity !== '0' &&
                                         $autocompleteContainer.is(':visible');
                        
                        debugLog('Final dropdown visibility check:', {
                            display: finalStyle.display,
                            visibility: finalStyle.visibility,
                            opacity: finalStyle.opacity,
                            isVisible: isVisible,
                            hasResults: results.length,
                            containerInDOM: $autocompleteContainer[0].isConnected || document.body.contains($autocompleteContainer[0])
                        });
                        
                        if (!isVisible && results.length > 0) {
                            // Still not visible - try one more time with maximum force
                            $autocompleteContainer.show();
                            $autocompleteContainer[0].style.setProperty('display', 'block', 'important');
                            $autocompleteContainer[0].style.setProperty('visibility', 'visible', 'important');
                            $autocompleteContainer[0].style.setProperty('opacity', '1', 'important');
                            
                            debugWarn('Dropdown still not visible after all attempts - forcing one final time');
                        }
                    }
                }, 200);
            }
            
            // Track mouse interaction with autocomplete container
            // Fix: Use form-specific flag
            $autocompleteContainer.on('mouseenter', function() {
                if (formData) {
                    formData.interactingWithAutocomplete = true;
                }
            });
            
            $autocompleteContainer.on('mouseleave', function() {
                // Clear flag when mouse leaves, but with a small delay to allow clicking
                setTimeout(() => {
                    if (formData) {
                        // Only clear if focus is not on an autocomplete item
                        const activeElement = document.activeElement;
                        if (!activeElement || (!$(activeElement).closest('.institution-autocomplete').length && !$(activeElement).hasClass('autocomplete-item'))) {
                            formData.interactingWithAutocomplete = false;
                        }
                    }
                }, 100);
            });
            
            // Also set via jQuery as backup
            $autocompleteContainer.css({
                'display': 'block',
                'visibility': 'visible',
                'opacity': '1',
                'z-index': '99999'
            });
            
            // Position dropdown immediately to ensure it's below the field
            positionDropdown();
            
            // Use setTimeout to ensure DOM is updated before final positioning and padding
            // Store timeout ID for cleanup
            if (positionTimeout) clearTimeout(positionTimeout);
            positionTimeout = setTimeout(() => {
                // Re-position to ensure correct placement after DOM updates
                positionDropdown();
                
                // Dynamically set padding based on actual dropdown height
                updateContainerPadding();
                
                // Double-check visibility after positioning using getComputedStyle
                if ($autocompleteContainer[0]) {
                    const display = window.getComputedStyle($autocompleteContainer[0]).display;
                    if (display === 'none') {
                        $autocompleteContainer[0].style.setProperty('display', 'block', 'important');
                        $autocompleteContainer.css({
                            'display': 'block',
                            'visibility': 'visible',
                            'opacity': '1'
                        });
                        positionDropdown();
                        updateContainerPadding();
                    }
                }
            }, 10);
            } catch (domError) {
                // CRITICAL: Catch ALL DOM errors to prevent form from disappearing
                // This prevents HubSpot's insertBefore errors from breaking the form
                const errorText = domError ? (domError.message || domError.toString() || String(domError)) : 'Unknown error';
                debugWarn('DOM error in displayAutocompleteResults (suppressed to prevent form disappearance):', errorText);
                // Don't rethrow - just log and continue
                // The form will remain visible even if dropdown fails to show
            }
        };
        
        // Reposition dropdown on scroll and window resize
        const repositionHandler = function() {
            if ($autocompleteContainer.is(':visible')) {
                positionDropdown();
                updateContainerPadding();
            }
        };
        
        $(window).on('scroll.autocomplete resize.autocomplete', repositionHandler);
        
        // Cleanup on form destroy
        // Fix: Store cleanup functions in array to support multiple form instances
        if (!window.SecurlyForm.cleanupFunctions) {
            window.SecurlyForm.cleanupFunctions = [];
        }
        
        // Handle clicks outside dropdown to hide it
        const handleDocumentClick = function(e) {
            // Check if click is outside the dropdown and company field
            if (!$autocompleteContainer.is(e.target) && 
                $autocompleteContainer.has(e.target).length === 0 &&
                !companyField.is(e.target) &&
                companyField.has(e.target).length === 0) {
                // Click is outside - hide dropdown
                if ($autocompleteContainer.is(':visible')) {
                    $autocompleteContainer.hide().empty();
                    updateContainerPadding();
                }
            }
        };
        
        // Attach document click handler with unique namespace
        const formId = $form.attr('id') || 'form-' + Date.now();
        $(document).on('click.autocomplete-' + formId, handleDocumentClick);
        
        const cleanupFn = function() {
            clearTimeout(autocompleteTimeout);
            clearTimeout(positionTimeout);
            $(window).off('scroll.autocomplete resize.autocomplete');
            $(document).off('click.autocomplete-' + formId);
            companyField.off('input blur keydown');
            if (emailField && emailField.length) {
                emailField.off('input');
            }
            // Fix: Cleanup MutationObserver
            if (emailFieldObserver) {
                emailFieldObserver.disconnect();
                emailFieldObserver = null;
            }
            $autocompleteContainer.remove();
            // Fix: Remove form instance data on cleanup
            if (window.SecurlyForm.instances) {
                window.SecurlyForm.instances.delete(formInstanceId);
            }
        };
        
        window.SecurlyForm.cleanupFunctions.push(cleanupFn);
        
        // Create master cleanup function that calls all cleanup functions
        const originalCleanup = window.SecurlyForm.cleanup;
        window.SecurlyForm.cleanup = function() {
            if (window.SecurlyForm.cleanupFunctions) {
                window.SecurlyForm.cleanupFunctions.forEach(fn => {
                    try {
                        fn();
                    } catch (e) {
                        logError('Error in cleanup function:', e);
                    }
                });
                window.SecurlyForm.cleanupFunctions = [];
            }
            if (originalCleanup) {
                originalCleanup();
            }
        };
        
        // Handle input events on company field
        // CRITICAL: Always attach input handler, even if container setup had issues
        try {
            debugLog('Attaching input handler to company field', {
                fieldElement: companyField[0],
                fieldValue: companyField.val(),
                fieldLength: companyField.length,
                hasContainer: !!$companyFieldContainer && $companyFieldContainer.length > 0
            });
            
            companyField.on('input', function() {
            const searchValue = $(this).val().trim();
            
            // CRITICAL: If field is cleared (empty), reset all selection flags immediately
            // This ensures dropdown will show when user starts typing again
            if (!searchValue || searchValue.length === 0) {
                debugLog('School field cleared - resetting all selection flags to allow dropdown when typing starts');
                schoolSelectedFromAutocomplete = false;
                lastSelectedSchoolName = '';
                lastEmailDomainWhenSchoolSelected = '';
                // Don't return - allow the rest of the logic to run (might trigger state search)
            }
            
            // Check if this input was triggered by auto-population from email search
            // If so, show all domain search results instead of filtering
            if (formData && formData.schoolPopulatedFromEmail && formData.domainSearchResults && Array.isArray(formData.domainSearchResults) && formData.domainSearchResults.length > 0) {
                // Field was just populated from email - show all domain results
                debugLog('Company field input after email population - showing all domain results', {
                    domainResultsCount: formData.domainSearchResults.length,
                    searchValue: searchValue
                });
                
                // Set flag to show domain results
                if (formData) {
                    formData.showDomainSearchResults = true;
                }
                
                // Clear the populated flag so next input will work normally
                if (formData) {
                    formData.schoolPopulatedFromEmail = false;
                }
            }
            
            debugLog('Company field input event fired!', {
                searchValue: searchValue,
                fieldValue: $(this).val(),
                timestamp: new Date().toISOString(),
                showDomainResults: formData && formData.showDomainSearchResults,
                schoolSelectedFromAutocomplete: schoolSelectedFromAutocomplete,
                lastSelectedSchoolName: lastSelectedSchoolName
            });
            
            clearTimeout(autocompleteTimeout);
            
            // Cancel any pending district search request when user types
            if (districtSearchAbortController) {
                districtSearchAbortController.abort();
                districtSearchAbortController = null;
            }
            
            // If user is typing something different from the selected school, reset the flag
            // This allows search to proceed when user modifies the field
            if (schoolSelectedFromAutocomplete) {
                if (searchValue !== lastSelectedSchoolName) {
                    // User is typing something different - allow search
                    debugLog('User typing different text - resetting selection flags');
                    schoolSelectedFromAutocomplete = false;
                    lastSelectedSchoolName = '';
                    lastEmailDomainWhenSchoolSelected = ''; // Clear email domain tracking
                } else if (searchValue.length > 0) {
                    // User is typing the same school name that was selected - don't show dropdown
                    debugLog('School was selected and value matches - not showing dropdown');
                    $autocompleteContainer.hide().empty();
                    updateContainerPadding();
                    return; // Exit early, don't trigger search
                }
            }
            
            // Only block autocomplete if school was selected AND value matches exactly AND user is not actively typing
            // But since user is typing (this is an input event), always allow search to proceed
            // The check in searchDistricts will handle the actual blocking logic
            
            // Don't block autocomplete based on emailSearchSucceeded - allow school search even after email search
            // Trigger search when typing (will check email domain first, then country/state)
            // Use standard debounce delay (400ms) to wait for user to stop typing
            // IMPORTANT: Always trigger search when user types - this ensures dropdown shows
            // IMPORTANT: Always trigger search when user types, even if email domain search fails
            debugLog('Company field input triggered:', {
                searchValue: searchValue,
                searchValueLength: searchValue ? searchValue.length : 0,
                DEBOUNCE_DELAY: DEBOUNCE_DELAY,
                schoolSelectedFromAutocomplete: schoolSelectedFromAutocomplete,
                lastSelectedSchoolName: lastSelectedSchoolName,
                hasState: stateField && stateField.length && stateField.val() ? true : false,
                stateValue: stateField && stateField.length ? stateField.val() : null
            });
            
            autocompleteTimeout = setTimeout(() => {
                // CRITICAL: Before making API call, check if we have cached results for current state
                // If cached results exist, filter them client-side instead of making API call
                // This prevents API failures from breaking autocomplete when typing
                if (stateField && stateField.length && stateField.val()) {
                    const currentStateValue = stateField.val();
                    const countryValue = countryField.length ? countryField.val() : null;
                    const isUSCountry = countryValue === 'United States' || countryValue === 'US' || countryValue === 'USA';
                    
                    if (isUSCountry) {
                        try {
                            const stateCode = institutionWidget.getStateCode(currentStateValue);
                            if (stateCode && typeof stateCode === 'string' && stateCode.length === 2) {
                                const cacheKey = `state:${stateCode}`;
                                const cached = apiCache.stateSearch.get(cacheKey);
                                
                                // If we have valid cached results, use them instead of making API call
                                if (cached && (Date.now() - cached.timestamp) < CACHE_DURATION) {
                                    const districts = cached.data;
                                    if (Array.isArray(districts) && districts.length > 0) {
                                        debugLog('Using cached results for typing (avoiding API call):', {
                                            searchValue: searchValue,
                                            cachedResultsCount: districts.length
                                        });
                                        
                                        // Filter by search value (allow filtering even with 1 character)
                                        // CRITICAL: Ensure searchValue is trimmed and case-insensitive matching works correctly
                                        let filtered = districts;
                                        if (searchValue && searchValue.length >= 1) {
                                            const searchLower = String(searchValue).trim().toLowerCase();
                                            filtered = districts.filter(d => {
                                                const name = (d.institutionNameProper || d.institutionName || d.name || d.districtName || d.DistrictName || '').toString();
                                                const nameLower = name.toLowerCase();
                                                // Check if search text appears anywhere in the name
                                                return nameLower.includes(searchLower);
                                            });
                                            debugLog('Filtered cached results for typing:', {
                                                searchValue: searchValue,
                                                searchLower: searchLower,
                                                totalDistricts: districts.length,
                                                filteredCount: filtered.length,
                                                firstFilteredName: filtered.length > 0 ? (filtered[0].institutionNameProper || filtered[0].institutionName || 'N/A') : 'N/A'
                                            });
                                        }
                                        
                                        // If field is empty, show all districts. If typing, show filtered results
                                        const resultsToShow = (searchValue && searchValue.length >= 1) ? filtered : districts;
                                        
                                        // If user is typing and no results match, hide dropdown
                                        if (searchValue && searchValue.length >= 1 && filtered.length === 0) {
                                            debugLog('No schools match search value (cached) - hiding dropdown', {
                                                searchValue: searchValue,
                                                totalDistricts: districts.length
                                            });
                                            $autocompleteContainer.hide().empty();
                                            updateContainerPadding();
                                            return; // Don't make API call
                                        }
                                        
                                        if (resultsToShow.length > 0) {
                                            // Check if domain results should be shown instead
                                            const hasDomainResults = formData && formData.domainSearchResults && Array.isArray(formData.domainSearchResults) && formData.domainSearchResults.length > 0;
                                            const isShowingDomainResults = formData && formData.showDomainSearchResults && hasDomainResults;
                                            const isBlockingStateSearch = formData && formData.blockStateSearch;
                                            
                                            if (!isShowingDomainResults && !isBlockingStateSearch) {
                                                autocompleteResults = resultsToShow;
                                                displayAutocompleteResults(resultsToShow);
                                                return; // Don't make API call - use cached results
                                            }
                                        }
                                    }
                                }
                            }
                        } catch (cacheError) {
                            debugWarn('Error checking cache for typing - will proceed with API call:', cacheError);
                        }
                    }
                }
                
                // No cached results or cache check failed - proceed with normal API call
                debugLog('Calling searchDistricts after debounce (no valid cache):', searchValue);
                searchDistricts(searchValue);
            }, DEBOUNCE_DELAY);
            });
        
            debugLog('Input handler attached successfully to company field');
        } catch (e) {
            logError('Error attaching input handler to company field:', e);
        }
        
        // Trigger search when state changes (to show schools for selected state)
        // This handles the case when user manually selects country and state for unknown emails
        if (stateField && stateField.length) {
            stateField.on('change', function() {
                // Cancel any pending district search request when state changes
                if (districtSearchAbortController) {
                    districtSearchAbortController.abort();
                    districtSearchAbortController = null;
                }
                
                // Also clear any pending debounce timeout
                clearTimeout(autocompleteTimeout);
                
                const stateValue = $(this).val();
                const companyValue = companyField.val().trim();
                
                // CRITICAL: Check country field - only search if country is United States
                const countryField = $form.find('select[name="country__new_"]').first();
                const countryValue = countryField.length ? countryField.val() : null;
                const isUSCountry = countryValue === 'United States' || countryValue === 'US' || countryValue === 'USA';
                
                debugLog('State field changed:', {
                    stateValue: stateValue,
                    countryValue: countryValue,
                    isUSCountry: isUSCountry,
                    companyValue: companyValue,
                    stateFieldLength: stateField.length,
                    stateFieldName: stateField.attr('name')
                });
                
                // Only trigger search if state is selected and country is United States
                if (stateValue && stateValue.length > 0) {
                    if (!isUSCountry) {
                        debugLog('State selected but country is not United States - skipping search');
                        $autocompleteContainer.hide().empty();
                        lastSearchedStateValue = null;
                        isDistrictSearching = false;
                        return;
                    }
                    
                    // CRITICAL: Always reset last searched state to force new search
                    // This ensures that even after an error with an invalid state, a new valid state will trigger a search
                    lastSearchedStateValue = null;
                    
                    // Also reset the searching flag to allow new searches
                    isDistrictSearching = false;
                    
                    // CRITICAL: Re-find the US states field to ensure we have the latest value
                    const usStateField = $form.find('select[name="us_states"]').first();
                    const actualStateValue = usStateField.length ? usStateField.val() : stateValue;
                    
                    debugLog('US state selected, triggering search:', {
                        actualStateValue: actualStateValue,
                        originalStateValue: stateValue
                    });
                    
                    // If school field is empty, show all schools for the selected state
                    // If user is typing, the input handler will handle it
                    if (!companyValue || companyValue.length === 0) {
                        debugLog('State selected, school field empty - triggering search for all schools in state');
                        clearTimeout(autocompleteTimeout);
                        autocompleteTimeout = setTimeout(() => {
                            // Pass empty string to show all schools for the state
                            searchDistricts('');
                        }, 200); // Short delay to ensure state field value is updated
                    } else {
                        // School field has value - trigger search with current value
                        debugLog('State selected, school field has value - triggering search with current value');
                        clearTimeout(autocompleteTimeout);
                        autocompleteTimeout = setTimeout(() => {
                            searchDistricts(companyValue);
                        }, 200);
                    }
                } else {
                    // State cleared - hide dropdown and reset state tracking
                    debugLog('State cleared - hiding dropdown');
                    $autocompleteContainer.hide().empty();
                    lastSearchedStateValue = null;
                    isDistrictSearching = false;
                }
            });
            
            debugLog('Change handler attached successfully to state field');
        }
        
        // Also trigger search when email changes (to show schools by domain in School field)
        if (emailField && emailField.length) {
            let lastEmailValue = emailField.val().trim();
            
            // Store references in closure for deferred population
            const $formRef = $form;
            const institutionWidgetRef = institutionWidget;
            const selfRef = self;
            
            // #region agent log
            debugInstrument('agile-ed-form-integration.js:6130', 'Attaching email input handler', {hasEmailField:!!emailField,emailFieldLength:emailField?.length,hasFormData:!!formData,hasStartCssMonitoring:!!formData?.startCssMonitoring}, 'CSS7');
            // #endregion
            
            emailField.on('input', function() {
                // CRITICAL: Wrap entire handler in try-catch to prevent any errors from breaking the form
                try {
                    // #region agent log
                    debugInstrument('agile-ed-form-integration.js:6138', 'Email input handler called', {hasFormData:!!formData,emailValue:$(this).val()}, 'CSS7');
                    // #endregion
                    
                    const currentEmailValue = $(this).val().trim();
                    // Use formData.lastSearchedEmail if available, otherwise fallback to empty string
                    const previousEmailValue = (formData && formData.lastSearchedEmail) ? formData.lastSearchedEmail : '';
                    
                    // #region agent log
                    debugInstrument('agile-ed-form-integration.js:6142', 'Email input handler - processing', {currentEmailValue,previousEmailValue,hasFormData:!!formData}, 'CSS7');
                    // #endregion
                    
                    // CRITICAL: If email changed (especially domain), abort pending requests and clear stale data
                    if (previousEmailValue && currentEmailValue !== previousEmailValue) {
                        const previousDomain = previousEmailValue.includes('@') ? previousEmailValue.split('@')[1] : '';
                        const currentDomain = currentEmailValue.includes('@') ? currentEmailValue.split('@')[1] : '';
                        
                        // If domain changed, abort pending API requests
                        // CRITICAL: Use formData.currentRequestAbortController (not local variable)
                        const abortController = formData && formData.currentRequestAbortController ? formData.currentRequestAbortController : null;
                        if (previousDomain !== currentDomain && abortController) {
                            debugLog('Email domain changed - aborting pending API request', {
                                previousEmail: previousEmailValue,
                                currentEmail: currentEmailValue,
                                previousDomain: previousDomain,
                                currentDomain: currentDomain
                            });
                            try {
                                abortController.abort();
                            } catch (e) {
                                // Ignore abort errors
                            }
                            if (formData) {
                                formData.currentRequestAbortController = null;
                            }
                        }
                        
                        // Clear any pending form population from old email
                        if (formData) {
                            formData.pendingFormPopulation = null;
                            formData.domainSearchResults = null;
                            formData.mergedEmailResults = null;
                            debugLog('Cleared stale form population data due to email change');
                        }
                        
                        // Reset search flags
                        // CRITICAL: Use formData only (local variables are out of scope here)
                        if (formData) {
                            formData.lastSearchedEmail = null;
                            formData.emailSearchSucceeded = false;
                        }
                        
                        // CRITICAL: If domain changed, trigger a new API call after debounce
                        // This ensures the API fires when user changes email extension
                        if (previousDomain !== currentDomain && currentDomain && currentEmailValue.includes('@') && currentEmailValue.includes('.')) {
                            debugLog('Email domain changed - scheduling new API call', {
                                previousDomain: previousDomain,
                                currentDomain: currentDomain,
                                currentEmail: currentEmailValue
                            });
                            
                            // CRITICAL: Abort any pending API requests immediately when domain changes
                            const abortController = formData && formData.currentRequestAbortController ? formData.currentRequestAbortController : null;
                            if (abortController) {
                                try {
                                    abortController.abort();
                                    debugLog('Aborted pending API request due to domain change');
                                } catch (e) {
                                    // Ignore abort errors
                                }
                                if (formData) {
                                    formData.currentRequestAbortController = null;
                                }
                            }
                            
                            // Clear any existing domain change timeout
                            if (formData.domainChangeTimeout) {
                                clearTimeout(formData.domainChangeTimeout);
                                formData.domainChangeTimeout = null;
                            }
                            
                            // Schedule API call after longer debounce delay (1000ms) to ensure user has finished typing
                            // CRITICAL: Use formData to access emailField since it might not be in scope
                            const emailFieldForTimeout = emailField; // Capture emailField reference
                            const targetDomain = currentDomain; // Capture the target domain
                            formData.domainChangeTimeout = setTimeout(function() {
                                // Check if email is still valid and domain hasn't changed again
                                const finalEmailValue = emailFieldForTimeout.val().trim();
                                const finalDomain = finalEmailValue.includes('@') ? finalEmailValue.split('@')[1] : '';
                                
                                // CRITICAL: Only trigger if domain matches and email is complete
                                // This prevents triggering API with incomplete domains like "or" instead of "org"
                                if (finalEmailValue && finalEmailValue.includes('@') && finalEmailValue.includes('.') && 
                                    finalDomain === targetDomain && 
                                    finalDomain.length >= 3 && // Ensure domain is at least 3 characters (e.g., "org", "com")
                                    formData && formData.triggerEmailSearch && typeof formData.triggerEmailSearch === 'function') {
                                    
                                    // Double-check that domain hasn't changed again during the debounce delay
                                    const currentDomainCheck = finalEmailValue.includes('@') ? finalEmailValue.split('@')[1] : '';
                                    if (currentDomainCheck === targetDomain) {
                                        debugLog('Triggering API call after domain change', {
                                            email: finalEmailValue,
                                            domain: finalDomain,
                                            targetDomain: targetDomain
                                        });
                                        
                                        // Temporarily set emailInputActive to false to allow API call
                                        const wasEmailInputActive = formData.emailInputActive;
                                        formData.emailInputActive = false;
                                        
                                        // Trigger the API call
                                        formData.triggerEmailSearch(finalEmailValue, false).then(() => {
                                            // Restore emailInputActive state
                                            if (formData) {
                                                formData.emailInputActive = wasEmailInputActive;
                                            }
                                        }).catch(() => {
                                            // Restore emailInputActive state even on error
                                            if (formData) {
                                                formData.emailInputActive = wasEmailInputActive;
                                            }
                                        });
                                    } else {
                                        debugLog('Domain changed again during debounce - skipping API call', {
                                            originalDomain: targetDomain,
                                            currentDomain: currentDomainCheck
                                        });
                                    }
                                } else {
                                    debugLog('Email incomplete or domain mismatch - skipping API call', {
                                        finalEmailValue: finalEmailValue,
                                        finalDomain: finalDomain,
                                        targetDomain: targetDomain,
                                        domainLength: finalDomain ? finalDomain.length : 0
                                    });
                                }
                                
                                // Clear the timeout reference
                                if (formData) {
                                    formData.domainChangeTimeout = null;
                                }
                            }, 1000); // 1000ms debounce delay to ensure user has finished typing
                        }
                    }
                    
                    // CRITICAL: Set flag IMMEDIATELY at the very start to prevent ANY DOM operations
                    // This must be the FIRST thing we do to prevent HubSpot conflicts
                    // Store in formData so both initEmailField and initCompanyField can access it
                    if (formData) {
                        formData.emailInputActive = true;
                        formData.lastEmailInputTime = Date.now();
                        
                        // #region agent log
                        debugInstrument('agile-ed-form-integration.js:6177', 'Email input active - starting CSS monitoring', {emailValue:currentEmailValue,hasStartCssMonitoring:!!formData.startCssMonitoring,isFunction:typeof formData.startCssMonitoring === 'function',formDataKeys:Object.keys(formData)}, 'CSS7');
                        // #endregion
                        
                        // CRITICAL: Start continuous restoration loop using requestAnimationFrame
                        // This runs every frame to catch and restore hidden fields immediately
                        if (!formData.continuousRestoreAnimationFrame) {
                            // #region agent log
                            debugInstrument('agile-ed-form-integration.js:7502', 'Starting continuous restore loop', {hasForm:!!$form,formConnected:$form?.[0]?.isConnected}, 'CSS1');
                            // #endregion
                            
                            const continuousRestore = function() {
                                if (formData && formData.emailInputActive && $form && $form[0] && $form[0].isConnected) {
                                    try {
                                        const formFields = $form.find('input:not([type="hidden"]):not([type="submit"]):not([type="button"]), textarea, select, label, .hs-form-field, .hs-input');
                                        let restoredCount = 0;
                                        let checkedCount = 0;
                                        formFields.each(function() {
                                            const field = this;
                                            // Skip hidden inputs
                                            if (field.tagName === 'INPUT' && field.type === 'hidden') {
                                                return;
                                            }
                                            
                                            // CRITICAL: Check if field was originally hidden - if so, skip restoration
                                            const wasOriginallyHidden = formData.cssPreservedStyles && 
                                                                       formData.cssPreservedStyles.originalHiddenState && 
                                                                       formData.cssPreservedStyles.originalHiddenState[field] === true;
                                            
                                            if (wasOriginallyHidden) {
                                                // Field was originally hidden - keep it hidden, don't restore
                                                return;
                                            }
                                            
                                            // CRITICAL: Skip fields that are intentionally hidden by design
                                            // Check for hidden attribute, aria-hidden, or hidden classes
                                            if (field.hasAttribute('hidden') || 
                                                field.getAttribute('aria-hidden') === 'true' ||
                                                field.classList.contains('hs-hidden') ||
                                                field.classList.contains('hidden') ||
                                                field.classList.contains('sr-only') ||
                                                field.classList.contains('visually-hidden')) {
                                                return; // Skip intentionally hidden fields
                                            }
                                            
                                            // CRITICAL: For .hs-form-field containers, check if they contain hidden inputs
                                            // If they do, they should remain hidden
                                            if (field.classList.contains('hs-form-field')) {
                                                const hiddenInputs = field.querySelectorAll('input[type="hidden"]');
                                                if (hiddenInputs.length > 0) {
                                                    // Check if this container is meant to be hidden (only contains hidden inputs)
                                                    const visibleInputs = field.querySelectorAll('input:not([type="hidden"]):not([type="submit"]):not([type="button"]), textarea, select');
                                                    if (visibleInputs.length === 0) {
                                                        return; // Skip containers that only have hidden inputs
                                                    }
                                                }
                                            }
                                            
                                            // CRITICAL: Check if parent has hidden attribute or aria-hidden
                                            let parentElement = field.parentElement;
                                            const formElement = $form[0];
                                            while (parentElement && parentElement !== formElement) {
                                                if (parentElement.hasAttribute('hidden') || 
                                                    parentElement.getAttribute('aria-hidden') === 'true' ||
                                                    parentElement.classList.contains('hs-hidden') ||
                                                    parentElement.classList.contains('hidden')) {
                                                    return; // Skip fields with intentionally hidden parents
                                                }
                                                parentElement = parentElement.parentElement;
                                            }
                                            
                                            // CRITICAL: Check if field's original inline style had display:none
                                            // This indicates it was intentionally hidden by design
                                            const originalStyle = formData.cssPreservedStyles && 
                                                                 formData.cssPreservedStyles.elements && 
                                                                 formData.cssPreservedStyles.elements[field];
                                            if (originalStyle && (originalStyle.includes('display:none') || originalStyle.includes('display: none'))) {
                                                // Original style had display:none - keep it hidden
                                                return;
                                            }
                                            
                                            if (field.isConnected) {
                                                checkedCount++;
                                                const targetWindow = formData.iframeWindow || window;
                                                const computedStyle = targetWindow.getComputedStyle(field);
                                                
                                                // Check if parent is hiding the field
                                                let parentHiding = false;
                                                if (field.parentElement) {
                                                    const parentComputed = targetWindow.getComputedStyle(field.parentElement);
                                                    if (parentComputed.display === 'none' || parentComputed.visibility === 'hidden' || parseFloat(parentComputed.opacity) === 0) {
                                                        parentHiding = true;
                                                        field.parentElement.style.setProperty('display', 'block', 'important');
                                                        field.parentElement.style.setProperty('visibility', 'visible', 'important');
                                                        field.parentElement.style.setProperty('opacity', '1', 'important');
                                                    }
                                                }
                                                
                                                // CRITICAL: Check for additional CSS properties that could hide fields
                                                const fieldHeight = parseFloat(computedStyle.height);
                                                const fieldWidth = parseFloat(computedStyle.width);
                                                const fieldMaxHeight = parseFloat(computedStyle.maxHeight);
                                                const fieldMaxWidth = parseFloat(computedStyle.maxWidth);
                                                const fieldPosition = computedStyle.position;
                                                const fieldLeft = computedStyle.left;
                                                const fieldTop = computedStyle.top;
                                                const fieldTransform = computedStyle.transform;
                                                
                                                // Check if field has zero dimensions (hidden by height/width)
                                                const hasZeroDimensions = (fieldHeight === 0 && fieldWidth === 0) || 
                                                                          (fieldMaxHeight === 0) || 
                                                                          (fieldMaxWidth === 0);
                                                
                                                // Check if field is positioned off-screen
                                                const isOffScreen = fieldPosition === 'absolute' && 
                                                                    (fieldLeft === '-9999px' || fieldTop === '-9999px' || 
                                                                     parseFloat(fieldLeft) < -1000 || parseFloat(fieldTop) < -1000);
                                                
                                                // Check if field is transformed to be invisible
                                                const isTransformedAway = fieldTransform && 
                                                                          (fieldTransform.includes('scale(0)') || 
                                                                           fieldTransform.includes('translateX(-9999px)') ||
                                                                           fieldTransform.includes('translateY(-9999px)'));
                                                
                                                // CRITICAL: Also check bounding box - field might be hidden even if CSS says it's visible
                                                let isBoundingBoxHidden = false;
                                                try {
                                                    const boundingRect = field.getBoundingClientRect();
                                                    // Field is hidden if it has zero dimensions or is positioned off-screen
                                                    if (boundingRect.width === 0 && boundingRect.height === 0) {
                                                        isBoundingBoxHidden = true;
                                                    } else if (boundingRect.left < -1000 || boundingRect.top < -1000 || 
                                                               boundingRect.right < 0 || boundingRect.bottom < 0) {
                                                        isBoundingBoxHidden = true;
                                                    }
                                                } catch (e) {
                                                    // Ignore errors in bounding box check
                                                }
                                                
                                                if (computedStyle.display === 'none' || computedStyle.visibility === 'hidden' || parseFloat(computedStyle.opacity) === 0 || parentHiding || hasZeroDimensions || isOffScreen || isTransformedAway || isBoundingBoxHidden) {
                                                    field.style.setProperty('display', 'block', 'important');
                                                    field.style.setProperty('visibility', 'visible', 'important');
                                                    field.style.setProperty('opacity', '1', 'important');
                                                    
                                                    // Restore dimensions if zero
                                                    if (hasZeroDimensions || isBoundingBoxHidden) {
                                                        if (fieldHeight === 0 || parseFloat(computedStyle.height) === 0) {
                                                            field.style.setProperty('height', 'auto', 'important');
                                                        }
                                                        if (fieldWidth === 0 || parseFloat(computedStyle.width) === 0) {
                                                            field.style.setProperty('width', 'auto', 'important');
                                                        }
                                                        if (fieldMaxHeight === 0) {
                                                            field.style.setProperty('max-height', 'none', 'important');
                                                        }
                                                        if (fieldMaxWidth === 0) {
                                                            field.style.setProperty('max-width', 'none', 'important');
                                                        }
                                                    }
                                                    
                                                    // Restore position if off-screen
                                                    if (isOffScreen || isBoundingBoxHidden) {
                                                        field.style.setProperty('position', 'static', 'important');
                                                        field.style.setProperty('left', 'auto', 'important');
                                                        field.style.setProperty('top', 'auto', 'important');
                                                        field.style.setProperty('right', 'auto', 'important');
                                                        field.style.setProperty('bottom', 'auto', 'important');
                                                    }
                                                    
                                                    // Restore transform if transformed away
                                                    if (isTransformedAway) {
                                                        field.style.setProperty('transform', 'none', 'important');
                                                    }
                                                    
                                                    restoredCount++;
                                                    
                                                    // #region agent log
                                                    if (isBoundingBoxHidden || hasZeroDimensions || isOffScreen || isTransformedAway) {
                                                        debugInstrument('agile-ed-form-integration.js:7580', 'Field hidden by non-standard CSS - restored', {
                                                            fieldTag:field.tagName,
                                                            fieldType:field.type,
                                                            hasZeroDimensions,
                                                            isOffScreen,
                                                            isTransformedAway,
                                                            isBoundingBoxHidden
                                                        }, 'CSS1');
                                                    }
                                                    // #endregion
                                                }
                                            }
                                        });
                                        
                                        // CRITICAL: Check if CSS tag exists and content is intact, re-inject if missing or corrupted
                                        // This catches cases where HubSpot removes CSS tag or clears its content between our checks
                                        const targetDoc = formData.targetDocument || document;
                                        const targetHead = formData.targetHead || targetDoc.head;
                                        const cssTag = targetDoc.getElementById('agile-ed-hubspot-form-css');
                                        const cssTagExists = !!cssTag;
                                        const cssTagInHead = cssTag && targetHead && targetHead.contains(cssTag);
                                        
                                        // Check if CSS tag content is intact
                                        let cssTagContentLost = false;
                                        if (cssTag && formData.hubspotFormCSS) {
                                            const cssTagContentLength = (cssTag.textContent || cssTag.innerHTML || '').length;
                                            const expectedCssTagLength = formData.hubspotFormCSS.length;
                                            // If content is less than 50% of expected, consider it lost
                                            cssTagContentLost = cssTagContentLength < expectedCssTagLength * 0.5;
                                        }
                                        
                                        if (!cssTagExists || !cssTagInHead || cssTagContentLost) {
                                            // CSS tag is missing or content is corrupted - re-inject immediately
                                            if (formData.injectHubSpotFormCSS && typeof formData.injectHubSpotFormCSS === 'function') {
                                                try {
                                                    formData.injectHubSpotFormCSS();
                                                    // #region agent log
                                                    debugInstrument('agile-ed-form-integration.js:8058', 'CSS tag missing or corrupted in continuous restore - re-injected', {
                                                        cssTagExists,
                                                        cssTagInHead,
                                                        cssTagContentLost,
                                                        frameCount:formData.continuousRestoreFrameCount || 0
                                                    }, 'CSS11');
                                                    // #endregion
                                                } catch (e) {
                                                    // #region agent log
                                                    debugInstrument('agile-ed-form-integration.js:8075', 'Error re-injecting CSS in continuous restore', {errorMessage:e?.message}, 'CSS11');
                                                    // #endregion
                                                }
                                            }
                                        }
                                        
                                        // CRITICAL: If API has previously succeeded, periodically re-inject CSS
                                        // This ensures CSS stays intact even if HubSpot removes it asynchronously
                                        const hasPreviousApiSuccess = formData && formData.emailSearchSucceeded;
                                        if (hasPreviousApiSuccess && formData.injectHubSpotFormCSS && typeof formData.injectHubSpotFormCSS === 'function') {
                                            const frameCount = formData.continuousRestoreFrameCount || 0;
                                            // Re-inject CSS every 60 frames (roughly every 1 second at 60fps) when API has succeeded
                                            // This provides continuous protection without excessive overhead
                                            if (frameCount % 60 === 0) {
                                                try {
                                                    formData.injectHubSpotFormCSS();
                                                    // #region agent log
                                                    debugInstrument('agile-ed-form-integration.js:8075', 'Periodic CSS re-injection in continuous restore (post-API)', {
                                                        frameCount,
                                                        emailSearchSucceeded:formData.emailSearchSucceeded
                                                    }, 'CSS10');
                                                    // #endregion
                                                } catch (e) {
                                                    // #region agent log
                                                    debugInstrument('agile-ed-form-integration.js:8082', 'Error in periodic CSS re-injection', {errorMessage:e?.message}, 'CSS10');
                                                    // #endregion
                                                }
                                            }
                                        }
                                        
                                        // Log every 10 frames to avoid spam, but always log if fields were restored
                                        if (restoredCount > 0 || (formData.continuousRestoreFrameCount || 0) % 10 === 0) {
                                            // #region agent log
                                            debugInstrument('agile-ed-form-integration.js:7540', 'Continuous restore - check complete', {
                                                restoredCount,
                                                checkedCount,
                                                totalFields:formFields.length,
                                                frameCount:formData.continuousRestoreFrameCount || 0,
                                                hasPreviousApiSuccess:formData && formData.emailSearchSucceeded
                                            }, 'CSS1');
                                            // #endregion
                                        }
                                        
                                        formData.continuousRestoreFrameCount = (formData.continuousRestoreFrameCount || 0) + 1;
                                    } catch (e) {
                                        // #region agent log
                                        debugInstrument('agile-ed-form-integration.js:7550', 'Error in continuous restore', {errorMessage:e?.message}, 'CSS1');
                                        // #endregion
                                    }
                                    
                                    // Continue the loop
                                    formData.continuousRestoreAnimationFrame = requestAnimationFrame(continuousRestore);
                                } else {
                                    // Email input no longer active - stop the loop
                                    // #region agent log
                                    debugInstrument('agile-ed-form-integration.js:7558', 'Stopping continuous restore loop', {
                                        hasFormData:!!formData,
                                        emailInputActive:formData?.emailInputActive,
                                        hasForm:!!$form,
                                        formConnected:$form?.[0]?.isConnected
                                    }, 'CSS1');
                                    // #endregion
                                    formData.continuousRestoreAnimationFrame = null;
                                }
                            };
                            
                            // Start the continuous restore loop
                            formData.continuousRestoreAnimationFrame = requestAnimationFrame(continuousRestore);
                        } else {
                            // #region agent log
                            debugInstrument('agile-ed-form-integration.js:7570', 'Continuous restore loop already running', {}, 'CSS1');
                            // #endregion
                        }
                        
                        // CRITICAL: Start continuous CSS monitoring during email editing
                        // Check if monitoring is already active - if not, start it
                        const isMonitoringActive = formData.cssMonitorInterval !== null && formData.cssMonitorInterval !== undefined;
                        if (formData.startCssMonitoring && typeof formData.startCssMonitoring === 'function') {
                            try {
                                // Always call startCssMonitoring - it will check if already monitoring
                                formData.startCssMonitoring();
                                // #region agent log
                                debugInstrument('agile-ed-form-integration.js:6184', 'startCssMonitoring called successfully', {
                                    wasAlreadyMonitoring:isMonitoringActive,
                                    isNowMonitoring:formData.cssMonitorInterval !== null && formData.cssMonitorInterval !== undefined,
                                    editCount:formData.emailEditCount || 0
                                }, 'CSS7');
                                // #endregion
                            } catch (e) {
                                // #region agent log
                                debugInstrument('agile-ed-form-integration.js:6187', 'Error calling startCssMonitoring', {errorMessage:e?.message,editCount:formData.emailEditCount || 0}, 'CSS7');
                                // #endregion
                            }
                        } else {
                            // #region agent log
                            debugInstrument('agile-ed-form-integration.js:6191', 'startCssMonitoring not available', {
                                hasStartCssMonitoring:!!formData.startCssMonitoring,
                                type:typeof formData.startCssMonitoring,
                                isMonitoringActive,
                                editCount:formData.emailEditCount || 0
                            }, 'CSS7');
                            // #endregion
                        }
                        
                        // CRITICAL: Re-inject HubSpot form CSS on EVERY keystroke during email editing
                        // This ensures CSS persists even if HubSpot removes it while user is typing
                        if (formData.injectHubSpotFormCSS && typeof formData.injectHubSpotFormCSS === 'function') {
                            try {
                                // Check CSS state before re-injection
                                const targetDoc = formData.targetDocument || document;
                                const targetHead = formData.targetHead || targetDoc.head;
                                const cssTagBefore = targetDoc.getElementById('agile-ed-hubspot-form-css');
                                const formComputedBefore = $form[0] ? window.getComputedStyle($form[0]) : null;
                                
                                // Check stylesheet count before re-injection
                                const styleTagsBefore = targetHead ? targetHead.querySelectorAll('style, link[rel="stylesheet"]') : [];
                                const stylesheetCountBefore = styleTagsBefore.length;
                                const capturedCount = formData.capturedStylesheets ? formData.capturedStylesheets.length : 0;
                                
                                // Track edit count for debugging
                                if (!formData.emailEditCount) {
                                    formData.emailEditCount = 0;
                                }
                                formData.emailEditCount++;
                                
                                // #region agent log
                                debugInstrument('agile-ed-form-integration.js:5908', 'Re-injecting CSS during email editing', {
                                    editCount:formData.emailEditCount,
                                    cssTagExists:!!cssTagBefore,
                                    cssTagInHead:cssTagBefore && targetHead && targetHead.contains(cssTagBefore),
                                    formDisplay:formComputedBefore?.display,
                                    formVisibility:formComputedBefore?.visibility,
                                    stylesheetCountBefore,
                                    capturedCount,
                                    emailValue:currentEmailValue,
                                    cssMonitoringActive:!!formData.cssMonitorInterval
                                }, 'CSS3');
                                // #endregion
                                
                                // CRITICAL: If stylesheets are missing, re-capture them before re-injecting
                                if (capturedCount > 0 && stylesheetCountBefore < capturedCount * 0.7) {
                                    // #region agent log
                                    debugInstrument('agile-ed-form-integration.js:5925', 'Stylesheets missing - re-capturing before re-injection', {
                                        stylesheetCountBefore,
                                        capturedCount,
                                        missingCount:capturedCount - stylesheetCountBefore
                                    }, 'CSS3');
                                    // #endregion
                                    if (formData.captureHubSpotStylesheets && typeof formData.captureHubSpotStylesheets === 'function') {
                                        try {
                                            formData.captureHubSpotStylesheets();
                                        } catch (e) {
                                            // #region agent log
                                            debugInstrument('agile-ed-form-integration.js:5932', 'Error re-capturing stylesheets', {errorMessage:e?.message}, 'CSS3');
                                            // #endregion
                                        }
                                    }
                                }
                                
                                formData.injectHubSpotFormCSS();
                                
                                // CRITICAL: If an API call has previously succeeded, add more aggressive CSS re-injection
                                // HubSpot's DOM manipulation after form population can break CSS when user edits email again
                                const hasPreviousApiSuccess = formData && formData.emailSearchSucceeded;
                                if (hasPreviousApiSuccess && formData.injectHubSpotFormCSS) {
                                    // #region agent log
                                    debugInstrument('agile-ed-form-integration.js:8039', 'Previous API success detected - adding aggressive CSS re-injection', {
                                        editCount:formData.emailEditCount,
                                        emailSearchSucceeded:formData.emailSearchSucceeded
                                    }, 'CSS10');
                                    // #endregion
                                    
                                    // Re-inject CSS multiple times with delays to catch delayed DOM manipulation
                                    setTimeout(function() {
                                        if (formData && formData.injectHubSpotFormCSS) {
                                            formData.injectHubSpotFormCSS();
                                            // #region agent log
                                            debugInstrument('agile-ed-form-integration.js:8047', 'CSS re-injected after 50ms (post-API edit)', {}, 'CSS10');
                                            // #endregion
                                        }
                                    }, 50);
                                    
                                    setTimeout(function() {
                                        if (formData && formData.injectHubSpotFormCSS) {
                                            formData.injectHubSpotFormCSS();
                                            // #region agent log
                                            debugInstrument('agile-ed-form-integration.js:8054', 'CSS re-injected after 150ms (post-API edit)', {}, 'CSS10');
                                            // #endregion
                                        }
                                    }, 150);
                                    
                                    setTimeout(function() {
                                        if (formData && formData.injectHubSpotFormCSS) {
                                            formData.injectHubSpotFormCSS();
                                            // #region agent log
                                            debugInstrument('agile-ed-form-integration.js:8061', 'CSS re-injected after 300ms (post-API edit)', {}, 'CSS10');
                                            // #endregion
                                        }
                                    }, 300);
                                    
                                    setTimeout(function() {
                                        if (formData && formData.injectHubSpotFormCSS) {
                                            formData.injectHubSpotFormCSS();
                                            // #region agent log
                                            debugInstrument('agile-ed-form-integration.js:8068', 'CSS re-injected after 500ms (post-API edit)', {}, 'CSS10');
                                            // #endregion
                                        }
                                    }, 500);
                                    
                                    setTimeout(function() {
                                        if (formData && formData.injectHubSpotFormCSS) {
                                            formData.injectHubSpotFormCSS();
                                            // #region agent log
                                            debugInstrument('agile-ed-form-integration.js:8075', 'CSS re-injected after 1000ms (post-API edit)', {}, 'CSS10');
                                            // #endregion
                                        }
                                    }, 1000);
                                }
                                
                    // Check CSS state after re-injection
                    const cssTagAfter = targetDoc.getElementById('agile-ed-hubspot-form-css');
                    const formComputedAfter = $form[0] ? window.getComputedStyle($form[0]) : null;
                    const styleTagsAfter = targetHead ? targetHead.querySelectorAll('style, link[rel="stylesheet"]') : [];
                    const stylesheetCountAfter = styleTagsAfter.length;
                    
                    // CRITICAL: Check if CSS tag content is intact
                    const cssTagContentLength = cssTagAfter ? (cssTagAfter.textContent || cssTagAfter.innerHTML || '').length : 0;
                    const expectedCssTagLength = formData.hubspotFormCSS ? formData.hubspotFormCSS.length : 0;
                    const cssTagContentLost = cssTagAfter && expectedCssTagLength > 0 && cssTagContentLength < expectedCssTagLength * 0.5;
                    
                    // CRITICAL: Check if stylesheet content is intact
                    let stylesheetContentLost = false;
                    if (formData.capturedStylesheets && formData.capturedStylesheets.length > 0) {
                        formData.capturedStylesheets.forEach(function(captured) {
                            if (captured.textContent) {
                                // Find matching stylesheet
                                styleTagsAfter.forEach(function(current) {
                                    if ((captured.id && current.id === captured.id) || 
                                        (captured.href && current.href === captured.href)) {
                                        const currentContentLength = (current.textContent || '').length;
                                        const capturedContentLength = captured.textContent.length;
                                        if (currentContentLength < capturedContentLength * 0.5) {
                                            stylesheetContentLost = true;
                                        }
                                    }
                                });
                            }
                        });
                    }
                    
                    // #region agent log
                    debugInstrument('agile-ed-form-integration.js:5916', 'CSS re-injected during email editing', {
                        editCount:formData.emailEditCount,
                        cssTagExists:!!cssTagAfter,
                        cssTagInHead:cssTagAfter && targetHead && targetHead.contains(cssTagAfter),
                        cssTagContentLength,
                        expectedCssTagLength,
                        cssTagContentLost,
                        formDisplay:formComputedAfter?.display,
                        formVisibility:formComputedAfter?.visibility,
                        stylesheetCountAfter,
                        stylesheetCountBefore,
                        stylesheetCountChanged:stylesheetCountAfter !== stylesheetCountBefore,
                        stylesheetContentLost
                    }, 'CSS3');
                    // #endregion
                    
                    // CRITICAL: If CSS tag content is lost, re-inject immediately
                    if (cssTagContentLost && formData.injectHubSpotFormCSS) {
                        // #region agent log
                        debugInstrument('agile-ed-form-integration.js:5950', 'CSS tag content lost - re-injecting immediately', {
                            editCount:formData.emailEditCount,
                            cssTagContentLength,
                            expectedCssTagLength
                        }, 'CSS3');
                        // #endregion
                        setTimeout(function() {
                            if (formData.injectHubSpotFormCSS) {
                                formData.injectHubSpotFormCSS();
                            }
                        }, 50);
                    }
                    
                    // CRITICAL: If stylesheet content is lost, re-capture and restore
                    if (stylesheetContentLost && formData.captureHubSpotStylesheets) {
                        // #region agent log
                        debugInstrument('agile-ed-form-integration.js:5960', 'Stylesheet content lost - re-capturing and restoring', {
                            editCount:formData.emailEditCount
                        }, 'CSS3');
                        // #endregion
                        if (formData.captureHubSpotStylesheets && typeof formData.captureHubSpotStylesheets === 'function') {
                            formData.captureHubSpotStylesheets();
                        }
                        // Restore missing stylesheets
                        if (formData.capturedStylesheets && targetHead) {
                            formData.capturedStylesheets.forEach(function(captured) {
                                if (captured.textContent) {
                                    // Check if stylesheet exists
                                    let existing = null;
                                    if (captured.id) {
                                        existing = targetDoc.getElementById(captured.id);
                                    } else if (captured.href) {
                                        existing = targetHead.querySelector('link[href="' + captured.href + '"]');
                                    }
                                    
                                    // If stylesheet exists but content is lost, restore it
                                    if (existing && existing.tagName === 'STYLE') {
                                        const currentContentLength = (existing.textContent || '').length;
                                        const capturedContentLength = captured.textContent.length;
                                        if (currentContentLength < capturedContentLength * 0.5) {
                                            try {
                                                existing.textContent = captured.textContent;
                                                // #region agent log
                                                debugInstrument('agile-ed-form-integration.js:5980', 'Restored stylesheet content', {
                                                    id:captured.id,
                                                    contentLength:capturedContentLength
                                                }, 'CSS3');
                                                // #endregion
                                            } catch (e) {
                                                // Ignore
                                            }
                                        }
                                    }
                                }
                            });
                        }
                    }
                            } catch (e) {
                                // #region agent log
                                debugInstrument('agile-ed-form-integration.js:5920', 'Error re-injecting CSS during email editing', {errorMessage:e?.message,editCount:formData.emailEditCount}, 'CSS3');
                                // #endregion
                                debugWarn('Error re-injecting HubSpot CSS during email editing:', e);
                            }
                        }
                        
                        // CRITICAL: Re-apply CSS styles on EVERY keystroke during email editing
                        // This ensures styles persist even if HubSpot removes them while user is typing
                        // This is MUCH simpler and more reliable than cloning/restoring
                        try {
                            if ($form && $form[0] && $form[0].isConnected) {
                                // ALWAYS re-apply inline styles during email editing (not just once)
                                // HubSpot may remove styles while user is typing, so we need to restore them continuously
                                const formElement = $form[0];
                                const computedStyle = window.getComputedStyle(formElement);
                                
                                // Store original style attribute if it exists (only once)
                                if (!formData.originalFormStyle) {
                                    formData.originalFormStyle = formElement.getAttribute('style') || '';
                                }
                                
                                // Check if styles have been lost - if so, restore from preserved styles
                                const currentDisplay = computedStyle.display;
                                const currentVisibility = computedStyle.visibility;
                                const currentOpacity = computedStyle.opacity;
                                
                                // Check CSS tag state
                                const targetDoc = formData.targetDocument || document;
                                const cssTag = targetDoc.getElementById('agile-ed-hubspot-form-css');
                                const cssTagInHead = cssTag && (formData.targetHead || document.head).contains(cssTag);
                                
                                // CRITICAL: Check if form has lost visual styling (not just visibility)
                                // Check for default/unstyled appearance that indicates CSS loss
                                const formBackgroundColor = computedStyle.backgroundColor;
                                const formColor = computedStyle.color;
                                const formFontSize = computedStyle.fontSize;
                                const formPadding = computedStyle.padding;
                                const formBorder = computedStyle.border;
                                
                                // Check if form looks unstyled (default browser styles)
                                // This detects when stylesheets are removed but form is still visible
                                const looksUnstyled = (
                                    (!formBackgroundColor || formBackgroundColor === 'rgba(0, 0, 0, 0)' || formBackgroundColor === 'transparent') &&
                                    (!formColor || formColor === 'rgb(0, 0, 0)') &&
                                    (!formFontSize || formFontSize === '16px') &&
                                    (!formPadding || formPadding === '0px') &&
                                    (!formBorder || formBorder === '0px none rgb(0, 0, 0)')
                                );
                                
                                // #region agent log
                                debugInstrument('agile-ed-form-integration.js:6042', 'Checking form CSS during email editing', {
                                    editCount:formData.emailEditCount || 0,
                                    currentDisplay,
                                    currentVisibility,
                                    currentOpacity,
                                    hasPreservedStyles:!!formData.cssPreservedStyles,
                                    emailInputActive:formData.emailInputActive,
                                    cssTagExists:!!cssTag,
                                    cssTagInHead,
                                    formHasStyle:!!formElement.getAttribute('style'),
                                    formBackgroundColor,
                                    formColor,
                                    formFontSize,
                                    formPadding,
                                    formBorder,
                                    looksUnstyled
                                }, 'CSS4');
                                // #endregion
                                
                                // CRITICAL: If form looks unstyled, re-inject CSS immediately
                                if (looksUnstyled && formData.injectHubSpotFormCSS) {
                                    // #region agent log
                                    debugInstrument('agile-ed-form-integration.js:6070', 'Form looks unstyled - re-injecting CSS', {
                                        editCount:formData.emailEditCount || 0,
                                        formBackgroundColor,
                                        formColor,
                                        formFontSize
                                    }, 'CSS4');
                                    // #endregion
                                    setTimeout(function() {
                                        if (formData.injectHubSpotFormCSS) {
                                            formData.injectHubSpotFormCSS();
                                        }
                                    }, 50);
                                }
                                
                                // If form has lost visibility, restore from preserved styles immediately
                                if (currentDisplay === 'none' || currentVisibility === 'hidden' || parseFloat(currentOpacity) === 0) {
                                    // #region agent log
                                    debugInstrument('agile-ed-form-integration.js:6047', 'Form CSS lost - restoring', {currentDisplay,currentVisibility,currentOpacity,hasPreservedStyles:!!formData.cssPreservedStyles,cssTagExists:!!cssTag,cssTagInHead}, 'CSS4');
                                    // #endregion
                                    if (formData.cssPreservedStyles && formData.cssPreservedStyles.formStyle) {
                                        formElement.setAttribute('style', formData.cssPreservedStyles.formStyle);
                                        debugLog('Restored form CSS from preserved styles (email editing)');
                                        
                                        // Check if restoration worked
                                        const afterComputed = window.getComputedStyle(formElement);
                                        // #region agent log
                                        debugInstrument('agile-ed-form-integration.js:6052', 'Form CSS restored', {displayAfter:afterComputed.display,visibilityAfter:afterComputed.visibility,opacityAfter:afterComputed.opacity}, 'CSS4');
                                        // #endregion
                                    }
                                }
                                
                                // CRITICAL: Only apply MINIMAL inline styles to prevent visibility loss
                                // Do NOT override all styles - this breaks the original design
                                // Only fix visibility/display issues, not duplicate all CSS
                                // Re-check computed styles after potential restoration (reuse existing variables)
                                
                                // Declare inlineStyle in outer scope so it's accessible in requestAnimationFrame callback
                                let inlineStyle = formData.originalFormStyle || '';
                                
                                // Only apply inline styles if form has lost visibility
                                // Otherwise, preserve original styles to maintain design
                                if (currentDisplay === 'none' || currentVisibility === 'hidden' || parseFloat(currentOpacity) === 0) {
                                    // Form has lost visibility - restore only visibility properties
                                    if (inlineStyle && !inlineStyle.endsWith(';')) {
                                        inlineStyle += ';';
                                    }
                                    
                                    // Only add visibility protection, not all styles
                                    if (currentDisplay === 'none') {
                                        inlineStyle += 'display: block !important; ';
                                    }
                                    if (currentVisibility === 'hidden') {
                                        inlineStyle += 'visibility: visible !important; ';
                                    }
                                    if (parseFloat(currentOpacity) === 0) {
                                        inlineStyle += 'opacity: 1 !important; ';
                                    }
                                    
                                    // Apply minimal inline styles
                                    formElement.setAttribute('style', inlineStyle);
                                    formData.inlineStylesApplied = true;
                                } else {
                                    // Form is visible - only preserve original style, don't add new ones
                                    if (formData.originalFormStyle && !formElement.getAttribute('style')) {
                                        formElement.setAttribute('style', formData.originalFormStyle);
                                        inlineStyle = formData.originalFormStyle; // Update inlineStyle for requestAnimationFrame
                                    }
                                }
                                
                                // CRITICAL: Use requestAnimationFrame to ensure styles persist after HubSpot manipulation
                                // This runs after browser paint, ensuring our styles override HubSpot's changes
                                requestAnimationFrame(function() {
                                    requestAnimationFrame(function() {
                                        // Double-check and re-apply if styles were removed
                                        const currentStyle = formElement.getAttribute('style');
                                        if (!currentStyle || !currentStyle.includes('display') || !currentStyle.includes('visibility')) {
                                            // Only use inlineStyle if it was set (form was hidden)
                                            if (inlineStyle) {
                                                formElement.setAttribute('style', inlineStyle);
                                            }
                                        }
                                        
                                        // Also check all inputs
                                        formInputs.each(function() {
                                            const el = this;
                                            if (el.isConnected) {
                                                const elComputed = window.getComputedStyle(el);
                                                if (elComputed.display === 'none' || elComputed.visibility === 'hidden') {
                                                    // Restore from preserved styles
                                                    if (formData.cssPreservedStyles && formData.cssPreservedStyles.elements && formData.cssPreservedStyles.elements[el]) {
                                                        el.setAttribute('style', formData.cssPreservedStyles.elements[el]);
                                                    }
                                                }
                                            }
                                        });
                                    });
                                });
                                
                                debugLog('Re-applied form CSS styles during email editing');
                                
                                // CRITICAL: Only fix visibility issues for form elements
                                // Do NOT apply all styles - this causes duplicate styling and design issues
                                // Only restore visibility if elements have lost it
                                const formInputs = $form.find('input:not([type="hidden"]), textarea, label, .hs-form-field:not(:has(input[type="hidden"])), .hs-input:not([type="hidden"])');
                                formInputs.each(function() {
                                    const el = this;
                                    if (el.isConnected) {
                                        const computed = window.getComputedStyle(el);
                                        
                                        // Check if element has lost visibility
                                        const elDisplay = computed.display;
                                        const elVisibility = computed.visibility;
                                        const elOpacity = parseFloat(computed.opacity);
                                        
                                        // Only fix if element is hidden - don't override visible elements
                                        if (elDisplay === 'none' || elVisibility === 'hidden' || elOpacity === 0) {
                                            // Element is hidden - restore from preserved styles or apply minimal fix
                                            if (formData.cssPreservedStyles && formData.cssPreservedStyles.elements && formData.cssPreservedStyles.elements[el]) {
                                                el.setAttribute('style', formData.cssPreservedStyles.elements[el]);
                                            } else {
                                                // Apply minimal visibility fix only
                                                let elStyle = el.getAttribute('style') || '';
                                                if (elStyle && !elStyle.endsWith(';')) {
                                                    elStyle += ';';
                                                }
                                                
                                                if (elDisplay === 'none') {
                                                    elStyle += 'display: block !important; ';
                                                }
                                                if (elVisibility === 'hidden') {
                                                    elStyle += 'visibility: visible !important; ';
                                                }
                                                if (elOpacity === 0) {
                                                    elStyle += 'opacity: 1 !important; ';
                                                }
                                                
                                                el.setAttribute('style', elStyle);
                                            }
                                        }
                                        // If element is visible, don't touch it - preserve original design
                                    }
                                });
                                
                                // CRITICAL: Ensure hidden inputs stay hidden
                                const hiddenInputs = $form.find('input[type="hidden"]');
                                hiddenInputs.each(function() {
                                    const el = this;
                                    if (el.isConnected) {
                                        const computed = window.getComputedStyle(el);
                                        if (computed.display !== 'none' || computed.visibility !== 'hidden') {
                                            // Hidden input is visible - hide it
                                            el.style.display = 'none';
                                            el.style.visibility = 'hidden';
                                            el.style.opacity = '0';
                                            el.style.height = '0';
                                            el.style.width = '0';
                                            el.style.padding = '0';
                                            el.style.margin = '0';
                                        }
                                    }
                                });
                                
                                // CRITICAL: Only fix visibility for select elements - don't override all styles
                                // This prevents duplicate styling and maintains original design
                                const formSelects = $form.find('select');
                                formSelects.each(function() {
                                    const el = this;
                                    if (el.isConnected) {
                                        const computed = window.getComputedStyle(el);
                                        
                                        // Only fix if select has lost visibility
                                        const elDisplay = computed.display;
                                        const elVisibility = computed.visibility;
                                        const elOpacity = parseFloat(computed.opacity);
                                        
                                        if (elDisplay === 'none' || elVisibility === 'hidden' || elOpacity === 0) {
                                            // Select is hidden - restore from preserved styles or apply minimal fix
                                            if (formData.cssPreservedStyles && formData.cssPreservedStyles.elements && formData.cssPreservedStyles.elements[el]) {
                                                el.setAttribute('style', formData.cssPreservedStyles.elements[el]);
                                            } else {
                                                // Apply minimal visibility fix only
                                                let elStyle = el.getAttribute('style') || '';
                                                if (elStyle && !elStyle.endsWith(';')) {
                                                    elStyle += ';';
                                                }
                                                
                                                if (elDisplay === 'none') {
                                                    elStyle += 'display: block !important; ';
                                                }
                                                if (elVisibility === 'hidden') {
                                                    elStyle += 'visibility: visible !important; ';
                                                }
                                                if (elOpacity === 0) {
                                                    elStyle += 'opacity: 1 !important; ';
                                                }
                                                
                                                el.setAttribute('style', elStyle);
                                            }
                                        }
                                        // If select is visible, don't touch it - preserve original design
                                    }
                                });
                            }
                        } catch (e) {
                            debugWarn('Error applying inline styles during email input:', e);
                        }
                    }
                    emailInputActive = true; // Also set local variable for backward compatibility
                    
                    // NOTE: CSS injection is now handled by injectHubSpotFormCSS() function
                    // which is called on page load and re-injected during email editing
                    // This prevents duplicate CSS injection and maintains original form design
                    
                    // CRITICAL: Abort any pending Personnel API requests to prevent DOM conflicts
                    // Access abort controller from formData (set by initEmailField)
                    if (formData && formData.currentRequestAbortController) {
                        try {
                            formData.currentRequestAbortController.abort();
                            formData.currentRequestAbortController = null;
                        } catch (e) {
                            // Ignore abort errors
                        }
                    }
                    
                    // CRITICAL: Clear ALL pending operations that might manipulate DOM
                    // Use try-catch for each to prevent errors from breaking the handler
                    try {
                        clearTimeout(autocompleteTimeout);
                    } catch (e) {
                        // Ignore
                    }
                    
                    if (formData && formData.emailInputResetTimeout) {
                        try {
                            clearTimeout(formData.emailInputResetTimeout);
                            formData.emailInputResetTimeout = null;
                        } catch (e) {
                            // Ignore
                        }
                    }
                    
                    // CRITICAL: Also clear any pending position timeouts that might manipulate DOM
                    if (positionTimeout) {
                        try {
                            clearTimeout(positionTimeout);
                            positionTimeout = null;
                        } catch (e) {
                            // Ignore
                        }
                    }
                    
                    // CRITICAL: Hide autocomplete dropdown immediately to prevent DOM conflicts
                    // This prevents any dropdown-related DOM operations during email editing
                    // Use requestAnimationFrame to defer DOM operations and avoid conflicts
                    try {
                        if ($autocompleteContainer && $autocompleteContainer.length) {
                            // Defer DOM manipulation to avoid conflicts
                            requestAnimationFrame(function() {
                                try {
                                    if ($autocompleteContainer && $autocompleteContainer.length && $autocompleteContainer.is(':visible')) {
                                        $autocompleteContainer.hide().empty();
                                    }
                                } catch (e) {
                                    // Suppress any errors from hiding dropdown
                                }
                            });
                        }
                    } catch (e) {
                        // Suppress any errors from hiding dropdown
                    }
                    
                    // CRITICAL: Block ALL search operations during email input
                    // Clear any pending searchDistricts calls
                    if (formData) {
                        formData.blockAllSearches = true;
                    }
                    
                    // CRITICAL: Do NOT perform any other operations during email input
                    // Just update tracking and return immediately
                    const emailValue = $(this).val().trim();
                    lastEmailValue = emailValue;
                    
                    // Reset email input flag after a LONG delay to ensure HubSpot has completely finished
                    // Clear any existing timeout first to prevent multiple resets
                    if (formData && formData.emailInputResetTimeout) {
                        try {
                            clearTimeout(formData.emailInputResetTimeout);
                        } catch (e) {
                            // Ignore
                        }
                    }
                    
                    const currentTime = Date.now();
                    if (formData) {
                        formData.lastEmailInputTime = currentTime;
                    }
                    
                    // Use requestAnimationFrame to defer timeout setup and avoid conflicts
                    requestAnimationFrame(function() {
                        try {
                            formData.emailInputResetTimeout = setTimeout(function checkAndReset() {
                                // Only reset if enough time has passed since last email input
                                const timeSinceLastInput = Date.now() - (formData.lastEmailInputTime || 0);
                                if (timeSinceLastInput >= 5000) { // Increased from 3000 to 5000ms for better CSS protection
                                    emailInputActive = false;
                                    if (formData) {
                                        formData.emailInputActive = false;
                                        
                                        // Stop continuous restore loop
                                        if (formData.continuousRestoreAnimationFrame) {
                                            cancelAnimationFrame(formData.continuousRestoreAnimationFrame);
                                            formData.continuousRestoreAnimationFrame = null;
                                        }
                                        
                                        // Stop CSS monitoring when email editing stops
                                        if (formData.stopCssMonitoring && typeof formData.stopCssMonitoring === 'function') {
                                            formData.stopCssMonitoring();
                                        }
                                        formData.blockAllSearches = false; // Also unblock searches
                                        formData.emailInputResetTimeout = null;
                                        
                                        // CRITICAL: Re-apply CSS protection after flag resets to prevent HubSpot from removing styles
                                        // This ensures CSS persists even after email input is complete
                                        if (formData.inlineStylesApplied && $form && $form[0] && $form[0].isConnected) {
                                            setTimeout(function() {
                                                try {
                                                    // Re-apply inline styles to form and inputs to ensure they persist
                                                    const formElement = $form[0];
                                                    const computedStyle = window.getComputedStyle(formElement);
                                                    
                                                    const criticalStyles = {
                                                        'display': computedStyle.display,
                                                        'visibility': computedStyle.visibility,
                                                        'opacity': computedStyle.opacity,
                                                        'position': computedStyle.position,
                                                        'width': computedStyle.width,
                                                        'max-width': computedStyle.maxWidth,
                                                        'margin': computedStyle.margin,
                                                        'padding': computedStyle.padding,
                                                        'background': computedStyle.backgroundColor,
                                                        'border': computedStyle.border,
                                                        'border-radius': computedStyle.borderRadius,
                                                        'box-shadow': computedStyle.boxShadow,
                                                        'font-family': computedStyle.fontFamily,
                                                        'font-size': computedStyle.fontSize,
                                                        'line-height': computedStyle.lineHeight
                                                    };
                                                    
                                                    let inlineStyle = formData.originalFormStyle || '';
                                                    if (inlineStyle && !inlineStyle.endsWith(';')) {
                                                        inlineStyle += ';';
                                                    }
                                                    
                                                    for (const prop in criticalStyles) {
                                                        const value = criticalStyles[prop];
                                                        if (value && value !== 'none' && value !== 'auto' && value !== 'normal') {
                                                            inlineStyle += prop.replace(/-([a-z])/g, (g) => g[1].toUpperCase()) + ': ' + value + ' !important; ';
                                                        }
                                                    }
                                                    
                                                    formElement.setAttribute('style', inlineStyle);
                                                    
                                                    // NOTE: CSS protection is now handled by injectHubSpotFormCSS()
                                                    // which injects minimal CSS into iframe/document head
                                                    // No need to re-apply inline styles here - that causes duplicate styling
                                                    debugLog('Email input flag reset - CSS protection handled by injectHubSpotFormCSS()');
                                                } catch (e) {
                                                    debugWarn('Error re-applying CSS protection:', e);
                                                }
                                            }, 500); // Small delay to let HubSpot finish any operations
                                        }
                                    }
                                    debugLog('Email input flag reset - DOM operations can resume', {
                                        hasPendingFormPopulation: !!(formData && formData.pendingFormPopulation)
                                    });
                                    
                                    // CRITICAL: If there's pending form population, do it now that email input is complete
                                    if (formData && formData.pendingFormPopulation) {
                                        debugLog('FOUND pendingFormPopulation - Processing pending form population after email input completed', {
                                            hasPendingData: !!formData.pendingFormPopulation,
                                            isArray: Array.isArray(formData.pendingFormPopulation),
                                            pendingDataKeys: typeof formData.pendingFormPopulation === 'object' ? Object.keys(formData.pendingFormPopulation) : 'N/A',
                                            hasCountry: formData.pendingFormPopulation && (formData.pendingFormPopulation.mailingCountry || formData.pendingFormPopulation.country),
                                            hasState: formData.pendingFormPopulation && (formData.pendingFormPopulation.mailingState || formData.pendingFormPopulation.state)
                                        });
                                        const pendingData = formData.pendingFormPopulation;
                                        delete formData.pendingFormPopulation;
                                        
                                        // Use multiple requestAnimationFrame to ensure DOM is stable
                                        requestAnimationFrame(function() {
                                            requestAnimationFrame(function() {
                                                try {
                                                    let dataToPopulate = null;
                                                    
                                                    if (Array.isArray(pendingData)) {
                                                        if (pendingData.length > 0) {
                                                            dataToPopulate = pendingData[0];
                                                        }
                                                    } else if (typeof pendingData === 'object') {
                                                        dataToPopulate = pendingData;
                                                    }
                                                    
                                                    if (dataToPopulate) {
                                                        // Create a copy without the company field (same as immediate population)
                                                        // This ensures country and state are populated but school field stays empty
                                                        const dataWithoutCompany = { ...dataToPopulate };
                                                        delete dataWithoutCompany.institutionNameProper;
                                                        delete dataWithoutCompany.institutionName;
                                                        delete dataWithoutCompany.company;
                                                        
                                                        debugLog('Populating form with deferred data (country/state should be included)', {
                                                            hasCountry: !!(dataWithoutCompany.mailingCountry || dataWithoutCompany.country),
                                                            hasState: !!(dataWithoutCompany.mailingState || dataWithoutCompany.state),
                                                            country: dataWithoutCompany.mailingCountry || dataWithoutCompany.country,
                                                            state: dataWithoutCompany.mailingState || dataWithoutCompany.state
                                                        });
                                                        
                                                        // Populate form with country and state
                                                        // Use captured references from closure
                                                        debugLog('About to call populateHubSpotForm with data:', {
                                                            country: dataWithoutCompany.mailingCountry || dataWithoutCompany.country,
                                                            state: dataWithoutCompany.mailingState || dataWithoutCompany.state,
                                                            hasInstitutionWidget: !!institutionWidgetRef
                                                        });
                                                        
                                                        const populatePromise = institutionWidgetRef.populateHubSpotForm(dataWithoutCompany);
                                                        
                                                        // After form population completes, trigger school dropdown if domain results exist
                                                        const triggerDropdown = function() {
                                                            debugLog('triggerDropdown called - checking if form was populated');
                                                            // Verify form fields were populated
                                                            if ($formRef && $formRef.length) {
                                                                const countryField = $formRef.find('[name="country__new_"]').first();
                                                                const stateField = $formRef.find('[name="us_states"]').first();
                                                                debugLog('Form field values after population:', {
                                                                    countryFieldValue: countryField.length ? countryField.val() : 'field not found',
                                                                    stateFieldValue: stateField.length ? stateField.val() : 'field not found'
                                                                });
                                                            }
                                                            
                                                            if (formData && formData.domainSearchResults && Array.isArray(formData.domainSearchResults) && formData.domainSearchResults.length > 0) {
                                                                debugLog('Domain search results available - triggering school dropdown display', {
                                                                    resultsCount: formData.domainSearchResults.length
                                                                });
                                                                // Set flag to show domain results
                                                                formData.showDomainSearchResults = true;
                                                                
                                                                // Find company field and trigger search to show dropdown
                                                                setTimeout(() => {
                                                                    let companyFieldForDropdown = null;
                                                                    for (const selector of selfRef.companySelectors) {
                                                                        companyFieldForDropdown = $formRef.find(selector).first();
                                                                        if (companyFieldForDropdown.length) {
                                                                            break;
                                                                        }
                                                                    }
                                                                    
                                                                    if (companyFieldForDropdown && companyFieldForDropdown.length) {
                                                                        // Trigger input event to show dropdown with domain results
                                                                        debugLog('Triggering input event to show school dropdown with domain results');
                                                                        companyFieldForDropdown.trigger('input');
                                                                    } else {
                                                                        debugWarn('Company field not found for dropdown trigger');
                                                                    }
                                                                }, 1000); // Delay to ensure form fields are populated
                                                            }
                                                        };
                                                        
                                                        // Handle promise if it returns one, otherwise trigger immediately
                                                        if (populatePromise && typeof populatePromise.then === 'function') {
                                                            populatePromise.then(() => {
                                                                debugLog('populateHubSpotForm promise resolved - triggering dropdown');
                                                                triggerDropdown();
                                                            }).catch(e => {
                                                                debugWarn('Error in populateHubSpotForm promise:', e);
                                                                // Still try to trigger dropdown even if there was an error
                                                                setTimeout(triggerDropdown, 500);
                                                            });
                                                        } else {
                                                            // Not a promise - trigger dropdown after a delay
                                                            debugLog('populateHubSpotForm did not return a promise - triggering dropdown after delay');
                                                            setTimeout(triggerDropdown, 1000);
                                                        }
                                                    }
                                                } catch (e) {
                                                    debugWarn('Error processing pending form population:', e);
                                                }
                                            });
                                        });
                                    }
                                } else {
                                    // User is still typing - extend the timeout
                                    formData.emailInputResetTimeout = setTimeout(checkAndReset, 1000);
                                }
                            }, 5000); // 5 second delay to ensure HubSpot has completely finished (increased from 3000ms)
                        } catch (e) {
                            debugWarn('Error setting up email input reset timeout:', e);
                        }
                    });
                    
                    // Return immediately - do NOT execute any other code during email input
                    return;
                } catch (error) {
                    // CRITICAL: Catch ALL errors to prevent form from disappearing
                    // #region agent log
                    debugInstrument('agile-ed-form-integration.js:6752', 'Error in email input handler', {errorMessage:error?.message,errorStack:error?.stack?.substring(0,200),errorName:error?.name}, 'CSS7');
                    // #endregion
                    debugWarn('Error in email input handler - suppressing to prevent form disappearance:', error);
                    // Don't rethrow - just log and continue
                    return;
                }
                
                // Note: emailSearchTimeout is handled in initEmailField, not here
                
                const emailValue = $(this).val().trim();
                
                // CRITICAL: During email input, do ABSOLUTELY NOTHING that touches the DOM
                // Just update the lastEmailValue tracking variable and return immediately
                // All other logic will be handled after email input is complete
                lastEmailValue = emailValue;
                
                // Reset email input flag after a LONG delay to ensure HubSpot has completely finished
                // Clear any existing timeout first to prevent multiple resets
                if (formData && formData.emailInputResetTimeout) {
                    clearTimeout(formData.emailInputResetTimeout);
                }
                
                const currentTime = Date.now();
                if (formData) {
                    formData.lastEmailInputTime = currentTime;
                }
                
                formData.emailInputResetTimeout = setTimeout(function checkAndReset() {
                    // Only reset if enough time has passed since last email input
                    const timeSinceLastInput = Date.now() - (formData.lastEmailInputTime || 0);
                    if (timeSinceLastInput >= 5000) { // Increased from 3000 to 5000ms for better CSS protection
                        emailInputActive = false;
                        if (formData) {
                            formData.emailInputActive = false;
                            
                            // Stop continuous restore loop
                            if (formData.continuousRestoreAnimationFrame) {
                                cancelAnimationFrame(formData.continuousRestoreAnimationFrame);
                                formData.continuousRestoreAnimationFrame = null;
                            }
                            
                            // Stop CSS monitoring when email editing stops
                            if (formData.stopCssMonitoring && typeof formData.stopCssMonitoring === 'function') {
                                formData.stopCssMonitoring();
                            }
                            formData.blockAllSearches = false; // Also unblock searches
                            formData.emailInputResetTimeout = null;
                            
                            // CRITICAL: Re-apply CSS protection after flag resets to prevent HubSpot from removing styles
                            // This ensures CSS persists even after email input is complete
                            if (formData.inlineStylesApplied && $form && $form[0] && $form[0].isConnected) {
                                setTimeout(function() {
                                    try {
                                        // Re-apply inline styles to form and inputs to ensure they persist
                                        const formElement = $form[0];
                                        const computedStyle = window.getComputedStyle(formElement);
                                        
                                        const criticalStyles = {
                                            'display': computedStyle.display,
                                            'visibility': computedStyle.visibility,
                                            'opacity': computedStyle.opacity,
                                            'position': computedStyle.position,
                                            'width': computedStyle.width,
                                            'max-width': computedStyle.maxWidth,
                                            'margin': computedStyle.margin,
                                            'padding': computedStyle.padding,
                                            'background': computedStyle.backgroundColor,
                                            'border': computedStyle.border,
                                            'border-radius': computedStyle.borderRadius,
                                            'box-shadow': computedStyle.boxShadow,
                                            'font-family': computedStyle.fontFamily,
                                            'font-size': computedStyle.fontSize,
                                            'line-height': computedStyle.lineHeight
                                        };
                                        
                                        let inlineStyle = formData.originalFormStyle || '';
                                        if (inlineStyle && !inlineStyle.endsWith(';')) {
                                            inlineStyle += ';';
                                        }
                                        
                                        for (const prop in criticalStyles) {
                                            const value = criticalStyles[prop];
                                            if (value && value !== 'none' && value !== 'auto' && value !== 'normal') {
                                                inlineStyle += prop.replace(/-([a-z])/g, (g) => g[1].toUpperCase()) + ': ' + value + ' !important; ';
                                            }
                                        }
                                        
                                        formElement.setAttribute('style', inlineStyle);
                                        
                                        // Also re-apply to form inputs
                                        const formInputs = $form.find('input, textarea, label, .hs-form-field, .hs-input');
                                        formInputs.each(function() {
                                            const el = this;
                                            if (el.isConnected) {
                                                const computed = window.getComputedStyle(el);
                                                const critical = {
                                                    'display': computed.display,
                                                    'visibility': computed.visibility,
                                                    'opacity': computed.opacity,
                                                    'width': computed.width,
                                                    'max-width': computed.maxWidth,
                                                    'padding': computed.padding,
                                                    'margin': computed.margin,
                                                    'border': computed.border,
                                                    'border-radius': computed.borderRadius,
                                                    'background': computed.backgroundColor,
                                                    'color': computed.color,
                                                    'font-size': computed.fontSize,
                                                    'font-family': computed.fontFamily
                                                };
                                                
                                                let elStyle = el.getAttribute('style') || '';
                                                if (elStyle && !elStyle.endsWith(';')) {
                                                    elStyle += ';';
                                                }
                                                
                                                for (const prop in critical) {
                                                    const value = critical[prop];
                                                    if (value && value !== 'none' && value !== 'auto' && value !== 'normal') {
                                                        elStyle += prop.replace(/-([a-z])/g, (g) => g[1].toUpperCase()) + ': ' + value + ' !important; ';
                                                    }
                                                }
                                                
                                                el.setAttribute('style', elStyle);
                                            }
                                        });
                                        
                                        debugLog('CSS protection re-applied after email input flag reset');
                                    } catch (e) {
                                        debugWarn('Error re-applying CSS protection:', e);
                                    }
                                }, 500); // Small delay to let HubSpot finish any operations
                            }
                        }
                        debugLog('Email input flag reset - DOM operations can resume', {
                            hasPendingFormPopulation: !!(formData && formData.pendingFormPopulation)
                        });
                        
                        // CRITICAL: If there's pending form population, do it now that email input is complete
                        if (formData && formData.pendingFormPopulation) {
                            debugLog('FOUND pendingFormPopulation - Processing pending form population after email input completed', {
                                hasPendingData: !!formData.pendingFormPopulation,
                                isArray: Array.isArray(formData.pendingFormPopulation),
                                pendingDataKeys: typeof formData.pendingFormPopulation === 'object' ? Object.keys(formData.pendingFormPopulation) : 'N/A',
                                hasCountry: formData.pendingFormPopulation && (formData.pendingFormPopulation.mailingCountry || formData.pendingFormPopulation.country),
                                hasState: formData.pendingFormPopulation && (formData.pendingFormPopulation.mailingState || formData.pendingFormPopulation.state)
                            });
                            const pendingData = formData.pendingFormPopulation;
                            delete formData.pendingFormPopulation;
                            
                            // Use multiple requestAnimationFrame to ensure DOM is stable
                            requestAnimationFrame(function() {
                                requestAnimationFrame(function() {
                                    try {
                                        let dataToPopulate = null;
                                        
                                        if (Array.isArray(pendingData)) {
                                            if (pendingData.length > 0) {
                                                dataToPopulate = pendingData[0];
                                            }
                                        } else if (typeof pendingData === 'object') {
                                            dataToPopulate = pendingData;
                                        }
                                        
                                        if (dataToPopulate) {
                                            // Create a copy without the company field (same as immediate population)
                                            // This ensures country and state are populated but school field stays empty
                                            const dataWithoutCompany = { ...dataToPopulate };
                                            delete dataWithoutCompany.institutionNameProper;
                                            delete dataWithoutCompany.institutionName;
                                            delete dataWithoutCompany.company;
                                            
                                            debugLog('Populating form with deferred data (country/state should be included)', {
                                                hasCountry: !!(dataWithoutCompany.mailingCountry || dataWithoutCompany.country),
                                                hasState: !!(dataWithoutCompany.mailingState || dataWithoutCompany.state),
                                                country: dataWithoutCompany.mailingCountry || dataWithoutCompany.country,
                                                state: dataWithoutCompany.mailingState || dataWithoutCompany.state
                                            });
                                            
                                            // Populate form with country and state
                                            // Use captured references from closure
                                            debugLog('About to call populateHubSpotForm with data:', {
                                                country: dataWithoutCompany.mailingCountry || dataWithoutCompany.country,
                                                state: dataWithoutCompany.mailingState || dataWithoutCompany.state,
                                                hasInstitutionWidget: !!institutionWidgetRef
                                            });
                                            
                                            const populatePromise = institutionWidgetRef.populateHubSpotForm(dataWithoutCompany);
                                            
                                            // After form population completes, trigger school dropdown if domain results exist
                                            const triggerDropdown = function() {
                                                debugLog('triggerDropdown called - checking if form was populated');
                                                // Verify form fields were populated
                                                if ($formRef && $formRef.length) {
                                                    const countryField = $formRef.find('[name="country__new_"]').first();
                                                    const stateField = $formRef.find('[name="us_states"]').first();
                                                    debugLog('Form field values after population:', {
                                                        countryFieldValue: countryField.length ? countryField.val() : 'field not found',
                                                        stateFieldValue: stateField.length ? stateField.val() : 'field not found'
                                                    });
                                                }
                                                if (formData && formData.domainSearchResults && Array.isArray(formData.domainSearchResults) && formData.domainSearchResults.length > 0) {
                                                    debugLog('Domain search results available - triggering school dropdown display', {
                                                        resultsCount: formData.domainSearchResults.length
                                                    });
                                                    // Set flag to show domain results
                                                    formData.showDomainSearchResults = true;
                                                    
                                                    // Find company field and trigger search to show dropdown
                                                    setTimeout(() => {
                                                        let companyFieldForDropdown = null;
                                                        for (const selector of selfRef.companySelectors) {
                                                            companyFieldForDropdown = $formRef.find(selector).first();
                                                            if (companyFieldForDropdown.length) {
                                                                break;
                                                            }
                                                        }
                                                        
                                                        if (companyFieldForDropdown && companyFieldForDropdown.length) {
                                                            // Trigger input event to show dropdown with domain results
                                                            debugLog('Triggering input event to show school dropdown with domain results');
                                                            companyFieldForDropdown.trigger('input');
                                                        } else {
                                                            debugWarn('Company field not found for dropdown trigger');
                                                        }
                                                    }, 1000); // Delay to ensure form fields are populated
                                                }
                                            };
                                            
                                            // Handle promise if it returns one, otherwise trigger immediately
                                            if (populatePromise && typeof populatePromise.then === 'function') {
                                                populatePromise.then(() => {
                                                    debugLog('populateHubSpotForm promise resolved - triggering dropdown');
                                                    triggerDropdown();
                                                }).catch(e => {
                                                    debugWarn('Error in populateHubSpotForm promise:', e);
                                                    // Still try to trigger dropdown even if there was an error
                                                    setTimeout(triggerDropdown, 500);
                                                });
                                            } else {
                                                // Not a promise - trigger dropdown after a delay
                                                debugLog('populateHubSpotForm did not return a promise - triggering dropdown after delay');
                                                setTimeout(triggerDropdown, 1000);
                                            }
                                        }
                                    } catch (e) {
                                        debugWarn('Error processing pending form population:', e);
                                    }
                                });
                            });
                        }
                    } else {
                        // User is still typing - extend the timeout
                        formData.emailInputResetTimeout = setTimeout(checkAndReset, 1000);
                    }
                }, 3000); // 3 second delay to ensure HubSpot has completely finished
                
                // Return immediately - do NOT execute any other code during email input
                return;
            });
        }
        
        // Hide autocomplete on blur (but check if user is interacting with it)
        companyField.on('blur', function() {
            // Don't hide dropdown on blur - keep it visible until user clicks outside or selects an item
            // Only hide if user actually selected a school from autocomplete
            if (schoolSelectedFromAutocomplete) {
                return;
            }
            
            // Fix: Check if user is interacting with THIS form's autocomplete
            if (formData && formData.interactingWithAutocomplete) {
                return;
            }
            
            // Don't hide dropdown - keep it visible for user to select
            // Dropdown will be hidden when:
            // 1. User selects an item from dropdown
            // 2. User clicks outside the dropdown (handled by document click)
            return;
            
            // OLD CODE - keeping for reference but not executing
            // Delay hiding to allow user to click on autocomplete item
            // setTimeout(() => {
            //     // Double-check flags before hiding
            //     if (schoolSelectedFromAutocomplete) {
            //         return;
            //     }
            //     // Fix: Check THIS form's interaction flag
            //     if (formData && formData.interactingWithAutocomplete) {
            //         return;
            //     }
            //     
            //     // Don't hide dropdown on blur - keep it visible until user clicks outside
            //     // Dropdown will be hidden by document click handler when user clicks outside
            //     // This allows user to see and interact with dropdown even after blur
            //     return;
            // }, 300);
        });
        
        // Handle keyboard navigation
        companyField.on('keydown', function(e) {
            if (!$autocompleteContainer.is(':visible') || autocompleteResults.length === 0) return;
            
            if (e.key === 'ArrowDown') {
                e.preventDefault();
                selectedIndex = Math.min(selectedIndex + 1, autocompleteResults.length - 1);
                $autocompleteContainer.find('.autocomplete-item').eq(selectedIndex).trigger('mouseenter');
            } else if (e.key === 'ArrowUp') {
                e.preventDefault();
                selectedIndex = Math.max(selectedIndex - 1, -1);
                if (selectedIndex >= 0) {
                    $autocompleteContainer.find('.autocomplete-item').eq(selectedIndex).trigger('mouseenter');
                }
            } else if (e.key === 'Enter' && selectedIndex >= 0) {
                e.preventDefault();
                $autocompleteContainer.find('.autocomplete-item').eq(selectedIndex).trigger('click');
            } else if (e.key === 'Escape') {
                $autocompleteContainer.hide();
                updateContainerPadding(); // Reset padding when hidden
            }
        });
    }
    
    /**
     * Disable browser's built-in email validation
     */
    disableBrowserValidation(emailField, $form) {
        const disableValidation = () => {
            emailField[0].type = 'text';
            emailField.attr('inputmode', 'email');
            emailField.attr('autocomplete', 'email');
            emailField.removeAttr('pattern');
            emailField.removeAttr('required');
            
            const $formElement = $form[0];
            if ($formElement && $formElement.tagName === 'FORM') {
                $formElement.setAttribute('novalidate', 'novalidate');
                $formElement.noValidate = true;
            }
        };
        
        disableValidation();
        
        // Watch for HubSpot trying to change type back
        // Fix: Store observer reference for cleanup
        let emailFieldObserver = null;
        if (emailField.length && emailField[0]) {
            emailFieldObserver = new MutationObserver((mutations) => {
                mutations.forEach((mutation) => {
                    if (mutation.type === 'attributes' && mutation.attributeName === 'type') {
                        if (emailField[0] && emailField[0].type === 'email') {
                            disableValidation();
                        }
                    }
                });
            });
            
            emailFieldObserver.observe(emailField[0], {
                attributes: true,
                attributeFilter: ['type', 'pattern', 'required']
            });
        }
        
        emailField.on('invalid', (e) => {
            e.preventDefault();
            e.stopPropagation();
            return false;
        });
        
        $form.on('submit', (e) => {
            const formElement = this;
            if (formElement.checkValidity && !formElement.noValidate) {
                formElement.noValidate = true;
            }
        });
    }
    
    /**
     * Completely remove "Did you mean" validation messages
     */
    hideDidYouMeanMessages(emailField, $form) {
        const removeMessages = () => {
            // Remove elements containing "Did you mean" text
            $form.find('*').each(function() {
                const $el = $(this);
                const text = ($el.text() || '').trim();
                if (text.toLowerCase().includes('did you mean')) {
                    // Remove the element completely
                    $el.remove();
                }
            });
            
            // Remove error containers that contain "Did you mean"
            const $errorContainers = $form.find('.hs-error-msgs, .hs-error-msg, [class*="error"], [class*="suggestion"]');
            $errorContainers.each(function() {
                const $container = $(this);
                const text = ($container.text() || '').trim();
                if (text.toLowerCase().includes('did you mean')) {
                    // Remove the container completely
                    $container.remove();
                }
            });
        };
        
        removeMessages();
        const removeInterval = setInterval(removeMessages, 500); // Check more frequently
        
        // Store interval reference for cleanup
        if (typeof window !== 'undefined' && window.SecurlyForm) {
            if (!window.SecurlyForm.intervals) {
                window.SecurlyForm.intervals = [];
            }
            window.SecurlyForm.intervals.push(removeInterval);
        }
        
        const messageObserver = new MutationObserver((mutations) => {
            // Remove immediately without delay for better responsiveness
            mutations.forEach((mutation) => {
                if (mutation.addedNodes.length) {
                    mutation.addedNodes.forEach((node) => {
                        if (node.nodeType === 1) {
                            const $node = $(node);
                            const text = ($node.text() || '').trim();
                            if (text.toLowerCase().includes('did you mean')) {
                                // Remove immediately
                                $node.remove();
                            }
                            // Also check and remove children
                            $node.find('*').each(function() {
                                const $child = $(this);
                                const childText = ($child.text() || '').trim();
                                if (childText.toLowerCase().includes('did you mean')) {
                                    $child.remove();
                                }
                            });
                        }
                    });
                }
            });
        });
        
        const $emailFieldContainer = emailField.closest('.hs-form-field');
        if ($emailFieldContainer.length) {
            messageObserver.observe($emailFieldContainer[0], {
                childList: true,
                subtree: true
            });
        }
        
        $form.on('submit', () => {
            clearInterval(removeInterval);
            // Remove from intervals array if it exists
            if (typeof window !== 'undefined' && window.SecurlyForm && window.SecurlyForm.intervals) {
                const index = window.SecurlyForm.intervals.indexOf(removeInterval);
                if (index > -1) {
                    window.SecurlyForm.intervals.splice(index, 1);
                }
            }
            messageObserver.disconnect();
            
            // CRITICAL: Reset emailInputActive flag when form is submitted to allow submission
            // This prevents the flag from blocking form submission after API results
            // Find formData from global instances storage since it's not in scope here
            let formData = null;
            if (typeof window !== 'undefined' && window.agileEdFormInstances) {
                // Find formData by matching form element
                for (const instanceId in window.agileEdFormInstances) {
                    const instance = window.agileEdFormInstances[instanceId];
                    if (instance && instance.$form && instance.$form[0] === $form[0]) {
                        formData = instance;
                        break;
                    }
                }
            }
            
            if (formData) {
                debugLog('Form submit event - resetting emailInputActive flag');
                formData.emailInputActive = false;
                
                // Stop continuous restore loop
                if (formData.continuousRestoreAnimationFrame) {
                    cancelAnimationFrame(formData.continuousRestoreAnimationFrame);
                    formData.continuousRestoreAnimationFrame = null;
                }
                
                // Stop CSS monitoring
                if (formData.stopCssMonitoring && typeof formData.stopCssMonitoring === 'function') {
                    formData.stopCssMonitoring();
                }
                
                // Clear email input reset timeout
                if (formData.emailInputResetTimeout) {
                    clearTimeout(formData.emailInputResetTimeout);
                    formData.emailInputResetTimeout = null;
                }
                
                // Unblock searches
                formData.blockAllSearches = false;
                
                // Clean up CSS monitor on form submit
                if (formData.cssMonitorInterval) {
                    clearInterval(formData.cssMonitorInterval);
                    formData.cssMonitorInterval = null;
                }
                if (formData.styleObserver) {
                    formData.styleObserver.disconnect();
                    formData.styleObserver = null;
                }
            }
        });
        
        // Also cleanup on form destroy
        // Fix: Add to cleanup functions array instead of overwriting
        if (!window.SecurlyForm.cleanupFunctions) {
            window.SecurlyForm.cleanupFunctions = [];
        }
        
        const messageCleanupFn = function() {
            clearInterval(removeInterval);
            messageObserver.disconnect();
            if (window.SecurlyForm && window.SecurlyForm.intervals) {
                const index = window.SecurlyForm.intervals.indexOf(removeInterval);
                if (index > -1) {
                    window.SecurlyForm.intervals.splice(index, 1);
                }
            }
        };
        
        window.SecurlyForm.cleanupFunctions.push(messageCleanupFn);
    }
    
    /**
     * Clear all active timeouts
     */
    clearAllTimeouts() {
        this.activeTimeouts.forEach(id => clearTimeout(id));
        this.activeTimeouts.length = 0;
    }
    
    /**
     * Add to cache
     */
    addToCache(key, value) {
        if (this.emailSearchCache.size >= this.MAX_CACHE_SIZE) {
            const firstKey = this.emailSearchCache.keys().next().value;
            this.emailSearchCache.delete(firstKey);
        }
        this.emailSearchCache.set(key, {
            data: value,
            timestamp: Date.now()
        });
    }
    
    /**
     * Get from cache
     */
    getFromCache(key) {
        const cached = this.emailSearchCache.get(key);
        if (cached && (Date.now() - cached.timestamp) < this.CACHE_DURATION) {
            return cached.data;
        }
        if (cached) {
            this.emailSearchCache.delete(key);
        }
        return null;
    }
    
    /**
     * Get API instance (for advanced usage)
     */
    getAPI() {
        return this.agileEdAPI;
    }
    
    /**
     * Get widget instance (for advanced usage)
     */
    getWidget() {
        return this.institutionWidget;
    }
}

// Export for use in other files
if (typeof module !== 'undefined' && module.exports) {
    module.exports = AgileEdFormIntegration;
}