mcp-accessibility-scanner 3.3.2 → 3.5.0

package/lib/context.js

@@ -20,6 +20,57 @@ import { Tab } from './tab.js';
 import { outputFile } from './config.js';
 import { ensureNetworkPolicyRoutes } from './networkPolicy.js';
 const testDebug = debug('pw:mcp:test');
+const recorderBufferMs = 500;
+const recorderControlTools = new Set(['browser_start_recording', 'browser_stop_recording']);
+const expectPrelude = "const { expect } = require('playwright/test');";
+const pendingPageCloses = new WeakMap();
+function pendingPageClose(page) {
+    const pending = pendingPageCloses.get(page);
+    if (pending)
+        return pending;
+    const close = page.close();
+    pendingPageCloses.set(page, close);
+    const clear = () => {
+        if (pendingPageCloses.get(page) === close)
+            pendingPageCloses.delete(page);
+    };
+    void close.then(clear, clear);
+    return close;
+}
+/**
+ * Chromium can acknowledge Target.closeTarget while a racing navigation keeps
+ * the target alive. Retry the public close call instead of letting one tool or
+ * an entire crawl wait forever.
+ */
+async function closePage(page, timeoutMs) {
+    const deadline = Date.now() + timeoutMs;
+    for (let attempt = 0; attempt < 3; attempt++) {
+        const remaining = deadline - Date.now();
+        if (remaining <= 0)
+            break;
+        let timer;
+        try {
+            await Promise.race([
+                pendingPageClose(page),
+                new Promise((_, reject) => {
+                    timer = setTimeout(() => reject(new Error(`Timed out after ${timeoutMs}ms while closing the page.`)), remaining);
+                    timer.unref?.();
+                }),
+            ]);
+            if (page.isClosed())
+                return;
+        }
+        catch (error) {
+            if (page.isClosed())
+                return;
+            throw error;
+        }
+        finally {
+            clearTimeout(timer);
+        }
+    }
+    throw new Error(`Failed to close the page after 3 attempts within ${timeoutMs}ms.`);
+}
 class ContextRegistry {
     _contexts = new Set();
     register(context) {
@@ -34,6 +85,7 @@ class ContextRegistry {
 }
 const contextRegistry = new ContextRegistry();
 const traceHubs = new WeakMap();
+const idleGroups = new WeakMap();
 async function acquireTrace(browserContext) {
     let hub = traceHubs.get(browserContext);
     if (!hub) {
@@ -74,7 +126,26 @@ async function releaseTrace(browserContext) {
     if (!hub || --hub.users)
         return;
     traceHubs.delete(browserContext);
-    await browserContext.tracing.stop();
+    try {
+        await browserContext.tracing.stop();
+    }
+    catch (originalError) {
+        // Playwright's stop sends the server-side tracingStop only after the
+        // chunk export succeeds, so a stop that fails midway (an unwritable
+        // export target, a channel hiccup) leaves tracing started while the
+        // hub above is already gone — every later session on this browser
+        // context would fail its start with "Tracing has been already started".
+        // One bare retry ends the recording; when it succeeds the session
+        // recovered (the original failure is not worth surfacing), and when it
+        // also fails the original error is the real one to report. try/catch,
+        // not a .catch() chain, so a synchronously throwing stop is retried too.
+        try {
+            await browserContext.tracing.stop();
+        }
+        catch {
+            throw originalError;
+        }
+    }
 }
 export class Context {
     tools;
@@ -91,6 +162,7 @@ export class Context {
     // second still ran — letting the session TTL reaper (or a session close)
     // dispose the browser mid-operation.
     _runningTools = [];
+    _lastToolCallEndedAt = -Infinity;
     // In-flight download saves (Tab hands them over as they start). A download
     // outlives the tool call that triggered it — the response reports it as
     // "still downloading" — so disposal must wait for these before closing the
@@ -101,8 +173,16 @@ export class Context {
     _abortController = new AbortController();
     _removePageObserver;
     _inputRecorder;
+    _removeRecorderContext;
+    _recordingStartFinished;
+    _recording;
+    _recordingStops = new Set();
+    _closeAfterRecording = false;
     // Resolved from options.sessionLog at the first browser context launch.
     _sessionLog;
+    _idleGroup;
+    _lastActivityAt = Date.now();
+    _idleClosePromise;
     constructor(options) {
         this.tools = options.tools;
         this.config = options.config;
@@ -170,16 +250,98 @@ export class Context {
             await browserContext.newPage();
         return this._currentTab;
     }
+    async startRecording() {
+        this.assertRecordingCanStart();
+        await this._startRecording();
+    }
+    async startRecordingOnCurrentTab() {
+        this.assertRecordingCanStart();
+        let finishStart;
+        const startFinished = new Promise(resolve => finishStart = resolve);
+        this._recordingStartFinished = startFinished;
+        try {
+            const tab = await this.ensureTab();
+            await tab.page.bringToFront();
+            await this._startRecording();
+        }
+        finally {
+            if (this._recordingStartFinished === startFinished)
+                this._recordingStartFinished = undefined;
+            finishStart();
+            this._scheduleIdleTimeout();
+        }
+    }
+    async _startRecording() {
+        const actions = [];
+        const target = { actions, pageIndexes: new Map(), state: { stopping: false } };
+        const ready = this._ensureBrowserContext().then(async ({ browserContext }) => {
+            await InputRecorder.startRecording(this, browserContext, target);
+            return browserContext;
+        });
+        const recording = { target, ready, lastActivityAt: Date.now() };
+        this._recording = recording;
+        try {
+            await ready;
+        }
+        catch (error) {
+            if (this._recording === recording)
+                this._recording = undefined;
+            this._scheduleIdleTimeout();
+            this._closeBrowserContextAfterRecording();
+            throw error;
+        }
+    }
+    async stopRecording() {
+        this.assertRecordingCanPersist();
+        if (this._recordingStartFinished)
+            await this._recordingStartFinished;
+        const recording = this._recording;
+        if (!recording)
+            return undefined;
+        this._recording = undefined;
+        recording.target.state.stopping = true;
+        let finishStop;
+        const stopFinished = new Promise(resolve => finishStop = resolve);
+        this._recordingStops.add(stopFinished);
+        try {
+            const browserContext = await recording.ready;
+            await InputRecorder.stopRecording(this, browserContext, recording.target);
+            return recording.target.actions.map(action => action.code.trim()).filter(Boolean);
+        }
+        finally {
+            this._recordingStops.delete(stopFinished);
+            finishStop();
+            this._lastActivityAt = Date.now();
+            this._scheduleIdleTimeout();
+            this._closeBrowserContextAfterRecording();
+        }
+    }
+    recordingActivityAt() {
+        return this._recording?.lastActivityAt;
+    }
+    markRecordingActivity() {
+        if (this._recording)
+            this._recording.lastActivityAt = Date.now();
+    }
+    assertRecordingCanPersist() {
+        if (this.options.browserSession && !this.options.browserSessionId)
+            throw new Error('Recording over stateless HTTP requires a browserSessionId. Call browser_session_open, then pass its browserSessionId to browser_start_recording and browser_stop_recording. Shared-context modes that cannot open browser sessions require a stateful MCP connection.');
+    }
+    assertRecordingCanStart() {
+        this.assertRecordingCanPersist();
+        if (this._recording || this._recordingStartFinished)
+            throw new Error('Recording is already in progress.');
+    }
     async closeTab(index) {
         const tab = index === undefined ? this._currentTab : this._tabs[index];
         if (!tab)
             throw new Error(`Tab ${index} not found`);
         const url = tab.page.url();
-        await tab.page.close();
+        await closePage(tab.page, tab.operationTimeout());
         return url;
     }
-    async outputFile(name) {
-        return outputFile(this.config, name);
+    async outputFile(name, exclusive = false) {
+        return outputFile(this.config, name, exclusive);
     }
     /**
      * The registry behind `browser_session_open` / `browser_session_close`.
@@ -192,6 +354,7 @@ export class Context {
         return this.options.browserSessions;
     }
     _onPageCreated(page) {
+        this._closeAfterRecording = false;
         const tab = new Tab(this, page, tab => this._onPageClosed(tab));
         this._tabs.push(tab);
         if (!this._currentTab)
@@ -204,19 +367,36 @@ export class Context {
         this._tabs.splice(index, 1);
         if (this._currentTab === tab)
             this._currentTab = this._tabs[Math.min(index, this._tabs.length - 1)];
-        if (!this._tabs.length)
-            void this.closeBrowserContext();
+        if (!this._tabs.length) {
+            if (this._recording || this._recordingStops.size)
+                this._closeAfterRecording = true;
+            else
+                void this.closeBrowserContext();
+        }
     }
     async closeBrowserContext() {
+        if (this._idleClosePromise) {
+            await this._idleClosePromise;
+            this._idleClosePromise = undefined;
+        }
         if (!this._closeBrowserContextPromise)
             this._closeBrowserContextPromise = this._closeBrowserContextImpl().catch(logUnhandledError);
         await this._closeBrowserContextPromise;
         this._closeBrowserContextPromise = undefined;
     }
+    _closeBrowserContextAfterRecording() {
+        if (!this._closeAfterRecording || this._recording || this._recordingStops.size || this._closeBrowserContextPromise)
+            return;
+        this._closeAfterRecording = false;
+        void this.closeBrowserContext();
+    }
     /** True while ANY tool call is running in this Context, overlap included. */
     isRunningTool() {
         return this._runningTools.length > 0;
     }
+    isRunningToolForRecording(buffered) {
+        return this._runningTools.some(name => !recorderControlTools.has(name)) || buffered && Date.now() - this._lastToolCallEndedAt <= recorderBufferMs;
+    }
     /**
      * Registers an in-flight download save. Disposal waits (bounded) for the
      * registered saves before closing the browser context, and the session TTL
@@ -228,7 +408,12 @@ export class Context {
     trackPendingDownload(promise) {
         const settled = promise.catch(logUnhandledError);
         this._pendingDownloads.add(settled);
-        void settled.then(() => this._pendingDownloads.delete(settled));
+        this._scheduleIdleTimeout();
+        void settled.then(() => {
+            this._pendingDownloads.delete(settled);
+            this._lastActivityAt = Date.now();
+            this._scheduleIdleTimeout();
+        });
     }
     /** True while a download save is still writing its file. */
     hasPendingDownloads() {
@@ -272,6 +457,7 @@ export class Context {
      */
     beginToolCall(name) {
         this._runningTools.push(name);
+        this._scheduleIdleTimeout();
         let released = false;
         return () => {
             if (released)
@@ -280,8 +466,48 @@ export class Context {
             const index = this._runningTools.lastIndexOf(name);
             if (index !== -1)
                 this._runningTools.splice(index, 1);
+            if (!recorderControlTools.has(name))
+                this._lastToolCallEndedAt = Date.now();
+            this._lastActivityAt = Date.now();
+            this._scheduleIdleTimeout();
         };
     }
+    async resumeAfterIdle() {
+        if (!this._idleClosePromise)
+            return;
+        await this._idleClosePromise;
+        await this._ensureBrowserContext();
+        this._idleClosePromise = undefined;
+        return 'The browser connection was released after inactivity and has been reopened. Use browser_navigate to navigate again if needed; previous element references are no longer valid.';
+    }
+    _scheduleIdleTimeout() {
+        const group = this._idleGroup;
+        if (!group)
+            return;
+        clearTimeout(group.timer);
+        group.timer = undefined;
+        if (group.closing || !group.contexts.size)
+            return;
+        let deadline = 0;
+        for (const context of group.contexts) {
+            if (!context.config.timeouts.idle || context.options.browserSession || context.isRunningTool() || context.hasPendingDownloads() || context._recording || context._recordingStartFinished || context._recordingStops.size)
+                return;
+            deadline = Math.max(deadline, context._lastActivityAt + context.config.timeouts.idle);
+        }
+        group.timer = setTimeout(() => {
+            group.timer = undefined;
+            const contexts = [...group.contexts];
+            // Invoke every close synchronously before another tool can acquire a
+            // shared context. Factory release hooks preserve external ownership.
+            group.closing = Promise.all(contexts.map(context => context.closeBrowserContext())).then(() => {
+                idleGroups.delete(group.browserContext);
+            });
+            for (const context of contexts)
+                context._idleClosePromise = group.closing;
+            void group.closing.catch(logUnhandledError);
+        }, Math.max(0, deadline - Date.now()));
+        group.timer.unref?.();
+    }
     async _closeBrowserContextImpl() {
         if (!this._browserContextPromise)
             return;
@@ -309,6 +535,9 @@ export class Context {
             // window to finish, so the files tool responses reported as "still
             // downloading" actually materialize.
             await this._waitForPendingDownloads();
+            if (this._recording)
+                await this.stopRecording().catch(logUnhandledError);
+            await Promise.all(this._recordingStops);
             this._detachFromBrowserContext();
             // close() is the factory's only cleanup hook — for storage-state
             // sessions it also removes the disposable profile — and this close
@@ -344,10 +573,20 @@ export class Context {
     // listener would keep creating tabs inside a disposed Context, and the tab
     // wrappers' own page listeners would pile up with session churn.
     _detachFromBrowserContext() {
+        if (this._idleGroup) {
+            this._idleGroup.contexts.delete(this);
+            this._scheduleIdleTimeout();
+            if (!this._idleGroup.contexts.size && !this._idleGroup.closing)
+                idleGroups.delete(this._idleGroup.browserContext);
+            this._idleGroup = undefined;
+        }
         this._removePageObserver?.();
         this._removePageObserver = undefined;
+        this._removeRecorderContext?.();
+        this._removeRecorderContext = undefined;
         this._inputRecorder?.dispose();
         this._inputRecorder = undefined;
+        this._closeAfterRecording = false;
         for (const tab of this._tabs)
             tab.dispose();
         this._tabs = [];
@@ -369,6 +608,23 @@ export class Context {
         // The factory gets the most recently started call's name — with overlap
         // that is the call whose execution is creating the context right now.
         const result = await this._browserContextFactory.createContext(this._clientInfo, this._abortController.signal, this._runningTools[this._runningTools.length - 1], { browserSession: this.options.browserSession });
+        const closingGroup = idleGroups.get(result.browserContext)?.closing;
+        if (closingGroup) {
+            // A new client can acquire a shared factory lease during idle cleanup.
+            // Release it before waiting so the last old client can close the browser.
+            await result.close();
+            await closingGroup;
+            return this._setupBrowserContext();
+        }
+        let group = idleGroups.get(result.browserContext);
+        if (!group) {
+            group = { browserContext: result.browserContext, contexts: new Set() };
+            idleGroups.set(result.browserContext, group);
+        }
+        group.contexts.add(this);
+        this._idleGroup = group;
+        this._lastActivityAt = Date.now();
+        this._scheduleIdleTimeout();
         // The factory handed ownership over with close(); a setup failure past
         // this point would otherwise discard that callback with the browser still
         // running — and, for storage-state sessions, the disposable profile
@@ -376,6 +632,7 @@ export class Context {
         try {
             const { browserContext } = result;
             await this._setupRequestInterception(browserContext);
+            this._removeRecorderContext = InputRecorder.attachContext(this, browserContext);
             // First real use of this context: resolve — and, once per backend,
             // create — the session log before deciding whether to record input.
             await this.resolveSessionLog();
@@ -399,60 +656,45 @@ export class Context {
         return result;
     }
 }
+const actionIsBuffered = (action) => action.name === 'click' && action.button === 'left' || action.name === 'navigate';
+const pageAliasFromCode = (code) => code.match(/^\s*await\s+(page\d*)\./m)?.[1]
+    ?? code.match(/^\s*await\s+expect\((page\d*)(?:\.|\))/m)?.[1];
+const addMissingPageAlias = (recorded, page, code, pageIndexes, browserContext) => {
+    const alias = pageAliasFromCode(code);
+    if (!alias || alias === 'page')
+        return;
+    const declaration = new RegExp(`^\\s*const\\s+${alias}\\s*=`, 'm');
+    if (declaration.test(code) || recorded.some(action => declaration.test(action.code)))
+        return;
+    const initialPageIndex = pageIndexes.get(page);
+    const pageIndex = initialPageIndex ?? browserContext.pages().indexOf(page);
+    if (pageIndex === -1)
+        return;
+    const declarationAction = { page, code: `const ${alias} = context.pages()[${pageIndex}];` };
+    if (initialPageIndex === undefined)
+        recorded.push(declarationAction);
+    else
+        recorded.unshift(declarationAction);
+};
 const recorderHubs = new WeakMap();
+const recorderContexts = new WeakMap();
 export class InputRecorder {
     _context;
     _browserContext;
+    _lastActions = new WeakMap();
     constructor(context, browserContext) {
         this._context = context;
         this._browserContext = browserContext;
     }
     static async create(context, browserContext) {
         const recorder = new InputRecorder(context, browserContext);
-        let hub = recorderHubs.get(browserContext);
-        if (!hub) {
-            const recorders = new Set();
-            const dispatch = (handle) => {
-                // A tool call drives the page through Playwright, and the recorder
-                // cannot attribute a DOM event to the session that caused it — so
-                // while any session sharing this context runs a tool, the events are
-                // automation for every session's log, not user actions. (A real user
-                // action racing a sibling's tool call is suppressed with them — the
-                // same trade-off a single session already accepts for its own runs.)
-                for (const registered of recorders) {
-                    if (registered._context.isRunningTool())
-                        return;
-                }
-                for (const registered of recorders)
-                    handle(registered);
-            };
-            const created = {
-                recorders,
-                ready: browserContext._enableRecorder({
-                    mode: 'recording',
-                    recorderMode: 'api',
-                }, {
-                    actionAdded: (page, data, code) => {
-                        dispatch(registered => registered._actionAdded(page, data, code));
-                    },
-                    actionUpdated: (page, data, code) => {
-                        dispatch(registered => registered._actionUpdated(page, data, code));
-                    },
-                    signalAdded: (page, data) => {
-                        dispatch(registered => registered._signalAdded(page, data));
-                    },
-                }),
-            };
-            created.ready.catch(() => {
-                if (recorderHubs.get(browserContext) === created)
-                    recorderHubs.delete(browserContext);
-            });
-            recorderHubs.set(browserContext, created);
-            hub = created;
-        }
+        const existingHub = recorderHubs.get(browserContext);
+        const hub = InputRecorder._ensureHub(browserContext);
         hub.recorders.add(recorder);
         try {
             await hub.ready;
+            if (existingHub)
+                await hub.ensureArmed();
         }
         catch (error) {
             hub.recorders.delete(recorder);
@@ -460,30 +702,194 @@ export class InputRecorder {
         }
         return recorder;
     }
+    static attachContext(context, browserContext) {
+        let contexts = recorderContexts.get(browserContext);
+        if (!contexts) {
+            contexts = new Set();
+            recorderContexts.set(browserContext, contexts);
+        }
+        contexts.add(context);
+        return () => contexts.delete(context);
+    }
+    static async startRecording(context, browserContext, target) {
+        const existingHub = recorderHubs.get(browserContext);
+        const hub = InputRecorder._ensureHub(browserContext);
+        ++hub.starting;
+        try {
+            await hub.ready;
+            if (existingHub) {
+                await new Promise(resolve => setTimeout(resolve, recorderBufferMs));
+                await hub.arm();
+            }
+            for (const [index, page] of browserContext.pages().entries())
+                target.pageIndexes.set(page, index);
+            hub.recordings.set(context, target);
+        }
+        catch (error) {
+            if (hub.recordings.get(context) === target)
+                hub.recordings.delete(context);
+            throw error;
+        }
+        finally {
+            --hub.starting;
+        }
+    }
+    static async stopRecording(context, browserContext, target) {
+        // Playwright buffers clicks and navigations for 500ms so a later
+        // event can refine them. Keep this recording registered until that last
+        // event arrives; config.timeouts.settle may be shorter or disabled.
+        const recordings = recorderHubs.get(browserContext)?.recordings;
+        await new Promise(resolve => setTimeout(resolve, recorderBufferMs));
+        if (target && recordings?.get(context) === target) {
+            recordings.delete(context);
+            const hub = recorderHubs.get(browserContext);
+            await hub?.standbyIfIdle().catch(logUnhandledError);
+        }
+    }
     dispose() {
-        recorderHubs.get(this._browserContext)?.recorders.delete(this);
+        const hub = recorderHubs.get(this._browserContext);
+        hub?.recorders.delete(this);
+        void hub?.standbyIfIdle().catch(logUnhandledError);
+    }
+    static _ensureHub(browserContext) {
+        const hub = recorderHubs.get(browserContext);
+        if (hub)
+            return hub;
+        const recorders = new Set();
+        const recordings = new Map();
+        let actionSequence = 0;
+        const lastActionSequence = new WeakMap();
+        let armed = false;
+        let transition = Promise.resolve();
+        const enqueue = (callback) => {
+            const result = transition.then(callback, callback);
+            transition = result.catch(() => { });
+            return result;
+        };
+        const dispatch = (buffered, flushable, log, record) => {
+            const contexts = new Set(recorderContexts.get(browserContext));
+            for (const context of recordings.keys())
+                contexts.add(context);
+            const running = [...contexts].filter(context => context.isRunningToolForRecording(buffered));
+            if (!running.length) {
+                for (const recorder of recorders)
+                    log(recorder);
+            }
+            for (const [context, target] of recordings) {
+                if ((!target.state.stopping || flushable) && !running.some(runningContext => runningContext !== context)) {
+                    record(target);
+                    context.markRecordingActivity();
+                }
+            }
+        };
+        const params = {
+            mode: 'recording',
+            recorderMode: 'api',
+            omitCallTracking: true,
+            language: 'javascript',
+        };
+        const sink = {
+            actionAdded: (page, data, code) => {
+                const sequence = ++actionSequence;
+                lastActionSequence.set(page, sequence);
+                const action = 'action' in data ? data.action : data;
+                const isAssertion = action.name.startsWith('assert');
+                if (isAssertion)
+                    code = code.replace(/^(\s*)\/\/ ?/gm, '$1');
+                const buffered = actionIsBuffered(action);
+                dispatch(buffered, buffered || action.name === 'closePage', recorder => recorder._actionAdded(page, action, isAssertion ? `${expectPrelude}\n${code}` : code, sequence), target => {
+                    if (isAssertion && !target.actions.some(action => action.code === expectPrelude))
+                        target.actions.push({ page, code: expectPrelude });
+                    addMissingPageAlias(target.actions, page, code, target.pageIndexes, browserContext);
+                    target.actions.push({ page, code, sequence });
+                });
+            },
+            actionUpdated: (page, data, code) => {
+                const sequence = lastActionSequence.get(page);
+                if (sequence === undefined)
+                    return;
+                const action = 'action' in data ? data.action : data;
+                dispatch(true, true, recorder => recorder._actionUpdated(page, action, code, sequence), target => {
+                    const recorded = target.actions.findLast(action => action.sequence === sequence);
+                    if (recorded)
+                        recorded.code = code;
+                });
+            },
+            signalAdded: (page, data, code) => {
+                const sequence = lastActionSequence.get(page);
+                const signal = 'signal' in data ? data.signal : data;
+                dispatch(true, true, recorder => recorder._signalAdded(page, signal, code, sequence), target => {
+                    if (sequence === undefined)
+                        return;
+                    const action = target.actions.findLast(action => action.sequence === sequence);
+                    if (action && code)
+                        action.code = code;
+                });
+            },
+        };
+        const arm = async () => {
+            await browserContext._enableRecorder(params, sink);
+            armed = true;
+        };
+        const created = {
+            recorders,
+            recordings,
+            starting: 0,
+            ready: enqueue(arm),
+            arm: () => enqueue(arm),
+            ensureArmed: () => enqueue(async () => {
+                if (armed)
+                    return;
+                await arm();
+            }),
+            standbyIfIdle: () => enqueue(async () => {
+                if (created.starting || recorders.size || recordings.size)
+                    return;
+                try {
+                    await browserContext._disableRecorder();
+                }
+                finally {
+                    armed = false;
+                }
+            }),
+        };
+        created.ready.catch(() => {
+            if (recorderHubs.get(browserContext) === created)
+                recorderHubs.delete(browserContext);
+        });
+        recorderHubs.set(browserContext, created);
+        return created;
     }
-    _actionAdded(page, data, code) {
+    _actionAdded(page, action, code, sequence) {
+        this._lastActions.set(page, { action, sequence });
         const tab = this._context.tabForPage(page);
         if (tab)
-            this._context.sessionLog.logUserAction(data.action, tab, code, false);
+            this._context.sessionLog.logUserAction(action, tab, code, false);
     }
-    _actionUpdated(page, data, code) {
+    _actionUpdated(page, action, code, sequence) {
+        if (this._lastActions.get(page)?.sequence !== sequence)
+            return;
+        this._lastActions.set(page, { action, sequence });
         const tab = this._context.tabForPage(page);
         if (tab)
-            this._context.sessionLog.logUserAction(data.action, tab, code, true);
+            this._context.sessionLog.logUserAction(action, tab, code, true);
     }
-    _signalAdded(page, data) {
-        if (data.signal.name !== 'navigation')
+    _signalAdded(page, signal, code, sequence) {
+        const lastAction = this._lastActions.get(page);
+        if (sequence !== undefined && lastAction?.sequence !== sequence)
             return;
         const tab = this._context.tabForPage(page);
+        if (signal.name !== 'navigation' && tab && code && lastAction)
+            this._context.sessionLog.logUserAction(lastAction.action, tab, code, true);
+        if (signal.name !== 'navigation')
+            return;
         const navigateAction = {
             name: 'navigate',
-            url: data.signal.url,
+            url: signal.url,
             signals: [],
         };
         if (tab)
-            this._context.sessionLog.logUserAction(navigateAction, tab, `await page.goto('${data.signal.url}');`, false);
+            this._context.sessionLog.logUserAction(navigateAction, tab, `await page.goto('${signal.url}');`, false);
     }
 }
 //# sourceMappingURL=context.js.map