appium-remote-debugger 15.7.3 → 15.8.1

package/build/lib/rpc/rpc-client.js

@@ -7,14 +7,12 @@ exports.RpcClient = exports.EMPTY_PAGE_DICTIONARY_ERROR = exports.NEW_APP_CONNEC
 const remote_messages_1 = require("./remote-messages");
 const asyncbox_1 = require("asyncbox");
 const logger_1 = require("../logger");
-const lodash_1 = __importDefault(require("lodash"));
-const bluebird_1 = __importDefault(require("bluebird"));
 const rpc_message_handler_1 = __importDefault(require("./rpc-message-handler"));
 const support_1 = require("@appium/support");
 const node_events_1 = require("node:events");
 const async_lock_1 = __importDefault(require("async-lock"));
 const utils_1 = require("../utils");
-const DATA_LOG_LENGTH = { length: 200 };
+const DATA_LOG_LENGTH = 200;
 const MIN_WAIT_FOR_TARGET_TIMEOUT_MS = 30000;
 const DEFAULT_TARGET_CREATION_TIMEOUT_MS = 3 * 60 * 1000; // 3 minutes
 const WAIT_FOR_TARGET_INTERVAL_MS = 100;
@@ -117,14 +115,6 @@ class RpcClient {
     get isConnected() {
         return this.connected;
     }
-    /**
-     * Sets the connection status.
-     *
-     * @param connected - The connection status to set.
-     */
-    set isConnected(connected) {
-        this.connected = !!connected;
-    }
     /**
      * Gets the event emitter for target subscriptions.
      *
@@ -133,6 +123,14 @@ class RpcClient {
     get targetSubscriptions() {
         return this._targetSubscriptions;
     }
+    /**
+     * Sets the connection status.
+     *
+     * @param connected - The connection status to set.
+     */
+    set isConnected(connected) {
+        this.connected = !!connected;
+    }
     /**
      * Registers an event listener on the message handler.
      *
@@ -239,7 +237,7 @@ class RpcClient {
         try {
             await (0, asyncbox_1.waitForCondition)(() => {
                 target = this.getTarget(appIdKey, pageIdKey);
-                return !lodash_1.default.isEmpty(target);
+                return !(0, utils_1.isEmpty)(target);
             }, {
                 waitMs,
                 intervalMs: WAIT_FOR_TARGET_INTERVAL_MS,
@@ -298,108 +296,112 @@ class RpcClient {
      *          - If false: resolves to the full options object
      */
     async sendToDevice(command, opts, waitForResponse = true) {
-        return await new bluebird_1.default(async (resolve, reject) => {
-            // promise to be resolved whenever remote debugger
-            // replies to our request
-            // keep track of the messages coming and going using a simple sequential id
-            const msgId = this.msgId++;
-            // for target-base communication, everything is wrapped up
-            const wrapperMsgId = this.msgId++;
-            // acknowledge wrapper message
-            this.messageHandler.on(wrapperMsgId.toString(), function (err) {
-                if (err) {
-                    reject(err);
-                }
-            });
-            const appIdKey = opts.appIdKey;
-            const pageIdKey = opts.pageIdKey;
-            const targetId = opts.targetId ?? this.getTarget(appIdKey, pageIdKey);
-            // retrieve the correct command to send
-            const fullOpts = lodash_1.default.defaults({
-                connId: this.connId,
-                senderId: this.senderId,
-                targetId,
-                id: msgId.toString(),
-            }, opts);
-            let cmd;
-            try {
-                cmd = this.remoteMessages.getRemoteCommand(command, fullOpts);
-            }
-            catch (err) {
-                logger_1.log.error(err);
-                return reject(err);
-            }
-            const finalCommand = {
-                __argument: lodash_1.default.omit(cmd.__argument, ['WIRSocketDataKey']),
-                __selector: cmd.__selector,
-            };
-            const hasSocketData = lodash_1.default.isPlainObject(cmd.__argument?.WIRSocketDataKey);
-            if (hasSocketData) {
-                // make sure the message being sent has all the information that is needed
-                const socketData = cmd.__argument.WIRSocketDataKey;
-                if (!lodash_1.default.isInteger(socketData.id)) {
-                    // ! This must be a number
-                    socketData.id = wrapperMsgId;
-                }
-                finalCommand.__argument.WIRSocketDataKey = Buffer.from(JSON.stringify(socketData));
-            }
-            let messageHandled = true;
-            if (!waitForResponse) {
-                // the promise will be resolved as soon as the socket has been sent
-                messageHandled = false;
-                // do not log receipts
-                this.messageHandler.once(msgId.toString(), (err) => {
+        return await new Promise((resolve, reject) => {
+            void (async () => {
+                // promise to be resolved whenever remote debugger
+                // replies to our request
+                // keep track of the messages coming and going using a simple sequential id
+                const msgId = this.msgId++;
+                // for target-base communication, everything is wrapped up
+                const wrapperMsgId = this.msgId++;
+                // acknowledge wrapper message
+                this.messageHandler.on(wrapperMsgId.toString(), function (err) {
                     if (err) {
-                        // we are not waiting for this, and if it errors it is most likely
-                        // a protocol change. Log and check during testing
-                        logger_1.log.error(`Received error from send that is not being waited for (id: ${msgId}): ` +
-                            lodash_1.default.truncate(JSON.stringify(err), DATA_LOG_LENGTH));
-                        // reject, though it is very rare that this will be triggered, since
-                        // the promise is resolved directly after send. On the off chance,
-                        // though, it will alert of a protocol change.
                         reject(err);
                     }
                 });
-            }
-            else if (this.messageHandler.listenerCount(cmd.__selector)) {
-                this.messageHandler.prependOnceListener(cmd.__selector, (err, ...args) => {
-                    if (err) {
-                        return reject(err);
+                const appIdKey = opts.appIdKey;
+                const pageIdKey = opts.pageIdKey;
+                const targetId = opts.targetId ?? this.getTarget(appIdKey, pageIdKey);
+                // retrieve the correct command to send
+                const fullOpts = (0, utils_1.defaults)({
+                    connId: this.connId,
+                    senderId: this.senderId,
+                    targetId,
+                    id: msgId.toString(),
+                }, opts);
+                let cmd;
+                try {
+                    cmd = this.remoteMessages.getRemoteCommand(command, fullOpts);
+                }
+                catch (err) {
+                    logger_1.log.error(err);
+                    return reject(err);
+                }
+                const finalCommandArgs = { ...cmd.__argument };
+                delete finalCommandArgs.WIRSocketDataKey;
+                const finalCommand = {
+                    __argument: finalCommandArgs,
+                    __selector: cmd.__selector,
+                };
+                const hasSocketData = (0, utils_1.isPlainObject)(cmd.__argument?.WIRSocketDataKey);
+                if (hasSocketData) {
+                    // make sure the message being sent has all the information that is needed
+                    const socketData = cmd.__argument.WIRSocketDataKey;
+                    if (!Number.isInteger(socketData.id)) {
+                        // ! This must be a number
+                        socketData.id = wrapperMsgId;
                     }
-                    logger_1.log.debug(`Received response from send (id: ${msgId}): '${lodash_1.default.truncate(JSON.stringify(args), DATA_LOG_LENGTH)}'`);
-                    resolve(args);
-                });
-            }
-            else if (hasSocketData) {
-                this.messageHandler.once(msgId.toString(), (err, value) => {
-                    if (err) {
-                        return reject(new Error(`Remote debugger error with code '${err.code}': ${err.message}`));
+                    finalCommand.__argument.WIRSocketDataKey = Buffer.from(JSON.stringify(socketData));
+                }
+                let messageHandled = true;
+                if (!waitForResponse) {
+                    // the promise will be resolved as soon as the socket has been sent
+                    messageHandled = false;
+                    // do not log receipts
+                    this.messageHandler.once(msgId.toString(), (err) => {
+                        if (err) {
+                            // we are not waiting for this, and if it errors it is most likely
+                            // a protocol change. Log and check during testing
+                            logger_1.log.error(`Received error from send that is not being waited for (id: ${msgId}): ` +
+                                (0, utils_1.truncateString)(JSON.stringify(err), DATA_LOG_LENGTH));
+                            // reject, though it is very rare that this will be triggered, since
+                            // the promise is resolved directly after send. On the off chance,
+                            // though, it will alert of a protocol change.
+                            reject(err);
+                        }
+                    });
+                }
+                else if (this.messageHandler.listenerCount(cmd.__selector)) {
+                    this.messageHandler.prependOnceListener(cmd.__selector, (err, ...args) => {
+                        if (err) {
+                            return reject(err);
+                        }
+                        logger_1.log.debug(`Received response from send (id: ${msgId}): '${(0, utils_1.truncateString)(JSON.stringify(args), DATA_LOG_LENGTH)}'`);
+                        resolve(args);
+                    });
+                }
+                else if (hasSocketData) {
+                    this.messageHandler.once(msgId.toString(), (err, value) => {
+                        if (err) {
+                            return reject(new Error(`Remote debugger error with code '${err.code}': ${err.message}`));
+                        }
+                        logger_1.log.debug(`Received data response from send (id: ${msgId}): '${(0, utils_1.truncateString)(JSON.stringify(value), DATA_LOG_LENGTH)}'`);
+                        resolve(value);
+                    });
+                }
+                else {
+                    // nothing else is handling things, so just resolve when the message is sent
+                    messageHandled = false;
+                }
+                const msg = `Sending '${cmd.__selector}' message` +
+                    (appIdKey ? ` to app '${appIdKey}'` : '') +
+                    (pageIdKey ? `, page '${pageIdKey}'` : '') +
+                    (targetId ? `, target '${targetId}'` : '') +
+                    ` (id: ${msgId}): '${command}'`;
+                logger_1.log.debug(msg);
+                try {
+                    await this.sendMessage(finalCommand);
+                    if (!messageHandled) {
+                        // There are no handlers waiting for a response before resolving,
+                        // and no errors sending the message over the socket, so resolve
+                        resolve(fullOpts);
                     }
-                    logger_1.log.debug(`Received data response from send (id: ${msgId}): '${lodash_1.default.truncate(JSON.stringify(value), DATA_LOG_LENGTH)}'`);
-                    resolve(value);
-                });
-            }
-            else {
-                // nothing else is handling things, so just resolve when the message is sent
-                messageHandled = false;
-            }
-            const msg = `Sending '${cmd.__selector}' message` +
-                (appIdKey ? ` to app '${appIdKey}'` : '') +
-                (pageIdKey ? `, page '${pageIdKey}'` : '') +
-                (targetId ? `, target '${targetId}'` : '') +
-                ` (id: ${msgId}): '${command}'`;
-            logger_1.log.debug(msg);
-            try {
-                await this.sendMessage(finalCommand);
-                if (!messageHandled) {
-                    // There are no handlers waiting for a response before resolving,
-                    // and no errors sending the message over the socket, so resolve
-                    resolve(fullOpts);
                 }
-            }
-            catch (err) {
-                return reject(err);
-            }
+                catch (err) {
+                    return reject(err);
+                }
+            })().catch(reject);
         });
     }
     /**
@@ -445,7 +447,7 @@ class RpcClient {
      * @param targetInfo - Information about the created target.
      */
     async addTarget(err, app, targetInfo) {
-        if (lodash_1.default.isNil(targetInfo?.targetId)) {
+        if (targetInfo?.targetId == null) {
             logger_1.log.info(`Received 'Target.targetCreated' event for app '${app}' with no target. Skipping`);
             return;
         }
@@ -454,7 +456,7 @@ class RpcClient {
             return;
         }
         const { appIdKey, pageIdKey, pageReadinessDetector } = pendingPageTargetDetails;
-        if (!lodash_1.default.isPlainObject(this.targets[appIdKey])) {
+        if (!(0, utils_1.isPlainObject)(this.targets[appIdKey])) {
             this.targets[appIdKey] = {
                 lock: new async_lock_1.default({ maxOccupationTime: this._targetCreationTimeoutMs }),
             };
@@ -503,7 +505,7 @@ class RpcClient {
             return;
         }
         logger_1.log.debug(`Target created for app '${appIdKey}' and page '${pageIdKey}': ${JSON.stringify(targetInfo)}`);
-        if (lodash_1.default.has(this.targets[appIdKey], pageIdKey)) {
+        if (Object.hasOwn(this.targets[appIdKey], pageIdKey)) {
             const existingTarget = this.targets[appIdKey][pageIdKey];
             logger_1.log.debug(`There is already a target for this app and page ('${existingTarget}'). ` +
                 `This might cause problems`);
@@ -580,7 +582,7 @@ class RpcClient {
      * @param targetInfo - Information about the destroyed target.
      */
     async removeTarget(err, app, targetInfo) {
-        if (lodash_1.default.isNil(targetInfo?.targetId)) {
+        if (targetInfo?.targetId == null) {
             logger_1.log.debug(`Received 'Target.targetDestroyed' event with no target. Skipping`);
             return;
         }
@@ -591,7 +593,7 @@ class RpcClient {
             delete this.targets[app].provisional;
             // we do not know the page, so go through and find the existing target
             const appTargetsMap = this.targets[app];
-            for (const [page, targetId] of lodash_1.default.toPairs(appTargetsMap)) {
+            for (const [page, targetId] of Object.entries(appTargetsMap)) {
                 if (targetId === oldTargetId) {
                     logger_1.log.debug(`Found provisional target for app '${app}'. ` +
                         `Old target: '${oldTargetId}', new target: '${newTargetId}'. Updating`);
@@ -604,7 +606,7 @@ class RpcClient {
         }
         // if there is no waiting provisional target, just get rid of the existing one
         const targets = this.targets[app];
-        for (const [page, targetId] of lodash_1.default.toPairs(targets)) {
+        for (const [page, targetId] of Object.entries(targets)) {
             if (targetId === targetInfo.targetId) {
                 delete targets[page];
                 return;
@@ -660,7 +662,7 @@ class RpcClient {
                 }
                 await this.send('setSenderKey', sendOpts);
             };
-            await bluebird_1.default.resolve(setupWebview()).timeout(timeoutMs, `Cannot set up page '${pageIdKey}' for app '${appIdKey}' within ${timeoutMs}ms`);
+            await (0, utils_1.withTimeout)(setupWebview(), timeoutMs, `Cannot set up page '${pageIdKey}' for app '${appIdKey}' within ${timeoutMs}ms`);
             const msLeft = Math.max(timeoutMs - Math.trunc(timer.getDuration().asMilliSeconds), 1000);
             logger_1.log.debug(`Waiting up to ${msLeft}ms for page '${pageIdKey}' of app '${appIdKey}' to be selected`);
             await new Promise((resolve) => {
@@ -686,6 +688,113 @@ class RpcClient {
             });
         });
     }
+    /**
+     * Connects to a specific application and returns its page dictionary.
+     *
+     * @param appIdKey - The application identifier key to connect to.
+     * @returns A promise that resolves to a tuple containing the connected app ID key
+     *          and the page dictionary.
+     * @throws Error if a new application connects during the process or if the page
+     *               dictionary is empty.
+     */
+    async selectApp(appIdKey) {
+        return await new Promise((resolve, reject) => {
+            // local callback, temporarily added as callback to
+            // `_rpc_applicationConnected:` remote debugger response
+            // to handle the initial connection
+            const onAppChange = (err, dict) => {
+                if (err) {
+                    return reject(err);
+                }
+                // from the dictionary returned, get the ids
+                const oldAppIdKey = dict.WIRHostApplicationIdentifierKey;
+                const correctAppIdKey = dict.WIRApplicationIdentifierKey;
+                // if this is a report of a proxy redirect from the remote debugger
+                // we want to update our dictionary and get a new app id
+                if (oldAppIdKey && correctAppIdKey !== oldAppIdKey) {
+                    logger_1.log.debug(`We were notified we might have connected to the wrong app. ` +
+                        `Using id ${correctAppIdKey} instead of ${oldAppIdKey}`);
+                }
+                reject(new Error(exports.NEW_APP_CONNECTED_ERROR));
+            };
+            this.messageHandler.prependOnceListener('_rpc_applicationConnected:', onAppChange);
+            // do the actual connecting to the app
+            void (async () => {
+                try {
+                    const [connectedAppIdKey, pageDict] = await this.send('connectToApp', { appIdKey });
+                    // sometimes the connect logic happens, but with an empty dictionary
+                    // which leads to the remote debugger getting disconnected, and into a loop
+                    if ((0, utils_1.isEmpty)(pageDict)) {
+                        reject(new Error(exports.EMPTY_PAGE_DICTIONARY_ERROR));
+                    }
+                    else {
+                        resolve([connectedAppIdKey, pageDict]);
+                    }
+                }
+                catch (err) {
+                    logger_1.log.warn(`Unable to connect to the app: ${err.message}`);
+                    reject(err);
+                }
+                finally {
+                    this.messageHandler.off('_rpc_applicationConnected:', onAppChange);
+                }
+            })();
+        });
+    }
+    /**
+     * Handles execution context creation events by storing the context ID.
+     *
+     * @param err - Error if one occurred, undefined otherwise.
+     * @param context - The execution context information.
+     */
+    onExecutionContextCreated(err, context) {
+        // { id: 2, isPageContext: true, name: '', frameId: '0.1' }
+        // right now we have no way to map contexts to apps/pages
+        // so just store
+        this.contexts.push(context.id);
+    }
+    /**
+     * Handles garbage collection events by logging them.
+     * Garbage collection can affect operation timing.
+     */
+    onGarbageCollected() {
+        // just want to log that this is happening, as it can affect operation
+        logger_1.log.debug(`Web Inspector garbage collected`);
+    }
+    /**
+     * Handles script parsing events by logging script information.
+     *
+     * @param err - Error if one occurred, undefined otherwise.
+     * @param scriptInfo - Information about the parsed script.
+     */
+    onScriptParsed(err, scriptInfo) {
+        // { scriptId: '13', url: '', startLine: 0, startColumn: 0, endLine: 82, endColumn: 3 }
+        logger_1.log.debug(`Script parsed: ${JSON.stringify(scriptInfo)}`);
+    }
+    /**
+     * Waits for a page to be initialized by acquiring locks on both the page
+     * target lock and the page selection lock.
+     *
+     * @param appIdKey - The application identifier key.
+     * @param pageIdKey - The page identifier key.
+     * @throws Error if no targets are found for the application.
+     */
+    async waitForPage(appIdKey, pageIdKey) {
+        const appTargetsMap = this.targets[appIdKey];
+        if (!appTargetsMap) {
+            throw new Error(`No targets found for app '${appIdKey}'`);
+        }
+        const lock = appTargetsMap.lock;
+        const timer = new support_1.timing.Timer().start();
+        await Promise.all([
+            lock.acquire(pageIdKey, async () => await (0, utils_1.delay)(0)),
+            this._pageSelectionLock.acquire(toPageSelectionKey(appIdKey, pageIdKey), async () => await (0, utils_1.delay)(0)),
+        ]);
+        const durationMs = timer.getDuration().asMilliSeconds;
+        if (durationMs > 10) {
+            logger_1.log.debug(`Waited ${durationMs}ms until the page ${pageIdKey}@${appIdKey} is initialized`);
+        }
+    }
     /**
      * Initializes a page by enabling various Web Inspector domains.
      * Can perform either simple or full initialization based on configuration.
@@ -818,89 +927,6 @@ class RpcClient {
             `in ${timer.getDuration().asMilliSeconds}ms`);
         return true;
     }
-    /**
-     * Connects to a specific application and returns its page dictionary.
-     *
-     * @param appIdKey - The application identifier key to connect to.
-     * @returns A promise that resolves to a tuple containing the connected app ID key
-     *          and the page dictionary.
-     * @throws Error if a new application connects during the process or if the page
-     *               dictionary is empty.
-     */
-    async selectApp(appIdKey) {
-        return await new bluebird_1.default((resolve, reject) => {
-            // local callback, temporarily added as callback to
-            // `_rpc_applicationConnected:` remote debugger response
-            // to handle the initial connection
-            const onAppChange = (err, dict) => {
-                if (err) {
-                    return reject(err);
-                }
-                // from the dictionary returned, get the ids
-                const oldAppIdKey = dict.WIRHostApplicationIdentifierKey;
-                const correctAppIdKey = dict.WIRApplicationIdentifierKey;
-                // if this is a report of a proxy redirect from the remote debugger
-                // we want to update our dictionary and get a new app id
-                if (oldAppIdKey && correctAppIdKey !== oldAppIdKey) {
-                    logger_1.log.debug(`We were notified we might have connected to the wrong app. ` +
-                        `Using id ${correctAppIdKey} instead of ${oldAppIdKey}`);
-                }
-                reject(new Error(exports.NEW_APP_CONNECTED_ERROR));
-            };
-            this.messageHandler.prependOnceListener('_rpc_applicationConnected:', onAppChange);
-            // do the actual connecting to the app
-            (async () => {
-                try {
-                    const [connectedAppIdKey, pageDict] = await this.send('connectToApp', { appIdKey });
-                    // sometimes the connect logic happens, but with an empty dictionary
-                    // which leads to the remote debugger getting disconnected, and into a loop
-                    if (lodash_1.default.isEmpty(pageDict)) {
-                        reject(new Error(exports.EMPTY_PAGE_DICTIONARY_ERROR));
-                    }
-                    else {
-                        resolve([connectedAppIdKey, pageDict]);
-                    }
-                }
-                catch (err) {
-                    logger_1.log.warn(`Unable to connect to the app: ${err.message}`);
-                    reject(err);
-                }
-                finally {
-                    this.messageHandler.off('_rpc_applicationConnected:', onAppChange);
-                }
-            })();
-        });
-    }
-    /**
-     * Handles execution context creation events by storing the context ID.
-     *
-     * @param err - Error if one occurred, undefined otherwise.
-     * @param context - The execution context information.
-     */
-    onExecutionContextCreated(err, context) {
-        // { id: 2, isPageContext: true, name: '', frameId: '0.1' }
-        // right now we have no way to map contexts to apps/pages
-        // so just store
-        this.contexts.push(context.id);
-    }
-    /**
-     * Handles garbage collection events by logging them.
-     * Garbage collection can affect operation timing.
-     */
-    onGarbageCollected() {
-        // just want to log that this is happening, as it can affect operation
-        logger_1.log.debug(`Web Inspector garbage collected`);
-    }
-    /**
-     * Handles script parsing events by logging script information.
-     *
-     * @param err - Error if one occurred, undefined otherwise.
-     * @param scriptInfo - Information about the parsed script.
-     */
-    onScriptParsed(err, scriptInfo) {
-        // { scriptId: '13', url: '', startLine: 0, startColumn: 0, endLine: 82, endColumn: 3 }
-        logger_1.log.debug(`Script parsed: ${JSON.stringify(scriptInfo)}`);
-    }
     /**
      * Resumes a paused target.
      *
@@ -940,13 +966,13 @@ class RpcClient {
             let readyState;
             try {
                 const commandTimeoutMs = Math.max(100, Math.trunc((pageReadinessDetector.timeoutMs - timer.getDuration().asMilliSeconds) * 0.8));
-                const rawResult = await bluebird_1.default.resolve(this.send('Runtime.evaluate', {
+                const rawResult = await (0, utils_1.withTimeout)(this.send('Runtime.evaluate', {
                     expression: 'document.readyState;',
                     returnByValue: true,
                     appIdKey,
                     pageIdKey,
                     targetId,
-                })).timeout(commandTimeoutMs);
+                }), commandTimeoutMs);
                 readyState = (0, utils_1.convertJavascriptEvaluationResult)(rawResult);
             }
             catch (e) {
@@ -958,35 +984,11 @@ class RpcClient {
                     `${timer.getDuration().asMilliSeconds}ms`);
                 return;
             }
-            await bluebird_1.default.delay(100);
+            await (0, utils_1.delay)(100);
         }
         logger_1.log.warn(`Page '${pageIdKey}' for app '${appIdKey}' is not ready after ` +
             `${timer.getDuration().asMilliSeconds}ms. Continuing anyway`);
     }
-    /**
-     * Waits for a page to be initialized by acquiring locks on both the page
-     * target lock and the page selection lock.
-     *
-     * @param appIdKey - The application identifier key.
-     * @param pageIdKey - The page identifier key.
-     * @throws Error if no targets are found for the application.
-     */
-    async waitForPage(appIdKey, pageIdKey) {
-        const appTargetsMap = this.targets[appIdKey];
-        if (!appTargetsMap) {
-            throw new Error(`No targets found for app '${appIdKey}'`);
-        }
-        const lock = appTargetsMap.lock;
-        const timer = new support_1.timing.Timer().start();
-        await Promise.all([
-            lock.acquire(pageIdKey, async () => await bluebird_1.default.delay(0)),
-            this._pageSelectionLock.acquire(toPageSelectionKey(appIdKey, pageIdKey), async () => await bluebird_1.default.delay(0)),
-        ]);
-        const durationMs = timer.getDuration().asMilliSeconds;
-        if (durationMs > 10) {
-            logger_1.log.debug(`Waited ${durationMs}ms until the page ${pageIdKey}@${appIdKey} is initialized`);
-        }
-    }
     /**
      * Gets the pending target details if there is a pending request for the given app.
      * Filters out non-page target types (e.g., 'frame').