@arcadialdev/arcality 2.2.0

package/tests/_helpers/smart-action.spec.ts

@@ -0,0 +1,1458 @@
+
+import { test, expect, Page, Locator } from '@playwright/test';
+import 'dotenv/config';
+
+/**
+ * ✅ Detectores robustos de overlays REALES (no incluye [data-overlay-container] porque en tu portal existe siempre)
+ */
+const OVERLAY_VISIBLE = [
+    // Modales / dialogs
+    '[role="dialog"][aria-modal="true"]:visible',
+    '[role="dialog"]:visible',
+
+    // Popovers
+    '.heroui-popover:visible',
+    '.nextui-popover:visible',
+
+    // Listbox (autocompletes)
+    '[role="listbox"]:visible',
+    '.heroui-listbox:visible',
+
+    // Backdrops genéricos
+    '[data-overlay]:visible',
+    '[data-backdrop]:visible',
+].join(', ');
+
+const OVERLAY_PORTAL = '[data-overlay-container]';
+
+const SEARCH_INPUT_VISIBLE = 'input[type="search"]:visible, input[type="text"]:visible';
+const LISTBOX_VISIBLE = '[role="listbox"]:visible, .heroui-listbox:visible';
+const OPTION_VISIBLE =
+    '[role="option"]:visible, li:visible, .heroui-listbox-item:visible, .heroui-select-option:visible';
+
+/**
+ * Señales (en portal) que suelen aparecer cuando un SelectorModal/Modal custom está abierto.
+ * OJO: el portal existe siempre; lo que cambia es su contenido visible.
+ */
+const PORTAL_SIGNALS_SELECTORS = [
+    '[role="dialog"]',
+    '[aria-modal="true"]',
+    '.modal-content',
+    '.heroui-modal',
+    '.nextui-modal',
+    '.heroui-popover',
+    '.nextui-popover',
+    '[data-overlay]',
+    '[data-backdrop]',
+    '[role="listbox"]',
+    '.heroui-listbox',
+    'input[type="search"]',
+    'input[type="text"]',
+].join(', ');
+
+const PORTAL_OPTION_SELECTORS = [
+    '[role="option"]',
+    '.heroui-listbox-item',
+    '.heroui-select-option',
+    '[data-key]',
+    'li',
+    '[role="row"]',
+    '[role="gridcell"]',
+    'div[role="button"]',
+].join(', ');
+
+/**
+ * ✅ Cierra overlays reales sin tumbar el wizard si queda algo raro.
+ */
+async function ensureNoOverlay(page: Page) {
+    const overlay = page.locator(OVERLAY_VISIBLE);
+
+    if (!(await overlay.count())) return;
+
+    // Intento 1: Escape
+    await page.keyboard.press('Escape').catch(() => { });
+    await page.waitForTimeout(150);
+    if (!(await overlay.count())) return;
+
+    // Intento 2: click fuera
+    await page.mouse.click(5, 5).catch(() => { });
+    await page.waitForTimeout(150);
+    if (!(await overlay.count())) return;
+
+    // Intento 3: botón cerrar si existe
+    const closeBtn = page
+        .locator(
+            `${OVERLAY_VISIBLE} button:visible[aria-label*="cerr" i], ${OVERLAY_VISIBLE} button:visible[aria-label*="close" i], ${OVERLAY_VISIBLE} button:visible:has-text("×")`
+        )
+        .first();
+
+    if (await closeBtn.count()) {
+        await closeBtn.click({ force: true });
+        await page.waitForTimeout(200);
+    }
+
+    if (await overlay.count()) {
+        console.log('     ⚠️ Overlay sigue visible; continúo para no bloquear el wizard.');
+    }
+}
+
+/**
+ * Cuenta cuántas señales VISIBLES hay dentro del portal persistente.
+ * Esto es CLAVE para tu ZoneSelector: el modal se monta en el portal, no necesariamente como dialog estándar.
+ */
+async function countPortalSignals(page: Page): Promise<number> {
+    const portal = page.locator(OVERLAY_PORTAL).first();
+    if (!(await portal.count())) return 0;
+
+    return await portal.evaluate((root) => {
+        const isVisible = (el: Element) => {
+            const st = getComputedStyle(el as HTMLElement);
+            if (!st) return false;
+            if (st.display === 'none' || st.visibility === 'hidden' || Number(st.opacity) === 0) return false;
+            const r = (el as HTMLElement).getBoundingClientRect();
+            return r.width > 0 && r.height > 0;
+        };
+
+        const selectors = [
+            '[role="dialog"]',
+            '[aria-modal="true"]',
+            '.modal-content',
+            '.heroui-modal',
+            '.nextui-modal',
+            '.heroui-popover',
+            '.nextui-popover',
+            '[data-overlay]',
+            '[data-backdrop]',
+            '[role="listbox"]',
+            '.heroui-listbox',
+            'input[type="search"]',
+            'input[type="text"]',
+        ].join(',');
+
+        const nodes = Array.from(root.querySelectorAll(selectors));
+        return nodes.filter(isVisible).length;
+    });
+}
+
+/**
+ * Espera a que el portal cambie (apertura modal) sin depender de role=dialog.
+ * - beforeSignals: baseline previo al click
+ * - Consideramos “abierto” si señales aumentan al menos +1.
+ */
+async function waitPortalSignalsIncrease(page: Page, beforeSignals: number, timeout = 12000) {
+    await page.waitForFunction(
+        (arg: { before: number; selectors: string }) => {
+            const root = document.querySelector('[data-overlay-container]');
+            if (!root) return false;
+
+            const isVisible = (el: Element) => {
+                const st = getComputedStyle(el as HTMLElement);
+                if (!st) return false;
+                if (st.display === 'none' || st.visibility === 'hidden' || Number(st.opacity) === 0) return false;
+                const r = (el as HTMLElement).getBoundingClientRect();
+                return r.width > 0 && r.height > 0;
+            };
+
+            const nodes = Array.from(root.querySelectorAll(arg.selectors));
+            const visibleCount = nodes.filter(isVisible).length;
+
+            // abierto si sube (aunque sea poquito)
+            return visibleCount > arg.before;
+        },
+        { before: beforeSignals, selectors: PORTAL_SIGNALS_SELECTORS },
+        { timeout }
+    );
+}
+
+/**
+ * Espera a que el portal “vuelva” cerca del baseline (cierre modal).
+ * No exigimos 0 porque el portal puede tener otras cosas; sólo volvemos a <= baseline.
+ */
+async function waitPortalSignalsBackTo(page: Page, baseline: number, timeout = 8000) {
+    await page
+        .waitForFunction(
+            (arg: { baseline: number; selectors: string }) => {
+                const root = document.querySelector('[data-overlay-container]');
+                if (!root) return true;
+
+                const isVisible = (el: Element) => {
+                    const st = getComputedStyle(el as HTMLElement);
+                    if (!st) return false;
+                    if (st.display === 'none' || st.visibility === 'hidden' || Number(st.opacity) === 0) return false;
+                    const r = (el as HTMLElement).getBoundingClientRect();
+                    return r.width > 0 && r.height > 0;
+                };
+
+                const nodes = Array.from(root.querySelectorAll(arg.selectors));
+                const visibleCount = nodes.filter(isVisible).length;
+
+                return visibleCount <= arg.baseline;
+            },
+            { baseline, selectors: PORTAL_SIGNALS_SELECTORS },
+            { timeout }
+        )
+        .catch(() => {
+            // No tronamos el wizard si el portal no baja perfecto; solo avisamos.
+        });
+}
+
+/**
+ * Encuentra un “root” útil dentro del portal para buscar input/opciones.
+ * - Preferimos un contenedor más interno que tenga search/listbox/opciones.
+ * - Si no, usamos el portal completo (acota para no agarrar campos del form).
+ */
+async function getPortalRoot(page: Page): Promise<Locator> {
+    const portal = page.locator(OVERLAY_PORTAL).first();
+    if (!(await portal.count())) return page.locator('body');
+
+    // 1. Preferimos el diálogo completo o sección del modal (contiene todo)
+    const dialog = portal.locator('section[role="dialog"], [role="dialog"]').filter({ visible: true }).last();
+    if (await dialog.count()) return dialog;
+
+    // 2. Si no, el contenedor de la lista
+    const listContainer = portal.locator('[aria-label*="options list"], [role="listbox"]').filter({ visible: true }).last();
+    if (await listContainer.count()) return listContainer;
+
+    return portal;
+}
+
+/**
+ * MODAL CUSTOM (Zona / SelectorModal):
+ * - click al trigger (role=button)
+ * - espera aumento de señales en portal
+ * - ESCRIBE "a" en el search global del modal para activar filtrado
+ * - selecciona la primera opción visible dentro del portal
+ * - intenta cerrar y espera volver al baseline
+ */
+async function selectFirstFromZoneSelectorModal(page: Page, trigger: Locator, label: string) {
+    await ensureNoOverlay(page);
+    const baseline = await countPortalSignals(page);
+
+    // 1. Abrir modal
+    console.log(`     🖱️ Abriendo selector para "${label}"...`);
+    await trigger.click({ force: true });
+
+    // 2. Esperar a que el modal esté presente
+    await waitPortalSignalsIncrease(page, baseline, 8000).catch(() => { });
+    const modal = page.locator('section[role="dialog"]').filter({ visible: true }).last();
+
+    // 3. Buscar y llenar el input de búsqueda (basado en tu HTML exacto)
+    const searchInput = modal.locator('input[aria-label*="Search" i], input[data-slot="input"]').first();
+    try {
+        await searchInput.waitFor({ state: 'visible', timeout: 5000 });
+        await searchInput.click({ force: true });
+        await searchInput.fill('a'); // ACTIVADOR CLAVE
+        await page.waitForTimeout(1200); // Esperar filtrado de React
+    } catch (e) {
+        console.log(`     ⚠️ No se pudo interactuar con el buscador: ${e instanceof Error ? e.message : String(e)}`);
+    }
+
+    // 4. Seleccionar la opción DENTRO del contenedor de lista
+    // IMPORTANTE: Buscamos específicamente en el div con el aria-label de la lista
+    const listContainer = modal.locator('[aria-label*="options list"]').first();
+    const options = listContainer.locator('[role="button"]').filter({ visible: true }).filter({ hasText: /.+/ });
+
+    // Fallback por si el aria-label falla
+    let target = options.first();
+    if (!(await target.count())) {
+        target = modal.locator('div[role="button"]').filter({ visible: true }).filter({ hasNotText: /Close|Refresh|Refresh-CW/i }).first();
+    }
+
+    await target.waitFor({ state: 'visible', timeout: 12000 });
+    const optionText = (await target.innerText().catch(() => '')).trim().split('\n')[0];
+    console.log(`     ✅ [${label}] Seleccionando opción: ${optionText}`);
+
+    // Click ultra-robusto
+    await target.click({ force: true, timeout: 5000 }).catch(async () => {
+        const box = await target.boundingBox();
+        if (box) await page.mouse.click(box.x + box.width / 2, box.y + box.height / 2);
+    });
+
+    // 5. Cerrar y asegurar retorno
+    await page.waitForTimeout(300);
+    await page.keyboard.press('Escape').catch(() => { });
+    await page.mouse.click(5, 5).catch(() => { });
+    await waitPortalSignalsBackTo(page, baseline, 5000);
+    await ensureNoOverlay(page);
+}
+
+/**
+ * ✅ AUTOCOMPLETE genérico:
+ * - si es combobox, escribe 'a', espera listbox, selecciona primera opción
+ * - si no aparece listbox, NO falla: regresa false
+ */
+async function tryHandleAutocomplete(page: Page, combobox: Locator, label: string): Promise<boolean> {
+    await ensureNoOverlay(page);
+
+    await combobox.scrollIntoViewIfNeeded().catch(() => { });
+    await combobox.click({ force: true });
+    await combobox.fill('a');
+
+    const listbox = page.locator(LISTBOX_VISIBLE).last();
+    const appeared = await listbox.isVisible().catch(() => false);
+
+    if (!appeared) return false;
+
+    const opt = listbox.locator(OPTION_VISIBLE).filter({ hasText: /.+/ }).first();
+    await expect(opt).toBeVisible({ timeout: 8000 });
+
+    const optionText = (await opt.innerText().catch(() => '')).trim();
+    console.log(`     ✅ [${label}] Seleccionando (autocomplete): ${optionText || '(sin texto)'}`);
+    await opt.click({ force: true });
+
+    await page.waitForTimeout(150);
+    return true;
+}
+
+/**
+ * ✅ DETECTOR GENÉRICO DE COMPONENTES CUSTOM (SelectorModal, Autocomplete, ZoneSelector, etc.)
+ * Busca elementos que actúan como disparadores (triggers) y que aún no han sido seleccionados.
+ */
+async function fillCustomPickersIfPresent(page: Page, formScope: Locator, filledFieldsIds: Set<string>): Promise<number> {
+    // Buscamos cualquier botón o trigger que contenga texto de "Selecciona" o "Elegir"
+    const potentialTriggers = await formScope.locator('div[role="button"]:visible, [data-slot="trigger"]:visible, .heroui-autocomplete-input-wrapper:visible').all();
+    let count = 0;
+
+    for (const trigger of potentialTriggers) {
+        const text = await trigger.innerText().catch(() => '');
+        // El patrón es: Contiene "Selecciona" o "Elegir" (indica que es un picker vacío)
+        if (/selecciona|elegir|select|uno/i.test(text)) {
+            const label = await getFieldLabel(trigger);
+            const id = await getStableFieldId(trigger);
+
+            if (filledFieldsIds.has(id)) continue;
+
+            console.log(`   - [custom/generic] "${label}"`);
+
+            // Esperar si el componente está en estado Loading (común en HeroUI)
+            const loader = trigger.locator('[data-slot="spinner"], .animate-spin').first();
+            if (await loader.count()) {
+                console.log(`     ⌛ Esperando carga de "${label}"...`);
+                await expect(loader).not.toBeVisible({ timeout: 10000 }).catch(() => { });
+            }
+
+            try {
+                // Usamos tu lógica robusta de portal para seleccionar
+                await selectFirstFromZoneSelectorModal(page, trigger, label);
+                filledFieldsIds.add(id);
+                count++;
+            } catch (e) {
+                console.log(`     ⚠️ Fallo en picker custom "${label}": ${e instanceof Error ? e.message : String(e)}`);
+            }
+        }
+    }
+    return count;
+}
+
+/**
+ * ✅ MANEJADOR DE CARGA DE ARCHIVOS (DropImage / File inputs)
+ * Detecta inputs de tipo file y sube una imagen dummy para cubrir validaciones.
+ */
+/**
+ * ✅ MANEJADOR DE CARGA DE ARCHIVOS (DropImage / File inputs)
+ * Detecta inputs de tipo file y usa archivos REALES si vienen en el prompt, o dummy si no.
+ */
+async function handleFileUploads(page: Page, formScope: Locator, filledFieldsIds: Set<string>) {
+    // 1. Parsear contexto de archivos reales del Prompt
+    const prompt = process.env.SMART_PROMPT || '';
+    const fileMap: Record<string, string> = {}; // "nombre.png" -> "C:\Path\Absoluto\nombre.png"
+
+    const contextMatch = prompt.match(/AVAILABLE FILES[\s\S]*$/);
+    if (contextMatch) {
+        const lines = contextMatch[0].split('\n');
+        for (const line of lines) {
+            // Regex para extraer: File "nombre.ext" -> Use path: "Ruta"
+            const match = line.match(/File "([^"]+)" -> Use path: "([^"]+)"/);
+            if (match) {
+                fileMap[match[1].toLowerCase()] = match[2]; // Mapa insensible a mayúsculas
+            }
+        }
+    }
+    const availableFiles = Object.values(fileMap); // Lista de rutas absolutas disponibles
+
+    // Función auxiliar para subir archivo
+    const uploadFileToInput = async (input: Locator, label: string) => {
+        try {
+            // Estrategia:
+            // 1. Si hay una imagen en el mapa que coincida con el label del input (ej: input "Foto" -> "foto.png"), usarla.
+            // 2. Si no hay coincidencia exacta de nombre, usar la PRIMERA imagen disponible del YAML.
+            // 3. Si no hay imágenes en YAML, usar dummy 1x1 buffer.
+
+            let fileToUse: { name: string, mimeType: string, buffer?: Buffer, path?: string } | null = null;
+
+            // Buscar por coincidencia parcial de nombre en el label (ej: label="Subir Logo", file="logo.png")
+            const matchingFileKey = Object.keys(fileMap).find(k => label.toLowerCase().includes(k.split('.')[0]));
+
+            if (matchingFileKey) {
+                console.log(`     📂 Usando archivo coincidente por nombre para "${label}": ${matchingFileKey}`);
+                await input.setInputFiles(fileMap[matchingFileKey]);
+                return;
+            }
+
+            // Fallback: Usar el primer archivo disponible del YAML (si existe)
+            if (availableFiles.length > 0) {
+                console.log(`     📂 Usando primer archivo disponible para "${label}": ${availableFiles[0]}`);
+                await input.setInputFiles(availableFiles[0]);
+                return;
+            }
+
+            // Fallback final: Dummy Buffer
+            console.log(`     🔹 Usando imagen dummy generada para "${label}" (no se provee archivo real)`);
+            await input.setInputFiles({
+                name: 'test-image.png',
+                mimeType: 'image/png',
+                buffer: Buffer.from('iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mP8/5+hHgAHggJ/PchI7wAAAABJRU5ErkJggg==', 'base64')
+            });
+
+        } catch (e) {
+            console.log(`     ⚠️ No se pudo cargar imagen en "${label}": ${e instanceof Error ? e.message : String(e)}`);
+        }
+    };
+
+    // 1. Buscamos contenedores que parezcan DropImage por su texto (Basado en tu imagen)
+    const markers = await formScope.locator('text=/arrastra|explora|formatos|drop|browse/i').all();
+
+    for (const marker of markers) {
+        const container = marker.locator('xpath=./ancestor::div[contains(@class, "border-dashed") or .//input[@type="file"]]').first();
+        if (!(await container.count())) continue;
+
+        const fileInput = container.locator('input[type="file"]').first();
+        if (!(await fileInput.count())) continue;
+
+        const id = await getStableFieldId(fileInput);
+        if (filledFieldsIds.has(id)) continue;
+
+        const label = await getFieldLabel(fileInput);
+        console.log(`   - [file/image] "${label}"`);
+
+        await uploadFileToInput(fileInput, label);
+        filledFieldsIds.add(id);
+        await page.waitForTimeout(1000);
+    }
+
+    // 2. Fallback para inputs de archivo estándar
+    const allFileInputs = await formScope.locator('input[type="file"]').filter({ visible: false }).all();
+    // Nota: filter visible:false porque los inputs file suelen estar ocultos. Si Playwright no los encuentra con .all(), usamos hidden.
+
+    for (const input of allFileInputs) {
+        const id = await getStableFieldId(input);
+        if (filledFieldsIds.has(id)) continue;
+
+        const isParentVisible = await input.evaluate((el) => {
+            const p = el.parentElement;
+            return p ? (p.getClientRects().length > 0) : false;
+        });
+        if (!isParentVisible) continue;
+
+        console.log(`   - [file-generic] Input estándar detectado`);
+        await uploadFileToInput(input, 'Generic Input');
+        filledFieldsIds.add(id);
+    }
+}
+
+async function getStableFieldId(field: Locator): Promise<string> {
+    const idAttr = await field.getAttribute('id');
+    if (idAttr) return `id:${idAttr}`;
+
+    const box = await field.evaluate((el) => {
+        const r = el.getBoundingClientRect();
+        return { top: Math.round(r.top), left: Math.round(r.left) };
+    });
+    return `pos:${box.top}:${box.left}`;
+}
+
+async function getFieldLabel(field: Locator): Promise<string> {
+    return (
+        (await field
+            .evaluate((el) => {
+                const parent = el.closest('[data-slot="base"], [data-slot="main-wrapper"], fieldset > div, .relative');
+                const innerLabel = parent?.querySelector('[data-slot="label"], label, .heroui-label, .nextui-label, .label');
+                if (innerLabel?.textContent) return innerLabel.textContent.trim();
+
+                const p = el.getAttribute('placeholder') || el.getAttribute('name') || el.getAttribute('aria-label');
+                if (p) return p;
+
+                return (el.textContent || '').split('\n')[0].trim().slice(0, 50) || 'campo';
+            })
+            .catch(() => 'campo')) || 'campo'
+    );
+}
+
+async function isFlowButton(field: Locator): Promise<boolean> {
+    const txt = ((await field.innerText().catch(() => '')) || '').toLowerCase();
+    return (
+        txt.includes('siguiente') ||
+        txt.includes('next') ||
+        txt.includes('guardar') ||
+        txt.includes('save') ||
+        txt.includes('finalizar') ||
+        txt.includes('create') ||
+        txt.includes('atrás') ||
+        txt.includes('back')
+    );
+}
+
+async function isNavOrHeaderNoise(field: Locator): Promise<boolean> {
+    const cls = ((await field.getAttribute('class')) || '').toLowerCase();
+    const id = ((await field.getAttribute('id')) || '').toLowerCase();
+
+    return (
+        cls.includes('nav') ||
+        cls.includes('menu') ||
+        cls.includes('sidebar') ||
+        cls.includes('navbar') ||
+        cls.includes('header') ||
+        id.includes('search') ||
+        id.includes('nav')
+    );
+}
+
+function valueFor(label: string, type: string): string {
+    const l = label.toLowerCase();
+
+    if (type === 'email') return `test.${Date.now()}@example.com`;
+    if (type === 'number') return '10';
+
+    // ✅ Para campos de fecha o datepickers: Siempre fecha FUTURA (hoy + 3 días)
+    if (type === 'date' || /fecha|date|nacimiento/i.test(l)) {
+        const future = new Date();
+        future.setDate(future.getDate() + 3);
+        return future.toISOString().split('T')[0];
+    }
+
+    if (/código postal|cp|postal/i.test(l)) return '12345';
+    if (/código|code/i.test(l)) return `QA-${Math.floor(Math.random() * 1000)}`;
+    if (/latitud/i.test(l)) return '19.4326';
+    if (/longitud/i.test(l)) return '-99.1332';
+
+    return 'Dato Prueba';
+}
+
+test('Smart Action Runner', async ({ page }) => {
+    test.setTimeout(60000); // Aumento timeout a 60s
+    const target = process.env.TARGET_PATH || '/';
+    const base = process.env.BASE_URL || '';
+    const user = process.env.LOGIN_USER || '';
+    const pass = process.env.LOGIN_PASSWORD || '';
+
+    // 1. Monitor de Red (Centinela)
+    // Vigila que no haya errores 403 (Prohibido) o 500+ (Error servidor) en llamadas API
+    const networkErrors: string[] = [];
+    page.on('response', response => {
+        const status = response.status();
+        const url = response.url();
+
+        // Filtramos errores críticos: 403 (Forbidden), 413 (Too Large), 500+ (Server Errors)
+        const resourceType = response.request().resourceType();
+        if ((status === 403 || status === 413 || status >= 500) && ['fetch', 'xhr', 'document'].includes(resourceType)) {
+            let msg = `⚠️  [NETWORK ERROR] ${status} en: ${url}`;
+            if (status === 413) msg += ' (El archivo subido es demasiado pesado para el servidor)';
+            console.log(msg);
+            networkErrors.push(`[${status}] ${url} ${status === 413 ? '(Entity Too Large)' : ''}`);
+        }
+    });
+
+    // 1.1 Login
+    await page.goto(base + '/login', { waitUntil: 'domcontentloaded' });
+    await page.locator('input[type="email"]').fill(user);
+    await page.locator('input[type="password"]').fill(pass);
+    await page.locator('button[type="submit"]').click();
+    await expect(page).not.toHaveURL(/\/login/, { timeout: 15000 });
+
+    // 2. Ir a la lista (🚫 evitar networkidle)
+    console.log('→ Navegando a:', base + target);
+    await page.goto(base + target, { waitUntil: 'domcontentloaded' });
+    await page.waitForLoadState('load').catch(() => { });
+    await page.waitForTimeout(500);
+
+    // 3. Selección de Acción: ¿Creación, Edición, Desactivación, Filtro, Ordenar o Columnas?
+    const prompt = (process.env.SMART_PROMPT || '').toLowerCase();
+    const isFilterMode = /filtro|filtrar|buscar|search|filtra /i.test(prompt);
+    const isSortMode = /ordenar|ordena |sort|order\s+by/i.test(prompt);
+    const isColumnsMode = /columnas?|columns?|selecciona\s+(?:la\s+)?opci[oó]n/i.test(prompt);
+    const isEditMode = /\bedit|actualiz|modific|update|cambiar/i.test(prompt);
+    const isDeactivateMode = /desactiv|elimin|borr|delete|remove/i.test(prompt);
+    // CREACIÓN solo si explícitamente dice crear/nuevo/new/add (no como fallback)
+    const isCreateMode = /\bcrear\b|\bnuevo\b|\bnueva\b|\bnew\b|\badd\b|\bagregar\b/i.test(prompt);
+
+    // Determinar modo (prioridad: Columnas > Ordenar > Filtro > Desactivación > Edición > Creación > Genérico)
+    let detectedMode = 'GENÉRICO';
+    if (isColumnsMode) detectedMode = 'COLUMNAS';
+    else if (isSortMode) detectedMode = 'ORDENAR';
+    else if (isFilterMode) detectedMode = 'FILTRO';
+    else if (isDeactivateMode) detectedMode = 'DESACTIVACIÓN';
+    else if (isEditMode) detectedMode = 'EDICIÓN';
+    else if (isCreateMode) detectedMode = 'CREACIÓN';
+
+    console.log(`🔍 [SMART-MODE] Prompt recibido: "${prompt}"`);
+    console.log(`🔍 [SMART-MODE] Modo detectado: ${detectedMode}`);
+
+    // =============== MODO ORDENAR ===============
+    if (isSortMode) {
+        console.log('→ Entrando en modo ORDENAR...');
+
+        // 3.1 Buscar y hacer clic en botón de Ordenar
+        const sortBtn = page
+            .getByRole('button', { name: /ordenar|sort/i })
+            .or(page.locator('button:has-text("Ordenar")'))
+            .or(page.locator('button:has-text("Sort")'))
+            .filter({ visible: true })
+            .first();
+
+        await expect(sortBtn).toBeVisible({ timeout: 10000 }).catch(() => {
+            throw new Error('No se encontró el botón de Ordenar en la vista.');
+        });
+
+        await sortBtn.click();
+        console.log('✅ Clic en botón de Ordenar realizado.');
+
+        // 3.2 Esperar que se abra el menú desplegable
+        await page.waitForTimeout(800);
+
+        // 3.3 Extraer la opción de ordenamiento del prompt
+        // Patrones: "ordena por [OPCION]", "ordenar por [OPCION]", "opción de [OPCION]"
+        const sortOptionPatterns = [
+            /(?:ordena|ordenar)\s+por\s+(?:la\s+)?(?:opci[oó]n\s+(?:de\s+)?)?(.+?)(?:\.|$)/i,
+            /opci[oó]n\s+(?:de\s+)?(.+?)(?:\.|$)/i,
+            /(?:sort|order)\s+by\s+(.+?)(?:\.|$)/i
+        ];
+
+        let sortOption = '';
+        for (const pattern of sortOptionPatterns) {
+            const match = prompt.match(pattern);
+            if (match && match[1]) {
+                sortOption = match[1].trim();
+                break;
+            }
+        }
+
+        console.log(`📋 Opción de ordenamiento detectada: "${sortOption}"`);
+
+        if (sortOption) {
+            // 3.4 Buscar y hacer clic en la opción del menú
+            // El menú usa role="menu" con li[role="menuitem"]
+            const menuOption = page
+                .locator('[role="menu"] [role="menuitem"]')
+                .filter({ hasText: new RegExp(sortOption, 'i') })
+                .first()
+                .or(page.locator('[role="listbox"] [role="option"]').filter({ hasText: new RegExp(sortOption, 'i') }).first())
+                .or(page.locator('li, div').filter({ hasText: new RegExp(`^${sortOption}$`, 'i') }).first());
+
+            if (await menuOption.isVisible({ timeout: 3000 }).catch(() => false)) {
+                await menuOption.click();
+                console.log(`✅ Opción "${sortOption}" seleccionada.`);
+            } else {
+                console.log(`⚠️ No se encontró la opción "${sortOption}" en el menú.`);
+                // Listar opciones disponibles para debug
+                const options = await page.locator('[role="menu"] [role="menuitem"]').allTextContents();
+                console.log(`   📋 Opciones disponibles: ${options.join(', ')}`);
+            }
+        } else {
+            console.log('⚠️ No se especificó opción de ordenamiento en el prompt.');
+        }
+
+        await page.waitForTimeout(500);
+        console.log('🎉 Modo ORDENAR completado.');
+        return;
+    }
+
+    // =============== MODO COLUMNAS ===============
+    if (isColumnsMode) {
+        console.log('→ Entrando en modo COLUMNAS...');
+
+        // 3.1 Buscar y hacer clic en botón de Columnas
+        const columnsBtn = page
+            .getByRole('button', { name: /columnas?|columns?/i })
+            .or(page.locator('button:has-text("Columnas")'))
+            .or(page.locator('button:has-text("Columns")'))
+            .filter({ visible: true })
+            .first();
+
+        await expect(columnsBtn).toBeVisible({ timeout: 10000 }).catch(() => {
+            throw new Error('No se encontró el botón de Columnas en la vista.');
+        });
+
+        await columnsBtn.click();
+        console.log('✅ Clic en botón de Columnas realizado.');
+
+        // 3.2 Esperar que se abra el menú desplegable
+        await page.waitForTimeout(800);
+
+        // 3.3 Extraer las opciones del prompt
+        // El patrón clave es: "selecciona la opción de [OPCIONES]" donde OPCIONES viene DESPUÉS de "de"
+        let optionsText = '';
+
+        // Patrón específico: buscar "opción de [X]" o "opciones de [X]"
+        const optionMatch = prompt.match(/opci[oó]n(?:es)?\s+(?:de\s+)?([^.]+)/i);
+        if (optionMatch && optionMatch[1]) {
+            optionsText = optionMatch[1].trim();
+        }
+
+        // Si no encontró con ese patrón, buscar después de "columnas" o "selecciona"
+        if (!optionsText) {
+            const fallbackMatch = prompt.match(/(?:columnas|selecciona)\s+(.+?)(?:\.|$)/i);
+            if (fallbackMatch && fallbackMatch[1]) {
+                optionsText = fallbackMatch[1].trim()
+                    .replace(/^(?:la\s+)?opci[oó]n(?:es)?\s+(?:de\s+)?/i, ''); // Limpiar prefijo si quedó
+            }
+        }
+
+        // Separar múltiples opciones por "y", "and", ","
+        const optionsList = optionsText
+            .split(/\s+y\s+|\s+and\s+|,\s*/)
+            .map(o => o.trim().replace(/['"]/g, '')) // Limpiar comillas
+            .filter(o => o.length > 0 && o.length < 50); // Filtrar opciones demasiado largas
+
+        console.log(`📋 Opciones detectadas: [${optionsList.join('], [')}]`);
+
+        for (const optionName of optionsList) {
+            console.log(`   → Buscando opción "${optionName}"...`);
+
+            // Estrategia HeroUI: Las opciones están en spans dentro de li[role="menuitem"]
+            const menuOption = page
+                .locator('[role="menu"]')
+                .locator('li[role="menuitem"]')
+                .filter({ hasText: new RegExp(optionName, 'i') })
+                .first();
+
+            if (await menuOption.isVisible({ timeout: 2000 }).catch(() => false)) {
+                await menuOption.click();
+                console.log(`   ✅ Opción "${optionName}" seleccionada.`);
+                await page.waitForTimeout(300);
+            } else {
+                // Fallback 1: Buscar en labels (HeroUI usa labels para checkboxes)
+                const labelOption = page.locator(`[role="menu"] label`).filter({ hasText: new RegExp(optionName, 'i') }).first();
+                if (await labelOption.isVisible({ timeout: 1000 }).catch(() => false)) {
+                    await labelOption.click();
+                    console.log(`   ✅ Opción "${optionName}" seleccionada (via label).`);
+                    await page.waitForTimeout(300);
+                } else {
+                    console.log(`   ⚠️ No se encontró la opción "${optionName}" en el menú.`);
+                    // Debug: listar opciones disponibles
+                    const availableOptions = await page.locator('[role="menu"] li[role="menuitem"], [role="menu"] label').allTextContents();
+                    const uniqueOptions = [...new Set(availableOptions.filter(o => o.trim().length > 0))].map(o => o.trim().split('\n')[0]);
+                    console.log(`      📋 Opciones disponibles (primeros 10): ${uniqueOptions.slice(0, 10).join(', ')}`);
+                }
+            }
+        }
+
+        if (optionsList.length === 0) {
+            console.log('⚠️ No se especificaron opciones en el prompt.');
+            const options = await page.locator('[role="menu"] [role="menuitem"], [role="menu"] label').allTextContents();
+            console.log(`   📋 Opciones disponibles: ${options.map(o => o.trim().split('\n')[0]).join(', ')}`);
+        }
+
+        await page.waitForTimeout(500);
+        console.log('🎉 Modo COLUMNAS completado.');
+        return;
+    }
+
+    // =============== MODO FILTRO ===============
+    if (isFilterMode) {
+        console.log('→ Entrando en modo FILTRO...');
+
+        // 3.1 Buscar y hacer clic en botón de Filtros
+        const filterBtn = page
+            .getByRole('button', { name: /filtro|filter/i })
+            .or(page.locator('button:has-text("Filtros")'))
+            .or(page.locator('button:has-text("Filter")'))
+            .filter({ visible: true })
+            .first();
+
+        await expect(filterBtn).toBeVisible({ timeout: 10000 }).catch(() => {
+            throw new Error('No se encontró el botón de Filtros en la vista.');
+        });
+
+        await filterBtn.click();
+        console.log('✅ Clic en botón de Filtros realizado.');
+
+        // 3.2 Esperar que se abra el panel lateral (side panel)
+        await page.waitForTimeout(800);
+        const filterPanel = page
+            .locator('[role="dialog"], [data-slot="drawer"], aside, .drawer, .side-panel, .filter-panel, div[class*="drawer"], div[class*="panel"]')
+            .filter({ has: page.locator('input, select, button') })
+            .first();
+
+        await expect(filterPanel).toBeVisible({ timeout: 10000 }).catch(() => {
+            console.log('⚠️ No se detectó panel lateral explícito, continuando con la página completa...');
+        });
+
+        // 3.3 Extraer instrucciones del prompt usando CAMPOS CONOCIDOS
+        // En lugar de regex complejos, buscamos nombres de campos conocidos y extraemos valores cercanos
+
+        const knownFields = [
+            'nombre completo', 'teléfono', 'telefono', 'correo electrónico', 'correo',
+            'email', 'código de referido', 'codigo de referido', 'código', 'codigo',
+            'fecha', 'nombre', 'descripción', 'descripcion', 'título', 'titulo'
+        ];
+
+        const fieldInstructions: Array<{ field: string; value: string }> = [];
+
+        for (const fieldName of knownFields) {
+            // Patrón 1: "campo : valor" o "campo = valor"
+            const colonPattern = new RegExp(`${fieldName}\\s*[:=]\\s*([\\w\\d@._-]+)`, 'i');
+            const colonMatch = prompt.match(colonPattern);
+            if (colonMatch && colonMatch[1]) {
+                const value = colonMatch[1].trim();
+                if (value && !fieldInstructions.some(f => f.field.toLowerCase() === fieldName.toLowerCase())) {
+                    fieldInstructions.push({ field: fieldName, value });
+                }
+                continue;
+            }
+
+            // Patrón 2: "valor en el input de campo"
+            const inFieldPattern = new RegExp(`([\\w\\d\\s@._-]+?)\\s+en\\s+(?:el\\s+)?(?:input|campo)\\s+(?:de\\s+)?${fieldName}`, 'i');
+            const inFieldMatch = prompt.match(inFieldPattern);
+            if (inFieldMatch && inFieldMatch[1]) {
+                let value = inFieldMatch[1].trim();
+                // Limpiar prefijos de instrucción
+                value = value.replace(/^.*(?:escribe|poner|ingresa|coloca)\s+(?:el\s+)?(?:nombre\s+de\s+)?/i, '').trim();
+                if (value && value.length < 100 && !fieldInstructions.some(f => f.field.toLowerCase() === fieldName.toLowerCase())) {
+                    fieldInstructions.push({ field: fieldName, value });
+                }
+            }
+        }
+
+        // Si no encontramos nada con campos conocidos, intentar patrón genérico simple
+        if (fieldInstructions.length === 0) {
+            const simplePattern = /escribe\s+(?:el\s+)?(?:nombre\s+de\s+)?(.+?)\s+en\s+(?:el\s+)?(?:input|campo)\s+(?:de\s+)?(.+?)(?:\.|$)/i;
+            const simpleMatch = prompt.match(simplePattern);
+            if (simpleMatch && simpleMatch[1] && simpleMatch[2]) {
+                fieldInstructions.push({
+                    field: simpleMatch[2].trim(),
+                    value: simpleMatch[1].trim()
+                });
+            }
+        }
+
+        console.log('📝 Instrucciones de llenado detectadas:', fieldInstructions);
+
+        // 3.4 Llenar los campos de filtro
+        // Detectamos el scope (panel de filtro o página completa)
+        const panelVisible = await filterPanel.isVisible().catch(() => false);
+        const scope = panelVisible ? filterPanel : page;
+        console.log(`   📍 Scope de búsqueda: ${panelVisible ? 'Panel de Filtros' : 'Página completa'}`);
+
+        for (const instr of fieldInstructions) {
+            console.log(`   → Buscando campo "${instr.field}" para escribir "${instr.value}"...`);
+
+            // Estrategia multi-framework para encontrar inputs:
+            // 1. HeroUI/NextUI: [data-slot="base"] que contenga label con texto -> buscar input[data-slot="input"] dentro
+            // 2. Standard: label[for] + input con ese id
+            // 3. Fallback: getByLabel de Playwright
+
+            let fieldFound = false;
+
+            // Estrategia 1: HeroUI/NextUI pattern (CORREGIDO)
+            // Buscamos contenedor [data-slot="base"] que contenga el texto del campo (case-insensitive)
+            const heroContainer = scope.locator('[data-slot="base"]').filter({
+                hasText: new RegExp(instr.field, 'i')
+            }).first();
+
+            const heroContainerCount = await scope.locator('[data-slot="base"]').count();
+            console.log(`      📊 Contenedores [data-slot="base"] encontrados: ${heroContainerCount}`);
+
+            if (await heroContainer.isVisible({ timeout: 2000 }).catch(() => false)) {
+                console.log(`      🎯 Contenedor HeroUI encontrado para "${instr.field}"`);
+                const heroInput = heroContainer.locator('input[data-slot="input"], textarea[data-slot="input"], input, textarea').first();
+                if (await heroInput.isVisible({ timeout: 1000 }).catch(() => false)) {
+                    await heroInput.fill(instr.value);
+                    console.log(`   ✅ [HeroUI] Campo "${instr.field}" llenado con "${instr.value}"`);
+                    fieldFound = true;
+                } else {
+                    console.log(`      ⚠️ Input no encontrado dentro del contenedor`);
+                }
+            } else {
+                console.log(`      ⚠️ No se encontró contenedor HeroUI con texto "${instr.field}"`);
+            }
+
+            // Estrategia 2: Buscar por role="dialog" (el panel tiene role="dialog")
+            if (!fieldFound) {
+                const dialogPanel = page.locator('[role="dialog"]').filter({ hasText: 'Filtros' }).first();
+                const dialogInput = dialogPanel.locator('[data-slot="base"]').filter({
+                    hasText: new RegExp(instr.field, 'i')
+                }).locator('input, textarea').first();
+
+                if (await dialogInput.isVisible({ timeout: 1000 }).catch(() => false)) {
+                    await dialogInput.fill(instr.value);
+                    console.log(`   ✅ [Dialog] Campo "${instr.field}" llenado con "${instr.value}"`);
+                    fieldFound = true;
+                }
+            }
+
+            // Estrategia 3: Selector estándar (placeholder, aria-label, getByLabel)
+            if (!fieldFound) {
+                const standardLocators = [
+                    page.locator(`input[placeholder*="${instr.field}" i]`),
+                    page.locator(`input[aria-label*="${instr.field}" i]`),
+                    page.locator(`textarea[placeholder*="${instr.field}" i]`),
+                    page.getByLabel(new RegExp(instr.field, 'i')),
+                ];
+
+                for (const loc of standardLocators) {
+                    if (await loc.first().isVisible({ timeout: 500 }).catch(() => false)) {
+                        await loc.first().fill(instr.value);
+                        console.log(`   ✅ [Standard] Campo "${instr.field}" llenado con "${instr.value}"`);
+                        fieldFound = true;
+                        break;
+                    }
+                }
+            }
+
+            if (!fieldFound) {
+                console.log(`   ⚠️ No se encontró campo para "${instr.field}"`);
+            }
+        }
+
+        // 3.5 Buscar y hacer clic en botón Aplicar/Buscar (si existe)
+        await page.waitForTimeout(500);
+        const applyBtn = scope
+            .getByRole('button', { name: /aplicar|apply|buscar|search|filtrar|filter$/i })
+            .filter({ visible: true })
+            .first();
+
+        if (await applyBtn.isVisible({ timeout: 2000 }).catch(() => false)) {
+            await applyBtn.click();
+            console.log('✅ Filtros aplicados.');
+        } else {
+            console.log('ℹ️ No se encontró botón de aplicar (posiblemente filtros automáticos).');
+        }
+
+        // 3.6 Esperar resultados
+        await page.waitForTimeout(1000);
+        console.log('🎉 Modo FILTRO completado.');
+        return;
+    }
+
+    let actionBtn;
+    if (isDeactivateMode) {
+        console.log('→ Buscando botón de DESACTIVACIÓN/BORRADO (Delete/Remove)...');
+        actionBtn = page
+            .getByRole('button', { name: /desactiv|elimin|borr|delete|remove|power/i })
+            .or(page.locator('button[aria-label*="delete" i], button[aria-label*="eliminar" i], button[aria-label*="borrar" i], button[aria-label*="power" i]'))
+            .or(page.locator('.lucide-trash, .lucide-trash-2, .lucide-ban, .lucide-power-off, [data-slot="delete-icon"]').locator('..'))
+            .filter({ visible: true })
+            .first();
+    } else if (/(^|\W)(descarg|export|bajar|get|obtener|download)($|\W)/i.test(prompt) && !/(\\|\/)downloads(\\|\/)/i.test(prompt)) {
+        console.log('→ Buscando botón de DESCARGA/EXPORTACIÓN...');
+        actionBtn = page
+            .getByRole('button', { name: /descarg|export|bajar|get|obtener|download|excel|pdf|csv/i })
+            .or(page.getByRole('link', { name: /descarg|export|bajar|get|obtener|download|excel|pdf|csv/i }))
+            .or(page.locator('button[aria-label*="download" i], button[aria-label*="export" i], button[aria-label*="descargar" i]'))
+            .or(page.locator('.lucide-download, .lucide-file-down, .lucide-share, [data-slot="download-icon"]').locator('..'))
+            .filter({ visible: true })
+            .first();
+
+        // Listen for download event BEFORE clicking
+        const downloadPromise = page.waitForEvent('download', { timeout: 15000 }).catch(() => null);
+
+        await expect(actionBtn).toBeVisible({ timeout: 10000 }).catch(() => {
+            throw new Error(`No se encontró botón de Descarga/Exportación.`);
+        });
+
+        await actionBtn.click();
+        console.log('✅ Clic en botón de Descarga realizado.');
+
+        const download = await downloadPromise;
+        if (download) {
+            console.log(`🎉 Descarga iniciada: ${download.suggestedFilename()}`);
+            await download.path(); // Wait for finish
+            console.log('✅ Archivo descargado correctamente.');
+            return;
+        } else {
+            console.warn('⚠️ No se detectó evento de descarga (tal vez abrió en nueva pestaña o no inició).');
+            // Si no hubo evento download, buscamos confirmación visual por si acaso
+        }
+        return; // Terminate for download tasks
+    } else if (isEditMode) {
+        console.log('→ Buscando botón de EDICIÓN (Edit/Update)...');
+        // Buscamos botones de edición, pero EXCLUIMOS los botones de "Crear/Nuevo"
+        actionBtn = page
+            .locator('button, a, [role="button"]')
+            .filter({ hasText: /edit|actualiz|modific|update/i })
+            .filter({ hasNotText: /nuevo|nueva|crear|new|add|agregar/i }) // IMPORTANTE: No confundir con "Nuevo"
+            .or(page.locator('button[aria-label*="edit" i], a[aria-label*="edit" i], [href*="edit" i]'))
+            .or(page.locator('.lucide-pencil, .lucide-edit, [data-slot="edit-icon"]').locator('..'))
+            .filter({ visible: true })
+            .first();
+    } else {
+        console.log('→ Buscando botón de CREACIÓN (New/Create)...');
+        // Para creación no suele haber "random" ni "target specifics" (salvo validaciones futuras)
+        actionBtn = page
+            .getByRole('button', { name: /nuevo|nueva|crear|new|add|agregar/i })
+            .or(page.getByRole('link', { name: /nuevo|nueva|crear|new|add|agregar/i }))
+            .filter({ visible: true })
+            .first();
+    }
+
+    // --- LOGICA DE SELECCIÓN (RANDOM / SPECIFIC) PARA EDIT/DELETE ---
+    const targetRecord = process.env.SMART_TARGET_RECORD || '';
+    const isRandom = process.env.SMART_IS_RANDOM === 'true';
+
+    // Si estamos en modo Edit/Delete verificamos si hay que filtrar o elegir aleatorio
+    if ((isEditMode || isDeactivateMode) && actionBtn) {
+        // Redefinimos actionBtn como una lista de candidatos si es necesario
+        // Nota: actionBtn arriba ya tenía .first(), así que necesitamos reconstruir el locator SIN .first()
+        // Copiamos la lógica de selectores de arriba pero sin .first()
+        let candidates;
+
+        if (isDeactivateMode) {
+            candidates = page
+                .getByRole('button', { name: /desactiv|elimin|borr|delete|remove|power/i })
+                .or(page.locator('button[aria-label*="delete" i], button[aria-label*="eliminar" i], button[aria-label*="borrar" i], button[aria-label*="power" i]'))
+                .or(page.locator('.lucide-trash, .lucide-trash-2, .lucide-ban, .lucide-power-off, [data-slot="delete-icon"]').locator('..'))
+                .filter({ visible: true });
+        } else {
+            // Edit Mode
+            candidates = page
+                .locator('button, a, [role="button"]')
+                .filter({ hasText: /edit|actualiz|modific|update/i })
+                .filter({ hasNotText: /nuevo|nueva|crear|new|add|agregar/i })
+                .or(page.locator('button[aria-label*="edit" i], a[aria-label*="edit" i], [href*="edit" i]'))
+                .or(page.locator('.lucide-pencil, .lucide-edit, [data-slot="edit-icon"]').locator('..'))
+                .filter({ visible: true });
+        }
+
+        if (targetRecord) {
+            console.log(`🎯 Filtrando por registro: "${targetRecord}"`);
+            // Estrategia: Buscar contenedor (fila/card) que tenga el texto, luego buscar botón dentro
+            const rowLocator = page.locator('tr, [role="row"], .card, li, div.border, div.shadow').filter({ hasText: targetRecord });
+
+            // Si encontramos filas, buscamos el botón dentro
+            if (await rowLocator.count() > 0) {
+                actionBtn = rowLocator.locator(candidates).first();
+            } else {
+                console.warn(`⚠️ No se encontraron filas con el texto "${targetRecord}". Se intentará buscar el botón globalmente.`);
+                actionBtn = candidates.first();
+            }
+        } else if (isRandom) {
+            console.log('🎲 Seleccionando registro ALEATORIO...');
+            const count = await candidates.count();
+            if (count > 0) {
+                const randIndex = Math.floor(Math.random() * count);
+                actionBtn = candidates.nth(randIndex);
+                console.log(`   ➡ Elegido índice ${randIndex} de ${count} candidatos.`);
+            } else {
+                actionBtn = candidates.first();
+            }
+        } else {
+            // Default: primero
+            actionBtn = candidates.first();
+        }
+    }
+
+
+    await expect(actionBtn).toBeVisible({ timeout: 10000 }).catch(() => {
+        throw new Error(`No se encontró el botón de ${isDeactivateMode ? 'Desactivación' : (isEditMode ? 'Edición' : 'Creación')} en la vista.`);
+    });
+
+    await actionBtn.click();
+    console.log(`✅ Clic en botón de ${isDeactivateMode ? 'Desactivación' : (isEditMode ? 'Edición' : 'Acción')} realizado.`);
+
+    // 3.1 Manejo especial para Desactivación/Borrado (Confirmación)
+    if (isDeactivateMode) {
+        console.log('→ Detectando posible modal de confirmación...');
+        await page.waitForTimeout(1000);
+        const confirmBtn = page.getByRole('button', { name: /aceptar|confirmar|si|yes|delete|eliminar|borrar/i })
+            .filter({ visible: true })
+            .first();
+
+        if (await confirmBtn.isVisible()) {
+            console.log('   ➡ Modal de confirmación detectado. Haciendo clic en confirmar...');
+            await confirmBtn.click();
+        } else {
+            console.log('   🏁 No se detectó modal de confirmación explícito.');
+        }
+
+        // Esperamos confirmación final y terminamos el test (no hay formulario que llenar)
+        const confirmation = page
+            .getByRole('alert')
+            .or(page.getByRole('status'))
+            .or(page.getByText(/exitosamente|success|borrado|eliminado|desactivado|éxito|correctamente/i));
+
+        await expect(confirmation.first()).toBeVisible({ timeout: 15000 });
+        console.log('🎉 Registro procesado (Desactivado/Borrado) con éxito.');
+        return;
+    }
+
+    // 4. Scope del formulario (wizard)
+    await page.waitForTimeout(1000);
+    const formScope = page
+        .locator('form, [role="dialog"], [role="main"], fieldset, .modal-content')
+        .filter({ has: page.locator('input, textarea, select, [role="combobox"], button, [data-slot]') })
+        .first();
+
+    await expect(formScope).toBeVisible({ timeout: 10000 });
+
+    // 5. Llenado inteligente (wizard/multistep)
+    console.log('→ Iniciando llenado de formulario...');
+
+    let step = 1;
+    let hasNext = true;
+    const filledFieldsIds = new Set<string>();
+
+    while (hasNext && step < 10) {
+        console.log(`\n📦 Pasando al paso #${step} del formulario...`);
+        await ensureNoOverlay(page);
+
+        // 5.0 Componentes custom genéricos y Carga de archivos
+        try {
+            await fillCustomPickersIfPresent(page, formScope, filledFieldsIds);
+            await handleFileUploads(page, formScope, filledFieldsIds);
+        } catch (e) {
+            console.log(`     ⚠️ ERROR en componentes custom/archivos: ${e instanceof Error ? e.message : String(e)}`);
+        }
+        await ensureNoOverlay(page);
+
+        // Scan genérico de campos
+        const fieldSelector = [
+            'input:not([type="hidden"])',
+            'textarea',
+            'select',
+            '[role="combobox"]',
+            'button[aria-haspopup]',
+            '[data-slot="trigger"]',
+            'button[type="button"]:not([disabled])', // Agregamos botones normales
+        ].join(', ');
+
+        const allPotentialFields = await formScope.locator(fieldSelector).all();
+
+        for (const field of allPotentialFields) {
+            await ensureNoOverlay(page);
+
+            if (!(await field.isVisible()) || (await field.isDisabled())) continue;
+
+            const id = await getStableFieldId(field);
+            if (filledFieldsIds.has(id)) continue;
+
+            if (await isNavOrHeaderNoise(field)) continue;
+            // OJO: isFlowButton filtra "Siguiente", "Guardar", etc.
+            // Si el botón es "Configurar preguntas", NO debería ser filtrado por isFlowButton si está bien implementado.
+            // Pero por seguridad, verificaremos el texto antes de descartar.
+            const label = await getFieldLabel(field);
+            const isNavigation = /siguiente|next|guardar|save|enviar|submit|cancelar|cancel/i.test(label);
+
+            if (await isFlowButton(field) || isNavigation) {
+                // Doble chequeo: Si dice "Agregar" o "Configurar", NO es navegación de flujo principal
+                if (!/agregar|add|configurar|config|gestionar|manage/i.test(label)) {
+                    continue;
+                }
+            }
+
+            const tag = await field.evaluate((el) => el.tagName.toLowerCase());
+            const role = (await field.getAttribute('role')) || '';
+            const type = (await field.getAttribute('type')) || '';
+            const ariaAutocomplete = (await field.getAttribute('aria-autocomplete')) || '';
+
+            // label ya fue declarado arriba
+            // const label = await getFieldLabel(field);
+
+            // Evitar Zona o botones de navegación desde el scan genérico
+            if (/^zona$/i.test(label) || label.toLowerCase().includes('zonaselecciona')) {
+                filledFieldsIds.add(id);
+                continue;
+            }
+
+            console.log(`   - [${tag}/${role || '-'}] "${label}"`);
+
+            try {
+                let handled = false;
+
+                // ✅ Autocomplete genérico
+                const looksLikeAutocomplete = role === 'combobox' || ariaAutocomplete !== '';
+                if (looksLikeAutocomplete) {
+                    console.log(`     🖱️ Intentando AUTOCOMPLETE para "${label}"...`);
+                    handled = await tryHandleAutocomplete(page, field, label);
+                }
+
+                // ✅ HeroUI Select o Trigger de Modal
+                const overrides = JSON.parse(process.env.SMART_FIELD_OVERRIDES || '{}');
+                const overrideKey = Object.keys(overrides).find(k => label.toLowerCase().includes(k.toLowerCase()));
+                const cleanPrompt = (process.env.SMART_PROMPT || '').toLowerCase();
+
+                if (!handled && (tag === 'button' || (await field.getAttribute('data-slot')) === 'trigger')) {
+                    const ariaHasPopup = await field.getAttribute('aria-haspopup');
+
+                    if (ariaHasPopup === 'listbox') {
+                        console.log(`     🔽 Detectado HeroUI Select para "${label}"`);
+                        const val = overrideKey ? overrides[overrideKey] : valueFor(label, 'select');
+                        handled = await handleHeroUISelect(page, field, val);
+                    } else {
+                        // Detección proactiva de disparadores de modal
+                        const isModalTrigger = /configurar|gestionar|agregar|add|manage|config|preguntas|respuestas/i.test(label) ||
+                            cleanPrompt.includes(label.toLowerCase().replace(/\*/g, '').trim()) ||
+                            overrideKey;
+
+                        if (isModalTrigger) {
+                            console.log(`     📦 [TRIGGER] Acción detectada: "${label}". Evaluando apertura...`);
+                            const instruction = overrideKey ? overrides[overrideKey] : cleanPrompt;
+                            handled = await handleModalSubform(page, field, instruction);
+                        }
+                    }
+                }
+
+                // select nativo
+                if (!handled && tag === 'select') {
+                    const opts = field.locator('option');
+                    if ((await opts.count()) > 1) {
+                        const val = await opts.nth(1).getAttribute('value');
+                        if (val) await field.selectOption(val);
+                    }
+                    handled = true;
+                }
+
+                if (!handled && (tag === 'input' || tag === 'textarea')) {
+                    let val = valueFor(label, type);
+
+                    if (overrideKey) {
+                        val = overrides[overrideKey];
+                        console.log(`     ✨ Usando valor específico para "${label}": "${val}"`);
+                    }
+
+                    await field.fill(val);
+                    handled = true;
+                }
+
+                filledFieldsIds.add(id);
+            } catch (e) {
+                console.log(`     ⚠️ ERROR en campo "${label}": ${e instanceof Error ? e.message : String(e)}`);
+                filledFieldsIds.add(id);
+            }
+        }
+
+        // Avance wizard
+        await ensureNoOverlay(page);
+
+        const nextBtn = page.getByRole('button', { name: /siguiente|next/i }).filter({ visible: true });
+        if ((await nextBtn.count()) > 0 && (await nextBtn.first().isEnabled())) {
+            console.log('   ➡ Botón "Siguiente" detectado. Avanzando...');
+            await nextBtn.first().click();
+            await page.waitForTimeout(1000);
+            step++;
+        } else {
+            console.log('   🏁 No hay más botones de "Siguiente". Procediendo a Guardar.');
+            hasNext = false;
+        }
+    }
+
+    // --- FINALIZACIÓN: CLIC EN GUARDAR PRINCIPAL ---
+    console.log('\n→ [FINAL] Intentando Guardar el registro principal...');
+    await page.waitForTimeout(1000);
+    await ensureNoOverlay(page);
+
+    const submitBtn = page
+        .locator('button')
+        .filter({ hasText: /guardar|save|crear|create|finalizar/i })
+        .filter({ visible: true })
+        .last(); // Usamos .last() por si hay botones fantasmas en el header
+
+    if (await submitBtn.isVisible({ timeout: 10000 })) {
+        if (await submitBtn.isDisabled()) {
+            console.warn('     ⚠️ Botón Guardar principal deshabilitado. Intentando scroll...');
+            await submitBtn.scrollIntoViewIfNeeded();
+            await page.waitForTimeout(500);
+        }
+        await submitBtn.click({ force: true });
+        console.log('✅ [EXITO] Clic en botón "Guardar" principal realizado.');
+    } else {
+        console.error('❌ [ERROR] No se pudo encontrar el botón de Guardar final.');
+    }
+});
+
+async function handleHeroUISelect(page: any, trigger: any, value: string) {
+    await trigger.click();
+    await page.waitForTimeout(600);
+    const listbox = page.locator('[role="listbox"], [role="menu"]').filter({ visible: true }).first();
+
+    // Si no vemos el listbox, puede que ya estuviera abierto o que el click fallara. 
+    // Re-intentamos levemente o buscamos opciones.
+    const options = listbox.locator('[role="option"], [role="menuitem"]');
+
+    // Intentamos buscar por texto exacto o parcial
+    let option = options.filter({ hasText: new RegExp(`^${value}$`, 'i') }).first();
+    if (!(await option.isVisible())) {
+        option = options.filter({ hasText: new RegExp(value, 'i') }).first();
+    }
+
+    if (await option.isVisible({ timeout: 2000 }).catch(() => false)) {
+        await option.click();
+        console.log(`       ✅ Opción "${value}" seleccionada.`);
+        return true;
+    }
+
+    // Fallback: Si no encontramos "Otros", intentamos con el primer elemento disponible 
+    // para no dejar el campo vacío y no cerrar el modal con Escape.
+    const firstOpt = options.first();
+    if (await firstOpt.isVisible()) {
+        const text = await firstOpt.innerText();
+        await firstOpt.click();
+        console.log(`       ✅ Opción "${value}" no encontrada. Usando fallback: "${text.trim()}"`);
+        return true;
+    }
+
+    console.log(`       ⚠️ No se pudo seleccionar nada en el select para "${value}".`);
+    // NO presionamos Escape aquí si no estamos seguros de que no cerrará el modal. 
+    // Es preferible dejar el listbox abierto que cerrar el modal.
+    await page.mouse.click(10, 10).catch(() => { }); // Click fuera neutral
+    return false;
+}
+
+async function handleModalSubform(page: any, trigger: any, instructions: string) {
+    console.log(`     🚀 [MODAL] Gestionando sub-formulario dinámico. Prompt: "${instructions}"`);
+    await trigger.click();
+    await page.waitForTimeout(2500);
+
+    const modal = page.locator('[role="dialog"], section[role="dialog"]').filter({ visible: true }).last();
+    if (!(await modal.isVisible({ timeout: 6000 }).catch(() => false))) {
+        console.warn('     ⚠️ No se detectó el modal abierto.');
+        return false;
+    }
+
+    const header = await modal.locator('header, h2, [role="banner"]').first().innerText().catch(() => 'Modal');
+    console.log(`     📦 Trabajando en: "${header.split('\n')[0]}"`);
+
+    // --- 1. PREPARACIÓN ESTRUCTURAL ---
+    const questMatch = instructions.match(/(\d+)\s+preguntas/i);
+    let targetQuests = questMatch ? parseInt(questMatch[1]) : 1;
+    const wantsNewQuest = /agrega(?:r)?\s+(?:una\s+)?nueva\s+pregunta|otra\s+pregunta/i.test(instructions);
+
+    const addQuestBtn = modal.locator('button').filter({ hasText: /agregar nueva pregunta|add new question/i }).first();
+
+    // Función para encontrar bloques de pregunta de forma dinámica
+    const getBlocks = async () => {
+        // Buscamos contenedores que tengan un botón de "agregar respuesta"
+        const potential = modal.locator('.heroui-card, fieldset, .border-default-200');
+        const count = await potential.count();
+        const valid = [];
+        for (let i = 0; i < count; i++) {
+            const block = potential.nth(i);
+            if (await block.locator('button').filter({ hasText: /agregar respuesta|add answer/i }).count() > 0) {
+                valid.push(block);
+            }
+        }
+        return valid;
+    };
+
+    let blocks = await getBlocks();
+    let currentBlocks = blocks.length || 1;
+
+    if (wantsNewQuest) {
+        targetQuests = Math.max(targetQuests, currentBlocks + 1);
+    }
+
+    while (currentBlocks < targetQuests && await addQuestBtn.isVisible()) {
+        console.log(`       ➕ Agregando bloque de pregunta #${currentBlocks + 1}...`);
+        await addQuestBtn.click();
+        await page.waitForTimeout(1000);
+        blocks = await getBlocks();
+        currentBlocks = blocks.length || (currentBlocks + 1);
+    }
+
+    // Respuestas por cada bloque
+    const respMatch = instructions.match(/(\d+)\s+respuestas/i);
+    const targetResps = respMatch ? parseInt(respMatch[1]) : 0;
+
+    if (targetResps > 0) {
+        blocks = await getBlocks();
+        const addRespBtns = await modal.locator('button').filter({ hasText: /agregar respuesta|add answer/i }).all();
+
+        for (let i = 0; i < Math.max(blocks.length, addRespBtns.length); i++) {
+            const btn = addRespBtns[i];
+            const container = blocks[i];
+
+            if (btn && await btn.isVisible()) {
+                let currentResps = 1;
+                if (container) {
+                    currentResps = await container.locator('input[placeholder*="Respuesta" i], input[aria-label*="Respuesta" i]').count();
+                } else {
+                    // Fallback: si no detectamos el contenedor, contamos globales divididos por número de botones
+                    const totalRespsInModal = await modal.locator('input[placeholder*="Respuesta" i]').count();
+                    currentResps = Math.ceil(totalRespsInModal / addRespBtns.length);
+                }
+
+                if (currentResps === 0) currentResps = 1;
+                while (currentResps < targetResps) {
+                    console.log(`       [Bloque ${i + 1}] ➕ Añadiendo respuesta extra...`);
+                    await btn.click();
+                    await page.waitForTimeout(600);
+                    currentResps++;
+                }
+            }
+        }
+    }
+
+    // --- 2. LLENADO ---
+    await page.waitForTimeout(800);
+    const fields = await modal.locator('input:not([type="hidden"]), textarea, [data-slot="trigger"]').all();
+    console.log(`     🔎 Llenando ${fields.length} campos detectados...`);
+
+    let qCount = 1;
+    let rCount = 1;
+
+    for (let i = 0; i < fields.length; i++) {
+        // VERIFICACIÓN CRÍTICA: ¿Sigue el modal visible?
+        if (!(await modal.isVisible())) {
+            console.error('     ❌ [ERROR] El modal se cerró inesperadamente durante el llenado.');
+            return false;
+        }
+
+        const field = fields[i];
+        if (!(await field.isVisible())) continue;
+
+        const label = await getFieldLabel(field);
+        const placeholder = await field.getAttribute('placeholder') || '';
+        const ariaLabel = await field.getAttribute('aria-label') || '';
+        const text = (label + ' ' + placeholder + ' ' + ariaLabel).toLowerCase();
+
+        let val = '';
+        if (/tipo|type/i.test(text)) {
+            val = 'Otros';
+        } else if (/pregunta|question/i.test(text)) {
+            val = `Pregunta #${qCount++}`;
+            rCount = 1;
+        } else if (/respuesta|answer/i.test(text)) {
+            val = `Respuesta ${Math.max(1, qCount - 1)}.${rCount++}: Editada`;
+        } else if (label.includes('*')) {
+            val = 'Obligatorio';
+        }
+
+        if (val) {
+            console.log(`       🖋️ "${label || placeholder || 'Campo'}" -> "${val}"`);
+            const isSelect = (await field.getAttribute('data-slot')) === 'trigger' || (await field.getAttribute('aria-haspopup')) === 'listbox';
+            if (isSelect) {
+                await handleHeroUISelect(page, field, val);
+                await page.waitForTimeout(400);
+            } else {
+                await field.click({ force: true }).catch(() => { });
+                await page.keyboard.press('Control+A');
+                await page.keyboard.press('Backspace');
+                await field.fill(val);
+                await page.waitForTimeout(200);
+            }
+        }
+    }
+
+    // --- 3. GUARDADO ---
+    if (!(await modal.isVisible())) return false;
+
+    console.log('     💾 Finalizando modal...');
+    const saveBtn = modal.locator('button').filter({ hasText: /guardar|save|aceptar|ok|confirm/i }).last();
+    if (await saveBtn.isVisible()) {
+        if (await saveBtn.isDisabled()) {
+            console.warn('     ⚠️ Botón deshabilitado. Forzando validación...');
+            const lastField = modal.locator('input').last();
+            if (await lastField.isVisible()) {
+                await lastField.focus();
+                await page.keyboard.type(' ');
+                await page.keyboard.press('Backspace');
+                await page.waitForTimeout(600);
+            }
+        }
+        await saveBtn.click({ force: true });
+        console.log('     ✅ Guardar pulsado.');
+        await expect(modal).not.toBeVisible({ timeout: 10000 }).catch(() => page.keyboard.press('Escape'));
+        await page.waitForTimeout(1000);
+        return true;
+    }
+    return false;
+}