@globisnv/cypress-core 0.0.1

package/dist/websocketDetector.js

@@ -0,0 +1,1593 @@
+import { cypressWebsocketDebug, extraParams } from './tsHelper.js';
+/** Module-level flag controlling auto-dismissal of Info dialogs. Disabled by default; set via WS_toggleDialogHandler or env wsEnableDialogHandler=true. */
+let wsDialogHandlerEnabled = extraParams.wsEnableDialogHandler === 'true';
+// ─── Cypress action tracking for metric labels ────────────────────────────────
+const ACTION_COMMANDS = new Set([
+    'click',
+    'dblclick',
+    'rightclick',
+    'type',
+    'check',
+    'uncheck',
+    'select',
+    'clear',
+    'trigger',
+    'submit',
+    'realClick',
+    'realType',
+    'realPress',
+    'realHover'
+]);
+const LOCATOR_COMMANDS = new Set(['get', 'find', 'contains', 'within']);
+// Commands that are utility/infrastructure — not meaningful as metric labels
+const SKIP_CUSTOM_COMMANDS = new Set(['GLO_checkLoadingIndicator', 'GLO_log', 'GLO_getElement', 'WS_loadingCheck', 'WS_visitWithSpy', 'WS_toggleDialogHandler']);
+// Auto-register every custom command added via Cypress.Commands.add
+const customCommands = new Set();
+const _origCommandsAdd = Cypress.Commands.add.bind(Cypress.Commands);
+Cypress.Commands.add = (name, ...rest) => {
+    if (typeof name === 'string')
+        customCommands.add(name);
+    // biome-ignore lint/suspicious/noExplicitAny: rebinding Cypress.Commands.add's variadic signature isn't expressible without any
+    _origCommandsAdd(name, ...rest);
+};
+let lastCypressAction = '';
+let lastCypressLocator = '';
+let lastGLOCommand = '';
+let lastActionStartTime = null;
+let wsInteractionCounter = 0;
+Cypress.on('command:start', (cmd) => {
+    const rawName = cmd.get('name');
+    const name = typeof rawName === 'string' ? rawName : '';
+    const args = (cmd.get('args') ?? []);
+    if (LOCATOR_COMMANDS.has(name) && typeof args[0] === 'string')
+        lastCypressLocator = args[0];
+    if (ACTION_COMMANDS.has(name)) {
+        lastCypressAction = name;
+        lastActionStartTime = Date.now();
+    }
+    if (customCommands.has(name) && !SKIP_CUSTOM_COMMANDS.has(name)) {
+        const label = args.filter((a) => typeof a === 'string').join(':');
+        lastGLOCommand = label ? `${name}:${label}` : name;
+    }
+});
+beforeEach(() => {
+    wsDialogHandlerEnabled = extraParams.wsEnableDialogHandler === 'true';
+    lastCypressAction = '';
+    lastCypressLocator = '';
+    lastGLOCommand = '';
+    lastActionStartTime = null;
+    wsInteractionCounter = 0;
+});
+after(() => {
+    cy.task('flushWsMetrics', null, { log: false }).then((result) => {
+        const r = result;
+        let msg;
+        if (r.error)
+            msg = `❌ metrics flush failed: ${r.error}`;
+        else if (r.skipped)
+            msg = `⏭️ metrics flush skipped: ${r.skipped}`;
+        else
+            msg = `✅ pushed ${r.flushed} metrics to Prometheus`;
+        Cypress.log({ name: 'WSMetrics', displayName: '📊 WSMetrics', message: msg });
+    });
+});
+Cypress.Commands.add('WS_visitWithSpy', (url) => {
+    const enableSpy = () => ({
+        onBeforeLoad(win) {
+            attachWebSocketSpy(win);
+        }
+    });
+    cy.visit(url, enableSpy());
+    cy.window().then((win) => {
+        cy.wrap(win.wsMessages).as('wsMessages');
+    });
+    // Wait for WS to connect before checking load state
+    cy.window({ timeout: 60000 }).should((win) => {
+        assert.isTrue(win.wsMessages?.wsConnected === true);
+    });
+    cy.WS_loadingCheck();
+});
+/**
+ * Patches window.WebSocket to mirror every outgoing and incoming frame into `win.wsMessages`.
+ * Must be called from onBeforeLoad so it runs before the application code connects.
+ *
+ * @param window - The AUT window object.
+ */
+export function attachWebSocketSpy(window) {
+    const messageStore = { messages: [] };
+    const OriginalWebSocket = window.WebSocket;
+    // biome-ignore lint/complexity/useArrowFunction: must be constructible — the AUT calls `new WebSocket(...)`
+    window.WebSocket = function (url, protocols) {
+        const socketInstance = protocols ? new OriginalWebSocket(url, protocols) : new OriginalWebSocket(url);
+        const originalSendMethod = socketInstance.send.bind(socketInstance);
+        // Override send to capture outgoing frames (skip ping 'p' frames)
+        socketInstance.send = function (data) {
+            if (data !== 'p')
+                messageStore.messages.push({ direction: 'outgoing', data, timestamp: Date.now() });
+            originalSendMethod.call(this, data);
+        };
+        socketInstance.addEventListener('open', () => {
+            messageStore.wsConnected = true;
+        });
+        // Capture incoming frames (skip pong 'P' frames)
+        socketInstance.addEventListener('message', (event) => {
+            if (event.data !== 'P')
+                messageStore.messages.push({ direction: 'incoming', data: event.data, timestamp: Date.now() });
+        });
+        return socketInstance;
+    };
+    window.wsMessages = messageStore;
+    window.wsMetrics = [];
+}
+Cypress.Commands.add('WS_toggleDialogHandler', (mode) => {
+    wsDialogHandlerEnabled = mode === 'enable';
+    Cypress.log({
+        name: 'WSDialogHandler',
+        displayName: '🔧 WSDialogHandler',
+        message: `Auto info dialog handling: ${mode === 'enable' ? 'enabled' : 'disabled'}`,
+        consoleProps: () => ({ mode, disabled: mode === 'disable' })
+    });
+});
+Cypress.Commands.add('WS_loadingCheck', (options) => {
+    const config = {
+        timeout: 120000,
+        debugMode: cypressWebsocketDebug,
+        ...options
+    };
+    const DEBUG_MODE = config.debugMode;
+    // ─── Timing constants ────────────────────────────────────────────────────
+    /** Normal quiet period: all signals must stay idle for this long before resolving. */
+    const QUIET_PERIOD_DEFAULT_MS = 200;
+    /** Extended quiet period used after closeNode or dialog interactions that cause follow-up traffic. */
+    const QUIET_PERIOD_EXTENDED_MS = 500;
+    /** Extra quiet period when inside a popup form that was opened before this loader started. */
+    const POPUP_QUIET_PERIOD_MS = 2000;
+    /** How long to wait after a window destroy event before continuing (server follow-up traffic). */
+    const WINDOW_DESTROY_WAIT_MS = 500;
+    // ─── Dialog constants ─────────────────────────────────────────────────────
+    /** Max retries for auto-handling a locked-record dialog before giving up. */
+    const LOCKED_RECORD_MAX_RETRIES = 3;
+    /** How long to wait before clicking OK on a locked-record dialog (server releases the lock). */
+    const LOCKED_RECORD_WAIT_MS = 60000;
+    /** How long after a dialog opens to still attribute a formLoaded event to a cellClick. */
+    const CELL_CLICK_DIALOG_TIMEOUT_MS = 5000;
+    // ─── SvyPush resolution timeouts ─────────────────────────────────────────
+    /** Timeout for simple boolean toggles (0/1) — these don't need a server round-trip. */
+    const SVY_PUSH_SIMPLE_TOGGLE_TIMEOUT_MS = 100;
+    /** Fallback timeout for svyPush changes that never get a server echo. */
+    const SVY_PUSH_DEFAULT_TIMEOUT_MS = 12000;
+    /** Short delay after hideLoading to auto-resolve associated svyPush entries. */
+    const SVY_PUSH_LOADING_RESOLVE_DELAY_MS = 50;
+    /** How long to wait after hideLoading for a `_dlg` form to send formUnloaded before timing out. */
+    const DLG_SVYPUSH_CLOSE_WAIT_MS = 1000;
+    // ─── Form load timeout ────────────────────────────────────────────────────
+    /** Max time to wait for a popup form's formLoaded event before giving up. */
+    const FORM_LOAD_TIMEOUT_MS = 15000;
+    /** Unix timestamp when this loader invocation started — used to filter stale popup messages. */
+    const wsLoaderStartTime = Date.now();
+    // ─── Test context labels ─────────────────────────────────────────────────
+    const testTitle = Cypress.currentTest?.titlePath?.join(' > ') ?? '';
+    const specFile = Cypress.spec?.relative ?? '';
+    // ─── Interaction timing ──────────────────────────────────────────────────
+    /** Timestamp of the action command (click/type/…) that triggered this loader. Null when called without a prior action (e.g. WS_visitWithSpy). */
+    const actionStartTime = lastActionStartTime;
+    lastActionStartTime = null;
+    const interactionId = String(++wsInteractionCounter);
+    /** Timestamp when the DOM loading indicator first appeared in this invocation. */
+    let capturedFirstLoadingStartTime = null;
+    /** Timestamp when the DOM loading indicator last disappeared. */
+    let capturedLastLoadingEndTime = null;
+    /** Accumulated ms the DOM loading indicator was visible (supports multiple show/hide cycles). */
+    let capturedTotalLoadingMs = 0;
+    /**
+     * Servoy dialog service methods that indicate the server wants to open a message dialog.
+     * Note: 'showInputDialog' is handled by the test but listed here for completeness.
+     */
+    const DIALOG_METHODS = ['showQuestionDialog', 'showInfoDialog', 'showWarningDialog', 'showErrorDialog', 'showSelectDialog', 'showInputDialog'];
+    /**
+     * The formService methodnames we track as pending requests.
+     * Other methodnames (formLoaded, formUnloaded, etc.) are informational and do not block resolution.
+     */
+    const TRACKED_METHODS = ['executeEvent', 'dataPush', 'svyPush', 'callServerSideApi', 'executeInlineScript', 'formvisibility'];
+    // ─── Per-invocation mutable state ────────────────────────────────────────
+    /** True once a locked-record dialog has been detected in this test (prevents double-detection). */
+    let lockedRecordDialogDetected = false;
+    /** True once a DOM loading indicator has appeared — extends the effective timeout to the full config value. */
+    let domLoadingIndicatorEverDetected = false;
+    /** True once the 60s wait has elapsed and the dialog click has been scheduled. */
+    let lockedRecordDialogHandled = false;
+    /** Monotonically increasing counter for unique dialog keys. */
+    let dialogIdCounter = 0;
+    /**
+     * True once this action's own outgoing dataPush shows a "search" (magnifier) icon click
+     * (`handlerExec.eventType` containing "Search"). These open a $windowService popup after a
+     * server round-trip with no intermediate WS traffic — treated like being inside a popup so
+     * the longer POPUP_QUIET_PERIOD_MS applies instead of racing the default quiet period.
+     */
+    let expectSearchPopup = false;
+    // ─── Typed helper functions ───────────────────────────────────────────────
+    const isFormService = (data) => 'service' in data && 'methodname' in data && data.service === 'formService';
+    const hasNonEmptyArray = (arr) => Array.isArray(arr) && arr.length > 0;
+    /** Returns all pending requests that are not currently held (waiting for dialog dismissal). */
+    const getUnheldRequests = () => [...state.pendingRequests.keys()].filter((id) => !state.heldRequests.has(id));
+    // ─── State machine ────────────────────────────────────────────────────────
+    const state = {
+        pendingRequests: new Map(),
+        loadingIndicator: false,
+        heldRequests: new Set(),
+        pendingDataSync: new Map(),
+        lastProcessedIndex: 0,
+        lastOutgoingRequestId: null,
+        pendingSvyPushMap: new Map(),
+        windowDestroyDetected: false,
+        windowDestroyTimestamp: null,
+        extendedQuietPeriod: false,
+        pendingCellClickRequests: new Map(),
+        lastDialogCreatedTimestamp: null,
+        lastWsActivityTs: Date.now(),
+        pendingDialogFormRequests: new Set(),
+        popupOpenedByThisAction: false,
+        pendingFormLoads: new Set(),
+        expectFormShowCount: 0,
+        expectingFormLoaded: false,
+        navigatingAway: false,
+        domLoadingIndicatorStart: null
+    };
+    /** Open dialogs keyed by `${type}:${counter}`. Window dialogs use `Window:` prefix; message dialogs use `Info:` or `Question:`. */
+    const pendingDialogs = new Map();
+    /** Active setTimeout handles — cleared on resolution to prevent stale callbacks. */
+    const pendingTimeouts = new Set();
+    /** Maps `_dlg` form name → timeout id. Blocks resolution until formUnloaded arrives or the timeout fires. */
+    const pendingDlgFormSvyPush = new Map();
+    /** Reference to the AUT window, refreshed on each poll tick for use in synchronous callbacks. */
+    let currentWin = null;
+    /** Context from the most recent tracked outgoing formService message — used as metric labels. */
+    let lastRequestContext = { formname: '', beanname: '', methodname: '', dataproviderid: '', eventname: '' };
+    /** Per-request context for individual round-trip timing metrics. */
+    const requestContextMap = new Map();
+    /** Live Cypress log entry for the DOM loading-indicator wait, updated in-place each tick. */
+    let domLoadingIndicatorLog = null;
+    // Initialise the per-test locked-record retry counter
+    cy.window({ log: false }).then((win) => {
+        win.lockedRecordRetries ??= 0;
+    });
+    const log = Cypress.log({
+        name: 'WSLoader',
+        displayName: '🟠 WSLoader',
+        message: 'Initializing...',
+        consoleProps: () => ({ state: getStateSnapshot(state), timeout: config.timeout, enableAutoInfoDialog: config.enableAutoInfoDialog })
+    });
+    /** Logs to the Cypress command log only when DEBUG_MODE is enabled. */
+    const debugLog = (message, data) => {
+        if (!DEBUG_MODE)
+            return;
+        Cypress.log({ name: 'WSLoader-Debug', message, consoleProps: () => data || {} });
+    };
+    /** Safely serialises any value to string, handling circular refs and non-serialisable objects. */
+    const safeStringify = (data) => {
+        if (typeof data === 'string')
+            return data;
+        if (data === null || data === undefined)
+            return '';
+        try {
+            return JSON.stringify(data);
+        }
+        catch {
+            return '<unparseable>';
+        }
+    };
+    /** Extracts human-readable debug fields (service, method, form, bean) from a parsed message. */
+    const extractDebugInfo = (data) => {
+        const debugInfo = {};
+        if ('service' in data)
+            debugInfo.service = data.service;
+        if ('methodname' in data)
+            debugInfo.methodname = data.methodname;
+        if ('args' in data && data.args) {
+            if (data.args.formname)
+                debugInfo.formname = data.args.formname;
+            if (data.args.event)
+                debugInfo.event = data.args.event;
+            if (data.args.beanname)
+                debugInfo.beanname = data.args.beanname;
+            if (data.args.methodName)
+                debugInfo.methodName = data.args.methodName;
+        }
+        return debugInfo;
+    };
+    /**
+     * Emits an interaction-scoped metric with context labels automatically attached.
+     * Extend future per-request timing by passing extra labels, e.g. { request_id, request_type }.
+     */
+    function pushInteractionMetric(win, name, value, extraLabels = {}) {
+        if (!win.wsMetrics)
+            return;
+        win.wsMetrics.push({
+            name,
+            value,
+            labels: {
+                hostname: win.location.hostname,
+                cypress_action: lastGLOCommand || (lastCypressAction ? `${lastCypressAction}:${lastCypressLocator}` : ''),
+                action_type: lastCypressAction,
+                ...lastRequestContext,
+                interaction_id: interactionId,
+                test_title: testTitle,
+                spec_file: specFile,
+                ...extraLabels
+            },
+            timestamp: Date.now()
+        });
+    }
+    /** Builds the standard debug payload logged alongside dialog events. */
+    const createDialogDebugInfo = (api) => {
+        return {
+            args: api.args ?? [],
+            heldRequests: Array.from(state.heldRequests),
+            lastOutgoingRequestId: state.lastOutgoingRequestId
+        };
+    };
+    debugLog('🔵 WebSocket loader initialized', { timeout: config.timeout, enableAutoInfoDialogOption: config.enableAutoInfoDialog });
+    return waitForResolution();
+    // ═══════════════════════════════════════════════════════════════════════════
+    // Resolution logic
+    // ═══════════════════════════════════════════════════════════════════════════
+    /**
+     * Returns true when the WebSocket state machine considers the application idle.
+     * All conditions must pass simultaneously; if any returns false the loop keeps polling.
+     */
+    function isStateResolved() {
+        // Cross-origin navigation detected — nothing more to wait for
+        if (state.navigatingAway)
+            return true;
+        const unheldRequests = getUnheldRequests();
+        // After a window/popup is destroyed, wait a short period for follow-up server traffic
+        if (state.windowDestroyDetected && state.windowDestroyTimestamp && Date.now() - state.windowDestroyTimestamp < WINDOW_DESTROY_WAIT_MS)
+            return false;
+        // A popup form opened by this action must fire formLoaded before we resolve
+        if (state.pendingFormLoads.size > 0)
+            return false;
+        // $sabloService told us a form will be shown — wait for the controller update
+        if (state.expectFormShowCount > 0)
+            return false;
+        // After expectFormShowCount reaches 0, wait for the formLoaded confirmation
+        if (state.expectingFormLoaded)
+            return false;
+        // A _dlg form sent a svyPush; wait for its formUnloaded (or a short fallback timeout)
+        if (pendingDlgFormSvyPush.size > 0)
+            return false;
+        const autoInfoDisabled = !(config.enableAutoInfoDialog ?? wsDialogHandlerEnabled);
+        // Non-Question, non-Window dialogs (i.e. plain Info dialogs we auto-handle) block the loader.
+        // Skip blocking when auto-handling is disabled — the test will handle the dialog.
+        if (!autoInfoDisabled && hasAutoHandledPendingDialog())
+            return false;
+        // Question/Window/Info dialogs may orphan pending requests — unblock so the test can dismiss them.
+        if (shouldUnblockForQuestionDialog(unheldRequests))
+            return true;
+        if (shouldUnblockForWindowDialog(unheldRequests))
+            return true;
+        if (autoInfoDisabled && shouldUnblockForDisabledInfoDialog(unheldRequests))
+            return true;
+        // All three signals must be idle: no unheld requests, no loading indicator, no pending data sync
+        return unheldRequests.length === 0 && !state.loadingIndicator && state.pendingDataSync.size === 0;
+    }
+    function hasAutoHandledPendingDialog() {
+        return [...pendingDialogs.keys()].some((k) => !k.startsWith('Window:') && !k.startsWith('Question:'));
+    }
+    function shouldUnblockForQuestionDialog(unheldRequests) {
+        const openDialogs = [...pendingDialogs.entries()].filter(([k]) => k.startsWith('Question:'));
+        if (openDialogs.length === 0)
+            return false;
+        if (unheldRequests.length === 0)
+            return true;
+        const questionDialogTs = Math.min(...openDialogs.map(([, v]) => v.timestamp));
+        if (state.loadingIndicator || state.pendingDataSync.size > 0)
+            return false;
+        const allPredate = unheldRequests.every((id) => {
+            const ts = state.pendingRequests.get(id);
+            return ts !== undefined && ts < questionDialogTs;
+        });
+        if (allPredate)
+            debugLog('🔓 Orphaned pre-question-dialog requests detected — unblocking', { orphaned: unheldRequests });
+        return allPredate;
+    }
+    function shouldUnblockForWindowDialog(unheldRequests) {
+        if (!state.lastDialogCreatedTimestamp)
+            return false;
+        if (![...pendingDialogs.keys()].some((k) => k.startsWith('Window:')))
+            return false;
+        if (state.loadingIndicator || state.pendingDataSync.size > 0)
+            return false;
+        const allPredate = unheldRequests.length === 0 ||
+            unheldRequests.every((id) => {
+                const ts = state.pendingRequests.get(id);
+                return ts !== undefined && ts < state.lastDialogCreatedTimestamp;
+            });
+        if (allPredate)
+            debugLog('🔓 Orphaned pre-window requests detected — unblocking', { orphaned: unheldRequests });
+        return allPredate;
+    }
+    function shouldUnblockForDisabledInfoDialog(unheldRequests) {
+        if (state.pendingDataSync.size > 0)
+            return false;
+        const openInfoDialogs = [...pendingDialogs.entries()].filter(([k]) => k.startsWith('Info:'));
+        if (openInfoDialogs.length === 0)
+            return false;
+        const infoDialogTs = Math.min(...openInfoDialogs.map(([, v]) => v.timestamp));
+        const canUnblock = unheldRequests.length === 0 ||
+            unheldRequests.every((id) => {
+                const ts = state.pendingRequests.get(id);
+                return ts !== undefined && ts < infoDialogTs;
+            });
+        if (canUnblock)
+            debugLog('🔓 Info dialog (auto-disabled) — unblocking for test to handle', { dialogs: openInfoDialogs.map(([k]) => k) });
+        return canUnblock;
+    }
+    /**
+     * Checks for visible dialogs in the DOM and handles them if appropriate.
+     * Returns a string tag: 'null' (no action), 'info', 'noPrice', or 'locked'.
+     */
+    function checkForDialogs() {
+        return cy.document({ log: false }).then((doc) => {
+            const dialog = findDialog(doc);
+            if (!dialog.exists)
+                return cy.wrap('null', { log: false });
+            return cy.window({ log: false }).then((win) => {
+                if (dialog.isLocked && !lockedRecordDialogDetected) {
+                    lockedRecordDialogDetected = true;
+                    return handleLockedRecordDialog(win, dialog.lockedYesLabel);
+                }
+                if (dialog.isInfo || dialog.isNoPrice)
+                    return handleInfoDialog(dialog.isInfo);
+                return cy.wrap('null', { log: false });
+            });
+        });
+    }
+    /** Inspects the DOM for a `.svy-message-dialog` and classifies it by title/body text. */
+    function findDialog(doc) {
+        const $dialog = Cypress.$(doc.body).find('.svy-message-dialog');
+        if ($dialog.length === 0)
+            return { exists: false, isLocked: false, isInfo: false, isNoPrice: false, lockedYesLabel: 'Yes' };
+        const title = $dialog.find('.window-title').text();
+        const body = $dialog.find('.window-body').text();
+        const isLocked = title.includes('Locked record');
+        const lockedYesLabel = isLocked ? $dialog.find('.svy-btn-primary').first().text().trim() || 'Yes' : 'Yes';
+        return {
+            exists: true,
+            isLocked,
+            isInfo: title.includes('Info'),
+            // "No price found" warnings appear in sales flows and are safe to auto-dismiss
+            isNoPrice: title.includes('Warning') && body.includes('No price found'),
+            lockedYesLabel
+        };
+    }
+    /** Auto-clicks OK on an Info or "No price found" dialog, unless auto-handling is disabled. */
+    function handleInfoDialog(isInfo) {
+        // DisableAutoInfoDialog only applies to plain Info dialogs — No price found is always handled
+        const shouldDisableAutoInfo = isInfo && !(config.enableAutoInfoDialog ?? wsDialogHandlerEnabled);
+        if (shouldDisableAutoInfo) {
+            debugLog('ℹ️ Info dialog detected, but auto-handling is disabled');
+            return cy.wrap('null', { log: false });
+        }
+        debugLog('ℹ️ Info/No price dialog detected, Self-handling');
+        cy.get('.svy-message-dialog button').contains('OK').click();
+        return cy.wrap(isInfo ? 'info' : 'noPrice', { log: false });
+    }
+    /**
+     * Waits 60 seconds for the server to release a record lock, then clicks Yes.
+     * Retries up to LOCKED_RECORD_MAX_RETRIES times per test before giving up.
+     */
+    function handleLockedRecordDialog(win, yesLabel = 'Yes') {
+        const retries = win.lockedRecordRetries ?? 0;
+        if (retries >= LOCKED_RECORD_MAX_RETRIES) {
+            debugLog('🔒 Locked record dialog detected but max retries (3) reached - skipping');
+            return cy.wrap('locked', { log: false });
+        }
+        win.lockedRecordRetries = retries + 1;
+        debugLog(`🔍 Locked record dialog detected (attempt ${win.lockedRecordRetries}/3), waiting 60s before handling`);
+        // biome-ignore plugin: <internal> Cypress wait for locked record dialog handling
+        cy.wait(LOCKED_RECORD_WAIT_MS).then(() => {
+            if (!lockedRecordDialogHandled) {
+                lockedRecordDialogHandled = true;
+                debugLog(`🔓 60s wait complete — executing GLO_dialogRequiredCheck (attempt ${win.lockedRecordRetries}/3)`);
+                cy.GLO_dialogRequiredCheck(yesLabel, 'Locked record');
+            }
+        });
+        return cy.wrap('locked', { log: false });
+    }
+    // ═══════════════════════════════════════════════════════════════════════════
+    // Main polling loop
+    // ═══════════════════════════════════════════════════════════════════════════
+    /** Entry point for the resolution loop. Polls every 100 ms until resolved or timed out. */
+    function waitForResolution() {
+        const startTime = Date.now();
+        return checkAndWait();
+        function checkAndWait() {
+            return cy
+                .window({ log: false })
+                .then((win) => {
+                let hasWsMessages;
+                try {
+                    hasWsMessages = !!win.wsMessages;
+                }
+                catch {
+                    hasWsMessages = false;
+                }
+                // If wsMessages is gone the page navigated away — nothing more to wait for
+                if (!hasWsMessages)
+                    return cy.wrap('navigated', { log: false });
+                return checkForDialogs();
+            })
+                .then((dialogType) => {
+                if (dialogType === 'navigated') {
+                    debugLog('🟢 Page navigated away — resolving loader');
+                    log.set({ displayName: '🟢 WSLoader', message: 'Resolved' }).end();
+                    return cy.wrap(undefined, { log: false });
+                }
+                if (dialogType === 'locked') {
+                    debugLog('🔓 Resolving loader due to locked record detection');
+                    log.set({ displayName: '🟡 WSLoader', message: 'Resolved (Locked Record)' }).end();
+                    return clearWebSocketMessages();
+                }
+                return performResolutionCheck();
+            });
+        }
+        function performResolutionCheck() {
+            return checkResolution().then((isResolved) => {
+                if (isResolved)
+                    return handleResolvedState();
+                const effectiveTimeout = !options?.timeout && domLoadingIndicatorEverDetected ? 1200000 : config.timeout;
+                if (Date.now() - startTime > effectiveTimeout)
+                    return handleTimeout(effectiveTimeout);
+                // biome-ignore plugin: internal polling interval for checkAndWait retry loop
+                return cy.wait(100, { log: false }).then(() => checkAndWait());
+            });
+        }
+        /**
+         * Called once isStateResolved() returns true.
+         * Enforces the quiet period — the state must stay resolved for QUIET_PERIOD_MS before
+         * we actually commit to being done.
+         */
+        function handleResolvedState() {
+            if (state.navigatingAway) {
+                log.set({ displayName: '🟢 WSLoader', message: 'Resolved (navigation)' }).end();
+                return clearWebSocketMessages();
+            }
+            // Inside a popup that was opened before this loader started, use the longer quiet
+            // period to bridge the gap between the loading indicator hiding and executeEvent firing
+            const isInsideExternalPopup = !state.popupOpenedByThisAction && currentWin?.wsPopupFormOpen === true;
+            let quietPeriodMs;
+            if (isInsideExternalPopup || expectSearchPopup) {
+                quietPeriodMs = POPUP_QUIET_PERIOD_MS;
+            }
+            else if (state.extendedQuietPeriod) {
+                quietPeriodMs = QUIET_PERIOD_EXTENDED_MS;
+            }
+            else {
+                quietPeriodMs = config.quietPeriodMs ?? QUIET_PERIOD_DEFAULT_MS;
+            }
+            // Only resolve if quiet period has fully elapsed since the last WS activity
+            const now = Date.now();
+            const quietTimeSoFar = now - state.lastWsActivityTs;
+            const remaining = quietPeriodMs - quietTimeSoFar;
+            if (remaining > 0) {
+                return cy.wait(remaining, { log: false }).then(() => checkAndWait());
+            }
+            state.extendedQuietPeriod = false;
+            log.set({ displayName: '🟢 WSLoader', message: 'Resolved' }).end();
+            return clearWebSocketMessages();
+        }
+        /**
+         * Checks whether the DOM loading indicator is gone first, then checks WS state.
+         * The DOM indicator guards against Angular render lag that can appear after WS goes idle.
+         */
+        function checkResolution() {
+            return checkDomLoadingIndicator().then((domReady) => {
+                if (!domReady)
+                    return cy.wrap(false, { log: false });
+                return checkWsResolution();
+            });
+        }
+        /** Processes new WS frames and evaluates isStateResolved() in a single cy.window() call. */
+        function checkWsResolution() {
+            return cy.window({ log: false }).then((win) => {
+                currentWin = win;
+                let wsMessages;
+                try {
+                    wsMessages = win.wsMessages;
+                }
+                catch {
+                    wsMessages = undefined;
+                }
+                if (!wsMessages) {
+                    debugLog('🟢 No wsMessages found, resolving');
+                    return cy.wrap(true, { log: false });
+                }
+                processMessages(wsMessages);
+                const isResolved = isStateResolved();
+                let wsPopupFormOpen;
+                try {
+                    wsPopupFormOpen = win.wsPopupFormOpen ?? false;
+                }
+                catch {
+                    wsPopupFormOpen = false;
+                }
+                if (!isResolved && !state.popupOpenedByThisAction && wsPopupFormOpen) {
+                    debugLog('🪟 Inside popup from previous action — using extended quiet period');
+                }
+                updateLog(isResolved, startTime);
+                return cy.wrap(isResolved, { log: false });
+            });
+        }
+    }
+    // ═══════════════════════════════════════════════════════════════════════════
+    // DOM loading indicator check
+    // ═══════════════════════════════════════════════════════════════════════════
+    /**
+     * Returns false (not ready) while a `<loading-indicator>` element is present in the DOM.
+     * Updates a live Cypress log entry showing how long we have been waiting.
+     */
+    function checkDomLoadingIndicator() {
+        return cy.document({ log: false }).then((doc) => {
+            const hasLoadingIndicator = Cypress.$(doc.body).find('loading-indicator').length > 0;
+            if (hasLoadingIndicator) {
+                if (state.domLoadingIndicatorStart === null) {
+                    state.domLoadingIndicatorStart = Date.now();
+                    capturedFirstLoadingStartTime ??= state.domLoadingIndicatorStart;
+                    domLoadingIndicatorEverDetected = true;
+                    domLoadingIndicatorLog = Cypress.log({ name: 'WSLoader-DOM', message: '⏳ loading-indicator in DOM — waiting (0.0s)' });
+                }
+                else if (domLoadingIndicatorLog) {
+                    const elapsed = ((Date.now() - state.domLoadingIndicatorStart) / 1000).toFixed(1);
+                    domLoadingIndicatorLog.set('message', `⏳ loading-indicator in DOM — waiting (${elapsed}s)`);
+                }
+            }
+            else if (state.domLoadingIndicatorStart !== null) {
+                const loadingEndTime = Date.now();
+                const durationMs = loadingEndTime - state.domLoadingIndicatorStart;
+                const duration = (durationMs / 1000).toFixed(1);
+                if (domLoadingIndicatorLog) {
+                    domLoadingIndicatorLog.set('message', `✅ loading-indicator removed after ${duration}s`);
+                }
+                capturedTotalLoadingMs += durationMs;
+                capturedLastLoadingEndTime = loadingEndTime;
+                state.domLoadingIndicatorStart = null;
+                domLoadingIndicatorLog = null;
+            }
+            return cy.wrap(!hasLoadingIndicator, { log: false });
+        });
+    }
+    // ═══════════════════════════════════════════════════════════════════════════
+    // Message processing
+    // ═══════════════════════════════════════════════════════════════════════════
+    /** Logs all pending state and throws a descriptive error after the timeout is exceeded. */
+    function handleTimeout(timeout) {
+        const unheldRequests = getUnheldRequests();
+        console.group('🚨 WebSocket Timeout Debug Information');
+        console.error(`WebSocket timeout after ${timeout}ms`);
+        console.log('Pending Requests:', unheldRequests);
+        return logAllWebSocketMessages('Timeout').then(() => {
+            throw new Error(`WebSocket timeout after ${timeout}ms. Pending: ${unheldRequests.join(', ')}`);
+        });
+    }
+    /**
+     * Reads all new frames from the message store (since `state.lastProcessedIndex`),
+     * sorts them by timestamp, and routes each to the appropriate outgoing/incoming handler.
+     */
+    function processMessages(store) {
+        const newMessages = store.messages.slice(state.lastProcessedIndex).sort((a, b) => a.timestamp - b.timestamp);
+        state.lastProcessedIndex = store.messages.length;
+        for (const message of newMessages) {
+            if (isPingPongFrame(message))
+                continue;
+            markWsActivity();
+            try {
+                const parsed = parseMessage(message);
+                if (!parsed)
+                    continue;
+                if (message.direction === 'outgoing')
+                    handleOutgoingMessage(parsed, message.timestamp);
+                else
+                    handleIncomingMessage(parsed, message.timestamp);
+            }
+            catch (e) {
+                const messageData = safeStringify(message.data).substring(0, 100);
+                debugLog('⚠️ Failed to parse message', { error: e instanceof Error ? e.message : String(e), messageData });
+            }
+        }
+    }
+    /**
+     * Processes an outgoing (client → server) frame.
+     * Tracks the request id, svyPush changes, cellClicks, dialog interactions, and form lifecycle.
+     */
+    function handleOutgoingMessage(data, timestamp) {
+        const requestId = extractRequestId(data);
+        checkForCloseNode(data);
+        checkForDialogInteraction(data);
+        checkForSearchIconClick(data);
+        trackCellClickRequests(data, requestId, timestamp);
+        if (requestId && isTrackedRequest(data))
+            trackPendingRequest(data, requestId, timestamp);
+        handleFormServiceOutgoing(data);
+    }
+    /**
+     * Detects a list-form-component "search" (magnifier) icon click via the `onSearchActionMethodID`
+     * handlerExec event embedded in the field's own outgoing dataPush, e.g.:
+     * `{"changes":{"containedForm":[[],[{"handlerExec":{"eventType":"onSearchActionMethodID",...}}]]}}`.
+     */
+    function checkForSearchIconClick(data) {
+        if (!isFormService(data) || data.methodname !== 'dataPush')
+            return;
+        const containedForm = data.args?.changes?.containedForm;
+        if (!Array.isArray(containedForm))
+            return;
+        const isSearchClick = containedForm.some((row) => Array.isArray(row) &&
+            row.some((cell) => {
+                const eventType = cell?.handlerExec?.eventType;
+                return typeof eventType === 'string' && eventType.toLowerCase().includes('search');
+            }));
+        if (isSearchClick) {
+            expectSearchPopup = true;
+            debugLog('🔍 Search icon click detected — using popup quiet period');
+        }
+    }
+    function trackPendingRequest(data, requestId, timestamp) {
+        handleExecuteEvent(data);
+        state.pendingRequests.set(requestId, timestamp);
+        state.lastOutgoingRequestId = requestId;
+        if (isFormService(data)) {
+            requestContextMap.set(requestId, {
+                methodname: data.methodname,
+                formname: data.args?.formname ?? '',
+                beanname: data.args?.beanname ?? '',
+                dataproviderid: data.methodname === 'svyPush' ? String(data.args?.changes?.dataProviderID ?? '') : '',
+                eventname: data.args?.event ?? ''
+            });
+        }
+        debugLog(`📤 Tracking: ${requestId}`, extractDebugInfo(data));
+        // ExecuteEvents from _dlg forms are resolved when the window closes, not by a response
+        if (isDialogFormEvent(data)) {
+            state.pendingDialogFormRequests.add(requestId);
+            debugLog(`🔲 Dialog form event tracked: ${requestId}`, extractDebugInfo(data));
+        }
+    }
+    function handleFormServiceOutgoing(data) {
+        if (!isFormService(data))
+            return;
+        if (data.methodname === 'svyPush')
+            trackDataChange(data);
+        if (data.args?.formname && data.args?.beanname) {
+            lastRequestContext = {
+                formname: data.args.formname,
+                beanname: data.args.beanname,
+                methodname: data.methodname,
+                dataproviderid: data.methodname === 'svyPush' ? String(data.args.changes?.dataProviderID ?? '') : '',
+                eventname: data.methodname === 'executeEvent' ? (data.args.event ?? '') : ''
+            };
+        }
+        if (data.methodname === 'formLoaded')
+            handleFormLoaded(data);
+        if (data.methodname === 'formUnloaded')
+            handleFormUnloaded(data);
+    }
+    /**
+     * Returns true for executeEvent calls on forms whose name contains `_dlg`.
+     * These dialog-form requests are resolved by window destruction, not by a normal server response.
+     */
+    function isDialogFormEvent(data) {
+        if (!isFormService(data) || data.methodname !== 'executeEvent')
+            return false;
+        const formname = data.args?.formname;
+        if (!formname || typeof formname !== 'string')
+            return false;
+        return formname.includes('_dlg');
+    }
+    /**
+     * Processes an incoming (server → client) frame.
+     * Routes it to the dialog or normal response handler, then applies service API side-effects.
+     */
+    function handleIncomingMessage(data, timestamp) {
+        // ColumnState-only dataPush messages are grid column layout updates — not data changes
+        if (isDataPushColumnStateOnly(data)) {
+            debugLog('🔁 Ignored columnState-only dataPush');
+            return;
+        }
+        const hasDialog = 'serviceApis' in data && Array.isArray(data.serviceApis) && checkForDialogInResponse(data.serviceApis);
+        if (hasDialog) {
+            // Response triggers a dialog — hold the triggering request until the dialog is dismissed
+            handleDialogResponse(data);
+        }
+        else {
+            handleNormalResponse(data);
+        }
+        if ('serviceApis' in data && Array.isArray(data.serviceApis)) {
+            updateLoadingState(data.serviceApis);
+            updateDialogState(data.serviceApis);
+            updateExpectFormShowState(data.serviceApis);
+        }
+        // Check if this response echoes back a pending svyPush data change
+        if ('msg' in data && data.msg.forms)
+            checkDataSyncReflection(data.msg.forms);
+        // Detect popup form opening via the window.popupform service message
+        if ('msg' in data)
+            checkForPopupFormOpening(data.msg, timestamp);
+    }
+    /**
+     * Detects when the server signals that a popup form is being opened by this action.
+     * Records the form name so we can wait for its formLoaded before resolving.
+     * Ignores stale popupform signals from before this loader invocation started.
+     */
+    function checkForPopupFormOpening(msg, timestamp) {
+        const popupFormValue = msg?.services?.window?.popupform?.v;
+        if (!popupFormValue?.form)
+            return;
+        if (timestamp < wsLoaderStartTime)
+            return;
+        const formname = popupFormValue.form;
+        state.popupOpenedByThisAction = true;
+        state.pendingFormLoads.add(formname);
+        if (currentWin)
+            currentWin.wsPopupFormOpen = true;
+        debugLog(`🪟 Popup form opening: ${formname} — awaiting formLoaded`, { form: formname });
+        // Fallback in case formLoaded never arrives (e.g. the popup was immediately closed)
+        const formTid = setTimeout(() => {
+            pendingTimeouts.delete(formTid);
+            if (state.pendingFormLoads.has(formname)) {
+                state.pendingFormLoads.delete(formname);
+                debugLog(`⏱️ Form load timeout: ${formname}`);
+            }
+        }, FORM_LOAD_TIMEOUT_MS);
+        pendingTimeouts.add(formTid);
+    }
+    /** Sets extendedQuietPeriod when a closeNode call is detected (tree collapse triggers follow-up traffic). */
+    function checkForCloseNode(data) {
+        if (!isFormService(data) || data.methodname !== 'callServerSideApi' || data.args?.methodName !== 'closeNode')
+            return;
+        state.extendedQuietPeriod = true;
+        debugLog('🚪 closeNode detected - extending quiet period to 500ms', extractDebugInfo(data));
+    }
+    /**
+     * Detects when the test (or auto-handler) dismisses a dialog via a smsgid+ret reply.
+     * Releases the held request so the loader keeps waiting for the server's actual response.
+     */
+    function checkForDialogInteraction(data) {
+        if (!('smsgid' in data && 'ret' in data && typeof data.ret === 'string'))
+            return;
+        state.extendedQuietPeriod = true;
+        // Release the oldest held non-Window pending dialog (FIFO order)
+        for (const [key, dialogData] of pendingDialogs) {
+            if (!key.startsWith('Window:')) {
+                pendingDialogs.delete(key);
+                if (dialogData.triggeringRequestId && state.heldRequests.has(dialogData.triggeringRequestId)) {
+                    state.heldRequests.delete(dialogData.triggeringRequestId);
+                    debugLog(`🔓 Released held request after dialog interaction: ${dialogData.triggeringRequestId}`);
+                }
+                break;
+            }
+        }
+        debugLog(`🗨️ Outgoing dialog interaction detected (smsgid: ${data.smsgid}, ret: "${data.ret.trim()}") — extending quiet period`);
+    }
+    /** Tracks cellClick requests separately so they can be resolved by a subsequent formLoaded event. */
+    function trackCellClickRequests(data, requestId, timestamp) {
+        if (!requestId || !isFormService(data) || data.methodname !== 'callServerSideApi' || data.args?.methodName !== 'cellClick')
+            return;
+        const argsArray = data.args.args;
+        if (!hasNonEmptyArray(argsArray))
+            return;
+        const firstArg = argsArray[0];
+        if (typeof firstArg === 'string' && (firstArg === 'click' || firstArg === 'doubleClick')) {
+            state.pendingCellClickRequests.set(requestId, {
+                timestamp,
+                clickType: firstArg,
+                formname: data.args.formname ?? '',
+                beanname: data.args.beanname ?? ''
+            });
+            debugLog(`🖱️ Tracking cellClick: ${requestId} (${firstArg})`, extractDebugInfo(data));
+        }
+    }
+    /**
+     * When an executeEvent arrives for a form/bean that has a pending svyPush, the user has
+     * confirmed the data change. The svyPush entry is resolved immediately instead of waiting
+     * for the server echo.
+     */
+    function handleExecuteEvent(data) {
+        if (!('methodname' in data) || data.methodname !== 'executeEvent')
+            return;
+        const formname = 'args' in data ? data.args?.formname : undefined;
+        const beanname = 'args' in data ? data.args?.beanname : undefined;
+        if (!formname || !beanname)
+            return;
+        const beanKey = `${formname}:${beanname}`;
+        if (!state.pendingSvyPushMap.has(beanKey))
+            return;
+        const { originalChangeKey } = state.pendingSvyPushMap.get(beanKey);
+        if (state.pendingDataSync.has(originalChangeKey)) {
+            const svyData = state.pendingDataSync.get(originalChangeKey);
+            state.pendingDataSync.delete(originalChangeKey);
+            if (currentWin)
+                pushInteractionMetric(currentWin, 'cypress_ws_request_timing_ms', Date.now() - svyData.timestamp, {
+                    methodname: 'svyPush',
+                    formname: originalChangeKey.split(':')[0],
+                    beanname: svyData.beanname ?? '',
+                    phase: wsRequestPhase(svyData.timestamp),
+                    request_type: 'svyPush'
+                });
+            debugLog(`🧹 svyPush resolved by executeEvent: ${originalChangeKey}`);
+        }
+        state.pendingSvyPushMap.delete(beanKey);
+    }
+    /**
+     * When a response arrives that also opens a dialog, the triggering request is held
+     * rather than resolved. The actual result will arrive after the dialog is dismissed.
+     */
+    function handleDialogResponse(data) {
+        let targetId = null;
+        // Prefer exact smsgid match; fall back to the most recent outgoing request
+        if ('smsgid' in data && typeof data.smsgid === 'number') {
+            const candidate = `cmsg:${data.smsgid}`;
+            if (state.pendingRequests.has(candidate))
+                targetId = candidate;
+        }
+        if (!targetId && state.lastOutgoingRequestId && state.pendingRequests.has(state.lastOutgoingRequestId)) {
+            targetId = state.lastOutgoingRequestId;
+        }
+        if (targetId) {
+            state.heldRequests.add(targetId);
+            debugLog(`🔲 Dialog detected - holding request: ${targetId}`);
+        }
+    }
+    function wsRequestPhase(sendTs) {
+        // No loading detected yet at response time → pre_loading
+        if (capturedFirstLoadingStartTime === null)
+            return 'pre_loading';
+        // Request was sent after loading fully ended → post_loading
+        if (capturedLastLoadingEndTime !== null && sendTs >= capturedLastLoadingEndTime)
+            return 'post_loading';
+        // Loading started at some point during the request's lifetime → loading
+        return 'loading';
+    }
+    /** Resolves (removes) a pending request when its matching server response arrives. */
+    function handleNormalResponse(data) {
+        const requestId = extractRequestId(data);
+        if (!requestId)
+            return;
+        const sendTs = state.pendingRequests.get(requestId);
+        const wasHeld = state.heldRequests.has(requestId);
+        state.pendingRequests.delete(requestId);
+        state.heldRequests.delete(requestId);
+        if (sendTs && currentWin) {
+            const ctx = requestContextMap.get(requestId);
+            requestContextMap.delete(requestId);
+            pushInteractionMetric(currentWin, 'cypress_ws_request_timing_ms', Date.now() - sendTs, {
+                ...(ctx ?? {}),
+                request_type: requestId.split(':')[0],
+                phase: wsRequestPhase(sendTs)
+            });
+        }
+        debugLog(wasHeld ? `📥 Resolved held request: ${requestId}` : `📥 Resolved: ${requestId}`);
+    }
+    /**
+     * Returns true for dataPush messages that only carry a `columnState` change.
+     * These are grid column layout updates triggered by user resizing/reordering — not data changes
+     * that need to be tracked.
+     */
+    function isDataPushColumnStateOnly(data) {
+        if (!isFormService(data) || data.methodname !== 'dataPush')
+            return false;
+        const args = data.args;
+        if (!args || typeof args !== 'object')
+            return false;
+        const changes = args.changes;
+        if (!changes || typeof changes !== 'object')
+            return false;
+        const changeKeys = Object.keys(changes);
+        return changeKeys.length === 1 && changeKeys[0] === 'columnState';
+    }
+    /**
+     * Returns true if this outgoing message should be tracked as a pending request.
+     * DOM event triggers (native browser events proxied through formService) are excluded
+     * because they do not expect a server response.
+     */
+    function isTrackedRequest(data) {
+        if (!isFormServiceRequest(data))
+            return false;
+        if ('methodname' in data && data.methodname === 'executeEvent' && isDOMEventTrigger(data))
+            return false;
+        return true;
+    }
+    /** Returns true if the message is a formService call for one of the tracked methodnames. */
+    function isFormServiceRequest(data) {
+        return isFormService(data) && TRACKED_METHODS.includes(data.methodname);
+    }
+    /**
+     * Returns true when an executeEvent's args contain a native browser event object.
+     * These are proxied DOM events (click, focus, etc.) — the server does not send a response.
+     * Identified by presence of `isTrusted`, `delegateTarget`, or `_defaultPrevented` on the first arg.
+     */
+    function isDOMEventTrigger(data) {
+        if (!('methodname' in data && 'args' in data) || data.methodname !== 'executeEvent')
+            return false;
+        const args = data.args?.args;
+        if (!hasNonEmptyArray(args))
+            return false;
+        const arg0 = args[0];
+        return arg0 && typeof arg0 === 'object' && ('isTrusted' in arg0 || 'delegateTarget' in arg0 || '_defaultPrevented' in arg0);
+    }
+    /**
+     * Tracks a svyPush data-change as a pending data-sync entry.
+     * Simple boolean toggles (0/1) resolve quickly; all other changes use the default timeout.
+     * A fallback timeout auto-resolves the entry if the server echo never arrives.
+     */
+    function trackDataChange(data) {
+        if (!isFormService(data) || data.methodname !== 'svyPush')
+            return;
+        const { formname, beanname, changes } = data.args;
+        if (!formname || !beanname || !changes?.dataProviderID)
+            return;
+        const changeKey = `${formname}:${beanname}:${String(changes.dataProviderID)}`;
+        const beanKey = `${formname}:${beanname}`;
+        // DataProviderID of 0 or 1 indicates a simple boolean toggle — resolves faster
+        const isSimpleToggle = changes.dataProviderID === 0 || changes.dataProviderID === 1;
+        state.pendingDataSync.set(changeKey, {
+            formBase: formname.split('_ng')[0],
+            value: changes.dataProviderID,
+            timestamp: Date.now(),
+            isSvyPush: true,
+            beanname
+        });
+        state.pendingSvyPushMap.set(beanKey, {
+            timestamp: Date.now(),
+            originalChangeKey: changeKey
+        });
+        debugLog(`📊 Tracking svyPush: ${changeKey}`, { isSimpleToggle, value: changes.dataProviderID });
+        const timeout = isSimpleToggle ? SVY_PUSH_SIMPLE_TOGGLE_TIMEOUT_MS : SVY_PUSH_DEFAULT_TIMEOUT_MS;
+        const svyTid = setTimeout(() => {
+            pendingTimeouts.delete(svyTid);
+            if (state.pendingDataSync.has(changeKey)) {
+                const svyData = state.pendingDataSync.get(changeKey);
+                state.pendingDataSync.delete(changeKey);
+                if (currentWin)
+                    pushInteractionMetric(currentWin, 'cypress_ws_request_timing_ms', timeout, {
+                        methodname: 'svyPush',
+                        formname: changeKey.split(':')[0],
+                        beanname: svyData.beanname ?? '',
+                        phase: wsRequestPhase(svyData.timestamp),
+                        request_type: 'svyPush'
+                    });
+                Cypress.log({ name: 'WSLoader', displayName: '⏱️ WSLoader', message: `svyPush fallback triggered after ${timeout}ms: ${changeKey}` });
+                debugLog(`⏱️ Auto-resolved svyPush after ${timeout}ms: ${changeKey}`);
+            }
+            if (state.pendingSvyPushMap.has(beanKey))
+                state.pendingSvyPushMap.delete(beanKey);
+        }, timeout);
+        pendingTimeouts.add(svyTid);
+    }
+    /**
+     * Updates `state.loadingIndicator` based on $sabloLoadingIndicator service calls.
+     * When the indicator hides, pending svyPush entries on normal forms are auto-resolved
+     * after a short delay. For `_dlg` forms, we first wait for formUnloaded confirmation.
+     */
+    function resolveSvyPushOnHideLoading() {
+        for (const [syncKey, trackedData] of state.pendingDataSync.entries()) {
+            if (!trackedData.isSvyPush)
+                continue;
+            const formname = syncKey.split(':')[0];
+            if (formname.includes('_dlg')) {
+                // _dlg forms: block resolution until formUnloaded arrives or the timeout fires.
+                // This ensures we don't resolve while the dialog close animation is still running.
+                const existingTid = pendingDlgFormSvyPush.get(formname);
+                if (existingTid !== undefined)
+                    clearTimeout(existingTid);
+                const closeTid = setTimeout(() => {
+                    pendingDlgFormSvyPush.delete(formname);
+                    debugLog(`⏱️ dlg form close wait expired: ${formname}`);
+                }, DLG_SVYPUSH_CLOSE_WAIT_MS);
+                pendingDlgFormSvyPush.set(formname, closeTid);
+                debugLog(`⏳ Waiting for formUnloaded or timeout: ${formname}`);
+            }
+            // Auto-resolve after a short delay — the loading indicator hiding is the echo
+            const loadTid = setTimeout(() => {
+                pendingTimeouts.delete(loadTid);
+                if (state.pendingDataSync.has(syncKey)) {
+                    const svyData = state.pendingDataSync.get(syncKey);
+                    state.pendingDataSync.delete(syncKey);
+                    if (currentWin)
+                        pushInteractionMetric(currentWin, 'cypress_ws_request_timing_ms', Date.now() - svyData.timestamp, {
+                            methodname: 'svyPush',
+                            formname: syncKey.split(':')[0],
+                            beanname: svyData.beanname ?? '',
+                            phase: wsRequestPhase(svyData.timestamp),
+                            request_type: 'svyPush'
+                        });
+                    debugLog(`🟡 svyPush auto-resolved: ${syncKey}`);
+                }
+            }, SVY_PUSH_LOADING_RESOLVE_DELAY_MS);
+            pendingTimeouts.add(loadTid);
+        }
+    }
+    function updateLoadingState(apis) {
+        const loadingApi = apis.find((api) => api.name === '$sabloLoadingIndicator');
+        if (!loadingApi)
+            return;
+        if (loadingApi.call === 'showLoading') {
+            state.loadingIndicator = true;
+            debugLog('🔄 Loading indicator requested');
+        }
+        else if (loadingApi.call === 'hideLoading') {
+            state.loadingIndicator = false;
+            debugLog('✓ Loading indicator resolved');
+            resolveSvyPushOnHideLoading();
+        }
+    }
+    /**
+     * Tracks $sabloService expectFormToShowOnClient signals.
+     * When count transitions from 1→0 alongside an updateController, we set expectingFormLoaded
+     * to wait for the actual formLoaded confirmation before resolving.
+     */
+    function updateExpectFormShowState(apis) {
+        const hasUpdateController = apis.some((api) => api.name === '$windowService' && api.call === 'updateController');
+        apis.forEach((api) => {
+            if (api.name !== '$sabloService' || api.call !== 'expectFormToShowOnClient')
+                return;
+            const expecting = Array.isArray(api.args) && api.args[0] === true;
+            if (expecting) {
+                state.expectFormShowCount++;
+                debugLog(`📋 expectFormToShowOnClient: true — count: ${state.expectFormShowCount}`);
+            }
+            else {
+                const newCount = Math.max(0, state.expectFormShowCount - 1);
+                if (newCount === 0 && state.expectFormShowCount > 0 && hasUpdateController)
+                    state.expectingFormLoaded = true;
+                state.expectFormShowCount = newCount;
+                debugLog(`📋 expectFormToShowOnClient: false — count: ${state.expectFormShowCount}, expectingFormLoaded: ${state.expectingFormLoaded}`);
+            }
+        });
+    }
+    /** Dispatches serviceApi calls to the appropriate dialog/window handler. */
+    function updateDialogState(apis) {
+        apis.forEach((api) => {
+            if (api.name === 'dialogs')
+                handleMessageDialog(api);
+            if (api.name === '$windowService')
+                handleWindowDialog(api);
+            if (api.name === 'window' && api.call === 'cancelFormPopupInternal')
+                handleWindowDestroy(api);
+            if (api.name === '$applicationService' && api.call === 'showUrl')
+                handleShowUrl(api);
+        });
+    }
+    /**
+     * Detects cross-origin navigation (e.g. Okta SSO redirect) so the loader resolves
+     * before the page switches. Relative URLs (e.g. file downloads) are intentionally ignored.
+     */
+    function handleShowUrl(api) {
+        const url = Array.isArray(api.args) ? api.args[0] : null;
+        const target = Array.isArray(api.args) ? api.args[1] : null;
+        if (target !== '_self' || typeof url !== 'string')
+            return;
+        if (!/^https?:\/\//.test(url))
+            return;
+        state.navigatingAway = true;
+        debugLog('🚀 showUrl(_self) — resolving loader before cross-origin navigation');
+    }
+    /**
+     * Registers a new pending dialog when the server opens a message dialog.
+     *
+     * Only Info dialogs with the literal title "Info" are auto-handled and block the loader.
+     * All others (Warning, Error, Input, Select, Info with a different title) use a "Question:"
+     * key which unblocks the loader so the test can interact with the dialog.
+     */
+    function handleMessageDialog(api) {
+        if (!api.call || !DIALOG_METHODS.includes(api.call))
+            return;
+        const dialogType = api.call.replace('show', '').replace('Dialog', '');
+        const wsTitle = Array.isArray(api.args) && typeof api.args[0] === 'string' ? api.args[0] : '';
+        // 'Info' key → loader blocks until auto-handled; 'Question' key → loader unblocks immediately
+        const keyType = dialogType === 'Info' && wsTitle === 'Info' ? 'Info' : 'Question';
+        const dialogKey = `${keyType}:${++dialogIdCounter}`;
+        pendingDialogs.set(dialogKey, { dialogType, triggeringRequestId: state.lastOutgoingRequestId, timestamp: Date.now() });
+        debugLog(`🔲 ${dialogType} dialog opened: ${api.call}`, { ...createDialogDebugInfo(api), dialogKey, wsTitle });
+    }
+    /** Routes $windowService API calls to create/show/destroy handlers. */
+    function handleWindowDialog(api) {
+        if (api.call === 'create')
+            handleWindowCreate(api);
+        else if (api.call === 'show')
+            handleWindowShow(api);
+        else if (api.call === 'destroy')
+            handleWindowDestroy(api);
+    }
+    /** Registers a new pending Window dialog entry when a $windowService 'create' is received. */
+    function handleWindowCreate(api) {
+        const windowName = Array.isArray(api.args) && api.args[0] && typeof api.args[0] === 'string' ? api.args[0] : 'unknown';
+        state.lastDialogCreatedTimestamp = Date.now();
+        const dialogKey = `Window:${windowName}:${++dialogIdCounter}`;
+        pendingDialogs.set(dialogKey, { dialogType: 'Window', triggeringRequestId: state.lastOutgoingRequestId, timestamp: Date.now() });
+        const debugInfo = createDialogDebugInfo(api);
+        debugInfo.pendingCellClicks = Array.from(state.pendingCellClickRequests.keys());
+        debugInfo.dialogKey = dialogKey;
+        debugLog(`🪟 Window dialog created: ${windowName}`, debugInfo);
+    }
+    /**
+     * Handles $windowService 'show' — the server is (re-)displaying a popup form.
+     * Unlike 'create', 'show' args are [windowName, formName, title], so the Angular form name
+     * is at args[1]. The `window.popupform` signal that normally feeds pendingFormLoads does not
+     * arrive for 'show', so we add the form here to block resolution until formLoaded fires.
+     */
+    function handleWindowShow(api) {
+        const formName = Array.isArray(api.args) && api.args[1] && typeof api.args[1] === 'string' ? api.args[1] : 'unknown';
+        state.lastDialogCreatedTimestamp = Date.now();
+        const dialogKey = `Window:${formName}:${++dialogIdCounter}`;
+        pendingDialogs.set(dialogKey, { dialogType: 'Window', triggeringRequestId: state.lastOutgoingRequestId, timestamp: Date.now() });
+        const debugInfo = createDialogDebugInfo(api);
+        debugInfo.dialogKey = dialogKey;
+        debugLog(`🪟 Window shown: ${formName}`, debugInfo);
+        if (formName !== 'unknown' && !state.pendingFormLoads.has(formName)) {
+            state.popupOpenedByThisAction = true;
+            state.pendingFormLoads.add(formName);
+            if (currentWin)
+                currentWin.wsPopupFormOpen = true;
+            const formTid = setTimeout(() => {
+                pendingTimeouts.delete(formTid);
+                if (state.pendingFormLoads.has(formName)) {
+                    state.pendingFormLoads.delete(formName);
+                    debugLog(`⏱️ Form load timeout (from window show): ${formName}`);
+                }
+            }, FORM_LOAD_TIMEOUT_MS);
+            pendingTimeouts.add(formTid);
+            debugLog(`🪟 Window show — waiting for formLoaded: ${formName}`);
+        }
+        // 'show' is the server's implicit response to a _dlg form button-click — no smsgid ever
+        // comes for that request. Hold the most-recent still-pending _dlg executeEvent so it
+        // doesn't block unheldRequests while the popup loads; handleWindowDestroy resolves it
+        // on close. We only hold the most-recent candidate to avoid incorrectly holding unrelated
+        // concurrent events (e.g. a "Save" click that already completed in the same invocation).
+        const pendingDlgIds = [...state.pendingDialogFormRequests].filter((id) => state.pendingRequests.has(id) && !state.heldRequests.has(id));
+        const triggeringRequest = pendingDlgIds[pendingDlgIds.length - 1];
+        if (triggeringRequest) {
+            state.heldRequests.add(triggeringRequest);
+            debugLog(`🔲 Show event — holding most-recent dialog form request: ${triggeringRequest}`);
+        }
+    }
+    /**
+     * Handles $windowService 'destroy' and window 'cancelFormPopupInternal' — both mean a
+     * popup/dialog was closed. Resets popup state, resolves any _dlg form requests, and
+     * starts the WINDOW_DESTROY_WAIT_MS cool-down period.
+     */
+    function handleWindowDestroy(api) {
+        state.windowDestroyDetected = true;
+        state.windowDestroyTimestamp = Date.now();
+        const windowName = Array.isArray(api.args) && api.args[0] && typeof api.args[0] === 'string' ? api.args[0] : 'unknown';
+        if (state.heldRequests.size > 0) {
+            debugLog(`🔓 Dialog/Window closed - ${state.heldRequests.size} held requests will be resolved by subsequent messages`);
+        }
+        // Reset popup-opened flag and clear pending form loads
+        state.popupOpenedByThisAction = false;
+        state.pendingFormLoads.clear();
+        if (currentWin)
+            currentWin.wsPopupFormOpen = false;
+        // Bulk-resolve any _dlg form requests — their responses won't arrive after window close
+        if (state.pendingDialogFormRequests.size > 0) {
+            for (const requestId of state.pendingDialogFormRequests) {
+                const sendTs = state.pendingRequests.get(requestId);
+                state.pendingRequests.delete(requestId);
+                state.heldRequests.delete(requestId);
+                if (sendTs && currentWin) {
+                    const ctx = requestContextMap.get(requestId);
+                    requestContextMap.delete(requestId);
+                    pushInteractionMetric(currentWin, 'cypress_ws_request_timing_ms', Date.now() - sendTs, {
+                        ...(ctx ?? {}),
+                        request_type: requestId.split(':')[0],
+                        phase: wsRequestPhase(sendTs)
+                    });
+                }
+                debugLog(`✅ Dialog form request resolved by window close: ${requestId}`);
+            }
+            state.pendingDialogFormRequests.clear();
+        }
+        for (const key of pendingDialogs.keys()) {
+            if (key.startsWith('Window:'))
+                pendingDialogs.delete(key);
+        }
+        debugLog(`🔳 Window closed: ${windowName} - starting 500ms wait period`);
+    }
+    /** Returns true if any serviceApi in the array opens a dialog (message dialog or window create). */
+    function checkForDialogInResponse(apis) {
+        return apis.some((api) => (api.name === 'dialogs' && api.call && DIALOG_METHODS.includes(api.call)) || (api.name === '$windowService' && (api.call === 'create' || api.call === 'show')));
+    }
+    /**
+     * Checks whether an incoming form update echoes back a pending svyPush.
+     * Matches by formBase (everything before `_ng` suffix) to handle the Angular form naming.
+     */
+    function checkDataSyncReflection(forms) {
+        for (const formKey of Object.keys(forms)) {
+            for (const [syncKey, pendingData] of state.pendingDataSync.entries()) {
+                if (formKey.includes(pendingData.formBase)) {
+                    state.pendingDataSync.delete(syncKey);
+                    if (currentWin)
+                        pushInteractionMetric(currentWin, 'cypress_ws_request_timing_ms', Date.now() - pendingData.timestamp, {
+                            methodname: 'svyPush',
+                            formname: syncKey.split(':')[0],
+                            beanname: pendingData.beanname ?? '',
+                            phase: wsRequestPhase(pendingData.timestamp),
+                            request_type: 'svyPush'
+                        });
+                    debugLog(`✅ Data sync reflected: ${syncKey}`);
+                }
+            }
+        }
+    }
+    /**
+     * Handles a formLoaded notification from the client.
+     * - Resolves the form from pendingFormLoads (popup form finished loading).
+     * - Clears expectingFormLoaded.
+     * - Resolves cellClick requests when a dialog form loaded shortly after a window was created.
+     */
+    function handleFormLoaded(data) {
+        const formname = 'args' in data && data.args && typeof data.args === 'object' && 'formname' in data.args ? String(data.args.formname) : '';
+        if (formname && currentWin) {
+            pushInteractionMetric(currentWin, 'cypress_ws_request_timing_ms', Date.now() - wsLoaderStartTime, {
+                methodname: 'formLoaded',
+                formname,
+                phase: wsRequestPhase(Date.now()),
+                request_type: 'formLoaded'
+            });
+        }
+        if (formname && state.pendingFormLoads.has(formname)) {
+            state.pendingFormLoads.delete(formname);
+            debugLog(`✅ Popup form loaded: ${formname}`);
+        }
+        if (state.expectingFormLoaded) {
+            state.expectingFormLoaded = false;
+            debugLog('✅ formLoaded resolved expectingFormLoaded', { formname: formname });
+        }
+        if (!state.lastDialogCreatedTimestamp || state.pendingCellClickRequests.size === 0)
+            return;
+        const timeSinceDialog = Date.now() - state.lastDialogCreatedTimestamp;
+        // Only attribute the formLoaded to cellClick if it arrived within the dialog timeout window
+        if (timeSinceDialog >= CELL_CLICK_DIALOG_TIMEOUT_MS)
+            return;
+        for (const [requestId, clickData] of state.pendingCellClickRequests.entries()) {
+            if (!state.pendingRequests.has(requestId))
+                continue;
+            state.pendingRequests.delete(requestId);
+            state.heldRequests.delete(requestId);
+            state.pendingCellClickRequests.delete(requestId);
+            state.extendedQuietPeriod = true;
+            debugLog(`✅ Resolved cellClick by formLoaded pattern: ${requestId}`, {
+                clickType: clickData.clickType,
+                formname: clickData.formname,
+                timeSinceDialog,
+                formLoaded: 'args' in data && data.args && typeof data.args === 'object' && 'formname' in data.args ? String(data.args.formname) : 'unknown'
+            });
+        }
+        state.lastDialogCreatedTimestamp = null;
+    }
+    /**
+     * Handles a formUnloaded notification — clears any pending svyPush entries for the
+     * unloaded form and confirms a _dlg form close if one is awaiting confirmation.
+     */
+    function handleFormUnloaded(data) {
+        const formname = 'args' in data && data.args && typeof data.args === 'object' && 'formname' in data.args ? String(data.args.formname) : '';
+        if (!formname)
+            return;
+        if (currentWin) {
+            pushInteractionMetric(currentWin, 'cypress_ws_request_timing_ms', Date.now() - wsLoaderStartTime, {
+                methodname: 'formUnloaded',
+                formname,
+                phase: wsRequestPhase(Date.now()),
+                request_type: 'formUnloaded'
+            });
+        }
+        for (const [syncKey] of state.pendingDataSync.entries()) {
+            if (syncKey.startsWith(`${formname}:`)) {
+                state.pendingDataSync.delete(syncKey);
+                debugLog(`✅ svyPush cleared on formUnloaded: ${syncKey}`);
+            }
+        }
+        // Cancel the _dlg fallback timeout — formUnloaded confirmed the dialog was closed
+        const closeTid = pendingDlgFormSvyPush.get(formname);
+        if (closeTid !== undefined) {
+            clearTimeout(closeTid);
+            pendingDlgFormSvyPush.delete(formname);
+            debugLog(`✅ dlg form close confirmed: ${formname}`);
+        }
+    }
+    // ═══════════════════════════════════════════════════════════════════════════
+    // Logging helpers
+    // ═══════════════════════════════════════════════════════════════════════════
+    /** Updates the live Cypress log entry with current pending counts and elapsed time. */
+    function updateLog(isResolved, startTime) {
+        if (isResolved)
+            return;
+        const elapsed = Math.floor((Date.now() - startTime) / 1000);
+        const unheldRequests = getUnheldRequests();
+        const heldRequestsList = Array.from(state.heldRequests);
+        const status = [
+            `${elapsed}s`,
+            unheldRequests.length > 0 ? `Requests: ${unheldRequests.length}` : '',
+            heldRequestsList.length > 0 ? `Held: ${heldRequestsList.length}` : '',
+            state.loadingIndicator ? 'Loading' : '',
+            state.pendingDataSync.size > 0 ? `DataSync: ${state.pendingDataSync.size}` : ''
+        ]
+            .filter(Boolean)
+            .join(' | ');
+        log.set({ message: status });
+    }
+    /**
+     * Resets the message store and all active timers after successful resolution.
+     * Optionally dumps all recorded messages to the console first (when DEBUG_MODE is on).
+     */
+    function clearWebSocketMessages() {
+        return cy
+            .wrap(null, { log: false })
+            .then(() => {
+            if (DEBUG_MODE)
+                return logAllWebSocketMessages('Before Clear');
+            return cy.wrap(null, { log: false });
+        })
+            .then(() => {
+            return cy.window({ log: false }).then((win) => {
+                // Capture before reset — this is the last WS message time, excluding the quiet period wait
+                const resolveTime = state.lastWsActivityTs;
+                if (win.wsMessages) {
+                    win.wsMessages.messages = [];
+                    state.lastProcessedIndex = 0;
+                    state.lastWsActivityTs = Date.now();
+                    for (const tid of pendingTimeouts)
+                        clearTimeout(tid);
+                    pendingTimeouts.clear();
+                    for (const tid of pendingDlgFormSvyPush.values())
+                        clearTimeout(tid);
+                    pendingDlgFormSvyPush.clear();
+                    debugLog('🧹 Cleared WebSocket messages');
+                }
+                if (actionStartTime !== null) {
+                    const totalMs = resolveTime - actionStartTime;
+                    const preLoadingMs = capturedFirstLoadingStartTime !== null ? capturedFirstLoadingStartTime - actionStartTime : totalMs;
+                    const postLoadingMs = capturedLastLoadingEndTime !== null ? resolveTime - capturedLastLoadingEndTime : 0;
+                    pushInteractionMetric(win, 'cypress_interaction_timing_ms', totalMs, { phase: 'total' });
+                    pushInteractionMetric(win, 'cypress_interaction_timing_ms', preLoadingMs, { phase: 'pre_loading' });
+                    pushInteractionMetric(win, 'cypress_interaction_timing_ms', capturedTotalLoadingMs, { phase: 'loading' });
+                    pushInteractionMetric(win, 'cypress_interaction_timing_ms', postLoadingMs, { phase: 'post_loading' });
+                }
+                if (win.wsMetrics?.length) {
+                    const metrics = [...win.wsMetrics];
+                    win.wsMetrics = [];
+                    cy.task('bufferWsMetrics', metrics, { log: false });
+                }
+            });
+        });
+    }
+    /** Dumps the full recorded message log to the browser console for post-mortem debugging. */
+    function logAllWebSocketMessages(context) {
+        return cy
+            .window({ log: false })
+            .then((win) => {
+            if (!win.wsMessages?.messages?.length) {
+                console.log(`No WebSocket messages to log for: ${context}`);
+                return;
+            }
+            console.group(`🔍 WebSocket Messages - ${context}`);
+            console.log(`Total messages: ${win.wsMessages.messages.length}`);
+            logCurrentState();
+            const outgoing = win.wsMessages.messages.filter((m) => m.direction === 'outgoing');
+            const incoming = win.wsMessages.messages.filter((m) => m.direction === 'incoming');
+            logMessageGroup('📤 Outgoing Messages', outgoing);
+            logMessageGroup('📥 Incoming Messages', incoming);
+            logRecentMessages(win.wsMessages.messages);
+            console.groupEnd();
+        })
+            .then(() => cy.wrap(undefined, { log: false }));
+    }
+    /** Dumps the current state machine snapshot to the console. */
+    function logCurrentState() {
+        console.group('📊 Current State');
+        console.log('Pending Requests:', Array.from(state.pendingRequests.keys()));
+        console.log('Held Requests:', Array.from(state.heldRequests));
+        console.log('Loading Indicator:', state.loadingIndicator);
+        console.log('Pending Data Sync:', Array.from(state.pendingDataSync.entries()));
+        console.log('Pending Cell Click Requests:', Array.from(state.pendingCellClickRequests.entries()));
+        console.log('Window Destroy Detected:', state.windowDestroyDetected);
+        console.log('Extended Quiet Period:', state.extendedQuietPeriod);
+        console.groupEnd();
+    }
+    /** Logs a group of WebSocket messages (outgoing or incoming) to the console. */
+    function logMessageGroup(title, messages) {
+        console.group(`${title} (${messages.length})`);
+        messages.forEach((msg, index) => {
+            console.group(`Message ${index + 1} - ${new Date(msg.timestamp).toISOString()}`);
+            console.log('Raw:', msg.data);
+            try {
+                const parsed = parseMessage(msg);
+                if (parsed)
+                    console.log('Parsed:', parsed);
+            }
+            catch (e) {
+                console.log('Parse error:', e);
+            }
+            console.groupEnd();
+        });
+        console.groupEnd();
+    }
+    /** Logs the last 10 frames in chronological order to the console. */
+    function logRecentMessages(messages) {
+        console.group('🕐 Last 10 Messages (Chronological)');
+        const lastMessages = [...messages].sort((a, b) => a.timestamp - b.timestamp).slice(-10);
+        lastMessages.forEach((msg, index) => {
+            const parsed = parseMessage(msg);
+            console.log(`${index + 1}. [${msg.direction}] ${new Date(msg.timestamp).toISOString()}`, parsed ?? msg.data);
+        });
+        console.groupEnd();
+    }
+    // ═══════════════════════════════════════════════════════════════════════════
+    // Utility functions
+    // ═══════════════════════════════════════════════════════════════════════════
+    /** Returns true for Servoy ping ('p') and pong ('P') heartbeat frames. */
+    function isPingPongFrame(message) {
+        if (typeof message.data !== 'string')
+            return false;
+        const s = message.data.trim();
+        return /^[Pp](\s+\d+)?$/.test(s);
+    }
+    /** Records the current time as the most recent WS activity timestamp (resets the quiet period). */
+    function markWsActivity() {
+        state.lastWsActivityTs = Date.now();
+    }
+    /**
+     * Parses the raw WebSocket frame data into a typed message object.
+     * Servoy frames may be prefixed with non-JSON characters before the JSON payload.
+     */
+    function parseMessage(message) {
+        if (typeof message.data !== 'string')
+            return null;
+        const jsonStart = message.data.indexOf('{');
+        const jsonString = jsonStart !== -1 ? message.data.substring(jsonStart) : message.data;
+        try {
+            return JSON.parse(jsonString);
+        }
+        catch {
+            return null;
+        }
+    }
+    /**
+     * Extracts the tracking RequestId from a parsed message.
+     * For outgoing messages: reads cmsgid, requestId, or msgid.
+     * For incoming messages: matches smsgid back to a known pending cmsgid (skips dialog responses).
+     */
+    function extractRequestId(data) {
+        // Outgoing message id fields
+        if ('cmsgid' in data && data.cmsgid !== undefined)
+            return `cmsg:${data.cmsgid}`;
+        if ('requestId' in data && data.requestId)
+            return `req:${data.requestId}`;
+        if ('msgid' in data && data.msgid !== undefined)
+            return `msg:${data.msgid}`;
+        // Incoming: resolve the outgoing request by its echoed smsgid, but not if it opened a dialog
+        if ('smsgid' in data && typeof data.smsgid === 'number') {
+            const hasDialog = 'serviceApis' in data && Array.isArray(data.serviceApis) && checkForDialogInResponse(data.serviceApis);
+            if (hasDialog)
+                return null;
+            const targetId = `cmsg:${data.smsgid}`;
+            if (state.pendingRequests.has(targetId))
+                return targetId;
+        }
+        return null;
+    }
+    /** Creates a serialisable snapshot of the current state for the Cypress consoleProps log. */
+    function getStateSnapshot(state) {
+        return {
+            pendingRequests: Array.from(state.pendingRequests.keys()),
+            loadingIndicator: state.loadingIndicator,
+            heldRequests: Array.from(state.heldRequests),
+            pendingDataSync: Array.from(state.pendingDataSync.keys()),
+            lastProcessedIndex: state.lastProcessedIndex,
+            lastOutgoingRequestId: state.lastOutgoingRequestId,
+            windowDestroyDetected: state.windowDestroyDetected,
+            windowDestroyTimestamp: state.windowDestroyTimestamp,
+            extendedQuietPeriod: state.extendedQuietPeriod,
+            pendingCellClickRequests: Array.from(state.pendingCellClickRequests.keys()),
+            lastDialogCreatedTimestamp: state.lastDialogCreatedTimestamp,
+            pendingDialogs: Array.from(pendingDialogs.entries())
+        };
+    }
+});