appium-remote-debugger 12.2.10 → 13.0.0

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

@@ -3,7 +3,8 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.RpcClient = void 0;
+exports.RpcClient = exports.EMPTY_PAGE_DICTIONARY_ERROR = exports.NEW_APP_CONNECTED_ERROR = void 0;
+exports.toLockKey = toLockKey;
 const remote_messages_1 = require("./remote-messages");
 const asyncbox_1 = require("asyncbox");
 const logger_1 = __importDefault(require("../logger"));
@@ -12,7 +13,7 @@ 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 constants_1 = require("./constants");
+const async_lock_1 = __importDefault(require("async-lock"));
 const DATA_LOG_LENGTH = { length: 200 };
 const WAIT_FOR_TARGET_TIMEOUT_MS = 10000;
 const WAIT_FOR_TARGET_INTERVAL_MS = 100;
@@ -25,6 +26,8 @@ const NO_TARGET_PRESENT_YET_ERRORS = [
     `some arguments of method`,
     `missing target`,
 ];
+exports.NEW_APP_CONNECTED_ERROR = 'New application has connected';
+exports.EMPTY_PAGE_DICTIONARY_ERROR = 'Empty page dictionary received';
 /**
  * @param {boolean} isSafari
  * @param {string} platformVersion
@@ -63,7 +66,6 @@ class RpcClient {
         this._targets = {};
         this._targetSubscriptions = new node_events_1.EventEmitter();
         // start with a best guess for the protocol
-        this._shouldCheckForTarget = !!opts.shouldCheckForTarget;
         this.isTargetBased = platformVersion ? isTargetBased(isSafari, platformVersion) : true;
     }
     /**
@@ -76,23 +78,14 @@ class RpcClient {
      * @returns {boolean}
      */
     get needsTarget() {
-        return this.shouldCheckForTarget && this.isTargetBased;
+        return this.isTargetBased;
     }
     /**
-     * @returns {import('@appium/types').StringRecord}
+     * @returns {AppToTargetsMap}
      */
     get targets() {
         return this._targets;
     }
-    /**
-     * @returns {boolean}
-     */
-    get shouldCheckForTarget() {
-        return this._shouldCheckForTarget;
-    }
-    set shouldCheckForTarget(shouldCheckForTarget) {
-        this._shouldCheckForTarget = !!shouldCheckForTarget;
-    }
     /**
      * @returns {boolean}
      */
@@ -178,47 +171,51 @@ class RpcClient {
      *
      * @param {import('../types').AppIdKey} appIdKey
      * @param {import('../types').PageIdKey} pageIdKey
-     * @returns {Promise<void>}
+     * @returns {Promise<import('../types').TargetId | undefined>}
      */
     async waitForTarget(appIdKey, pageIdKey) {
         if (!this.needsTarget) {
             logger_1.default.debug(`Target-based communication is not needed, skipping wait for target`);
             return;
         }
-        const target = this.getTarget(appIdKey, pageIdKey);
+        let target = this.getTarget(appIdKey, pageIdKey);
         if (target) {
             logger_1.default.debug(`The target '${target}' for app '${appIdKey}' and page '${pageIdKey}' already exists, no need to wait`);
-            return;
+            return target;
         }
         // otherwise waiting is necessary to see what the target is
         try {
-            await (0, asyncbox_1.waitForCondition)(() => !lodash_1.default.isEmpty(this.getTarget(appIdKey, pageIdKey)), {
+            await (0, asyncbox_1.waitForCondition)(() => {
+                target = this.getTarget(appIdKey, pageIdKey);
+                return !lodash_1.default.isEmpty(target);
+            }, {
                 waitMs: WAIT_FOR_TARGET_TIMEOUT_MS,
                 intervalMs: WAIT_FOR_TARGET_INTERVAL_MS,
-                error: 'No targets found, unable to communicate with device',
             });
+            return target;
         }
         catch (err) {
             if (!err.message.includes('Condition unmet')) {
                 throw err;
             }
-            throw new Error('No targets found, unable to communicate with device');
+            throw new Error(`No targets could be matched for the app '${appIdKey}' and page '${pageIdKey}' after ` +
+                `${WAIT_FOR_TARGET_TIMEOUT_MS}ms. This is likely a bug.`);
         }
     }
     /**
      *
      * @param {string} command
      * @param {import('../types').RemoteCommandOpts} opts
-     * @param {boolean} [waitForResponse]
+     * @param {boolean} [waitForResponse=true]
      * @returns {Promise<any>}
      */
     async send(command, opts, waitForResponse = true) {
         const timer = new support_1.timing.Timer().start();
-        const { appIdKey, pageIdKey } = opts;
         try {
             return await this.sendToDevice(command, opts, waitForResponse);
         }
         catch (err) {
+            const { appIdKey, pageIdKey } = opts;
             const messageLc = (err.message || '').toLowerCase();
             if (messageLc.includes(NO_TARGET_SUPPORTED_ERROR)) {
                 logger_1.default.info('The target device does not support Target based communication. ' +
@@ -239,11 +236,13 @@ class RpcClient {
     }
     /**
      *
+     * @template {boolean} TWaitForResponse
      * @param {string} command
      * @param {import('../types').RemoteCommandOpts} opts
-     * @param {boolean} [waitForResponse]
-     * @returns {Promise<any>}
+     * @param {TWaitForResponse} [waitForResponse=true]
+     * @returns {Promise<TWaitForResponse extends true ? import('../types').RemoteCommandOpts : any>}
      */
+    // @ts-ignore Compiler issue
     async sendToDevice(command, opts, waitForResponse = true) {
         return await new bluebird_1.default(async (resolve, reject) => {
             // promise to be resolved whenever remote debugger
@@ -264,23 +263,39 @@ class RpcClient {
             }
             const appIdKey = opts.appIdKey;
             const pageIdKey = opts.pageIdKey;
-            const targetId = this.getTarget(appIdKey, pageIdKey);
+            const targetId = opts.targetId ?? this.getTarget(appIdKey, pageIdKey);
             // retrieve the correct command to send
+            /** @type {import('../types').RemoteCommandOpts} */
             const fullOpts = lodash_1.default.defaults({
                 connId: this.connId,
                 senderId: this.senderId,
                 targetId,
                 id: msgId,
             }, opts);
-            // @ts-ignore remoteMessages must be defined
-            const cmd = this.remoteMessages.getRemoteCommand(command, fullOpts);
-            if (cmd?.__argument?.WIRSocketDataKey) {
+            /** @type {import('../types').RawRemoteCommand} */
+            let cmd;
+            try {
+                // @ts-ignore remoteMessages must be defined
+                cmd = this.remoteMessages.getRemoteCommand(command, fullOpts);
+            }
+            catch (err) {
+                logger_1.default.error(err);
+                return reject(err);
+            }
+            /** @type {import('../types').RemoteCommand} */
+            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
+                // @ts-ignore We have asserted it's a plain object above
                 if (lodash_1.default.isNil(cmd.__argument.WIRSocketDataKey.id)) {
+                    // @ts-ignore We have already asserted it's a plain object above
                     cmd.__argument.WIRSocketDataKey.id = wrapperMsgId;
                 }
-                cmd.__argument.WIRSocketDataKey =
-                    Buffer.from(JSON.stringify(cmd.__argument.WIRSocketDataKey));
+                finalCommand.__argument.WIRSocketDataKey = Buffer.from(JSON.stringify(cmd.__argument.WIRSocketDataKey));
             }
             let messageHandled = true;
             if (!waitForResponse) {
@@ -292,7 +307,8 @@ class RpcClient {
                     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.default.error(`Received error from send that is not being waited for (id: ${msgId}): '${lodash_1.default.truncate(JSON.stringify(err), DATA_LOG_LENGTH)}'`);
+                        logger_1.default.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 directlty after send. On the off chance,
                         // though, it will alert of a protocol change.
@@ -308,10 +324,11 @@ class RpcClient {
                         return reject(err);
                     }
                     logger_1.default.debug(`Received response from send (id: ${msgId}): '${lodash_1.default.truncate(JSON.stringify(args), DATA_LOG_LENGTH)}'`);
+                    // @ts-ignore This is ok
                     resolve(args);
                 });
             }
-            else if (cmd?.__argument?.WIRSocketDataKey) {
+            else if (hasSocketData) {
                 // @ts-ignore messageHandler must be defined
                 this.messageHandler.once(msgId.toString(), function (err, value) {
                     if (err) {
@@ -332,11 +349,12 @@ class RpcClient {
                 ` (id: ${msgId}): '${command}'`;
             logger_1.default.debug(msg);
             try {
-                const res = await this.sendMessage(cmd);
+                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(res);
+                    // @ts-ignore This is ok
+                    resolve(fullOpts);
                 }
             }
             catch (err) {
@@ -368,61 +386,99 @@ class RpcClient {
     }
     /**
      *
-     * @param {Error?} err
-     * @param {string} app
-     * @param {Record<string, any>} targetInfo
-     * @returns {void}
+     * @param {Error | undefined} err
+     * @param {import('../types').AppIdKey} app
+     * @param {import('../types').TargetInfo} targetInfo
+     * @returns {Promise<void>}
      */
-    addTarget(err, app, targetInfo) {
+    async addTarget(err, app, targetInfo) {
         if (lodash_1.default.isNil(targetInfo?.targetId)) {
-            logger_1.default.warn(`Received 'Target.targetCreated' event for app '${app}' with no target. Skipping`);
+            logger_1.default.info(`Received 'Target.targetCreated' event for app '${app}' with no target. Skipping`);
+            return;
+        }
+        if (!this._pendingTargetNotification) {
+            logger_1.default.info(`Received 'Target.targetCreated' event for app '${app}' with no pending request: ${JSON.stringify(targetInfo)}`);
             return;
         }
-        if (lodash_1.default.isEmpty(this.pendingTargetNotification) && !targetInfo.isProvisional) {
-            logger_1.default.warn(`Received 'Target.targetCreated' event for app '${app}' with no pending request: ${JSON.stringify(targetInfo)}`);
+        const [appIdKey, pageIdKey] = this._pendingTargetNotification;
+        if (appIdKey !== app) {
+            logger_1.default.info(`Received 'Target.targetCreated' event for app '${app}' with no pending request: ${JSON.stringify(targetInfo)}`);
             return;
         }
         if (targetInfo.isProvisional) {
-            logger_1.default.debug(`Provisional target created for app '${app}', '${targetInfo.targetId}'. Ignoring until target update event`);
+            logger_1.default.debug(`Provisional target created for app '${appIdKey}' and page '${pageIdKey}': '${targetInfo.targetId}'`);
+            if (!targetInfo.isPaused) {
+                return;
+            }
+            logger_1.default.debug(`The target ${targetInfo.targetId}@${appIdKey} is paused`);
+            const appTargetsMap = this.targets[appIdKey];
+            if (appTargetsMap) {
+                await appTargetsMap.lock.acquire(toLockKey(appIdKey, pageIdKey), async () => {
+                    try {
+                        await this._initializePage(appIdKey, pageIdKey, targetInfo.targetId);
+                    }
+                    finally {
+                        await this._resumeTarget(appIdKey, pageIdKey, targetInfo.targetId);
+                    }
+                });
+            }
             return;
         }
-        // @ts-ignore this.pendingTargetNotification must be defined here
-        const [appIdKey, pageIdKey] = this.pendingTargetNotification;
         logger_1.default.debug(`Target created for app '${appIdKey}' and page '${pageIdKey}': ${JSON.stringify(targetInfo)}`);
         if (lodash_1.default.has(this.targets[appIdKey], pageIdKey)) {
             logger_1.default.debug(`There is already a target for this app and page ('${this.targets[appIdKey][pageIdKey]}'). This might cause problems`);
         }
-        this.targets[app] = this.targets[app] || {};
+        const lock = new async_lock_1.default();
+        this.targets[app] = this.targets[app] || { lock };
         this.targets[appIdKey][pageIdKey] = targetInfo.targetId;
+        await lock.acquire(toLockKey(appIdKey, pageIdKey), async () => {
+            try {
+                await this.send('Target.setPauseOnStart', {
+                    pauseOnStart: true,
+                    appIdKey,
+                    pageIdKey,
+                });
+            }
+            catch { }
+            try {
+                await this._initializePage(appIdKey, pageIdKey);
+            }
+            finally {
+                if (targetInfo.isPaused) {
+                    await this._resumeTarget(appIdKey, pageIdKey);
+                }
+            }
+        });
     }
     /**
      *
-     * @param {Error?} err
-     * @param {string} app
-     * @param {string} oldTargetId
-     * @param {string} newTargetId
-     * @returns {void}
+     * @param {Error | undefined} err
+     * @param {import('../types').AppIdKey} app
+     * @param {import('../types').ProvisionalTargetInfo} targetInfo
+     * @returns {Promise<void>}
      */
-    updateTarget(err, app, oldTargetId, newTargetId) {
+    async updateTarget(err, app, targetInfo) {
+        const { oldTargetId, newTargetId, } = targetInfo;
         logger_1.default.debug(`Target updated for app '${app}'. Old target: '${oldTargetId}', new target: '${newTargetId}'`);
-        if (!this.targets[app]) {
+        const appTargetsMap = this.targets[app];
+        if (!appTargetsMap) {
             logger_1.default.warn(`No existing target for app '${app}'. Not sure what to do`);
             return;
         }
         // save this, to be used if/when the existing target is destroyed
-        this.targets[app].provisional = {
+        appTargetsMap.provisional = {
             oldTargetId,
             newTargetId,
         };
     }
     /**
      *
-     * @param {Error?} err
-     * @param {string} app
-     * @param {Record<string, any>} targetInfo
-     * @returns {void}
+     * @param {Error | undefined} err
+     * @param {import('../types').AppIdKey} app
+     * @param {import('../types').TargetInfo} targetInfo
+     * @returns {Promise<void>}
      */
-    removeTarget(err, app, targetInfo) {
+    async removeTarget(err, app, targetInfo) {
         if (lodash_1.default.isNil(targetInfo?.targetId)) {
             logger_1.default.debug(`Received 'Target.targetDestroyed' event with no target. Skipping`);
             return;
@@ -433,30 +489,17 @@ class RpcClient {
             const { oldTargetId, newTargetId } = this.targets[app].provisional;
             delete this.targets[app].provisional;
             // we do not know the page, so go through and find the existing target
-            const targets = this.targets[app];
-            for (const [page, targetId] of lodash_1.default.toPairs(targets)) {
+            const appTargetsMap = this.targets[app];
+            for (const [page, targetId] of lodash_1.default.toPairs(appTargetsMap)) {
                 if (targetId === oldTargetId) {
-                    logger_1.default.debug(`Found provisional target for app '${app}'. Old target: '${oldTargetId}', new target: '${newTargetId}'. Updating`);
-                    targets[page] = newTargetId;
-                    const opts = { appIdKey: app, pageIdKey: parseInt(page, 10) };
-                    (async () => {
-                        if (this.fullPageInitialization) {
-                            await this.initializePageFull(opts.appIdKey, opts.pageIdKey);
-                        }
-                        else {
-                            await this.initializePage(opts.appIdKey, opts.pageIdKey);
-                        }
-                        this._targetSubscriptions.emit(constants_1.ON_TARGET_PROVISIONED_EVENT, {
-                            ...opts,
-                            oldTargetId,
-                            targetId: newTargetId,
-                        });
-                    })();
+                    logger_1.default.debug(`Found provisional target for app '${app}'. ` +
+                        `Old target: '${oldTargetId}', new target: '${newTargetId}'. Updating`);
+                    appTargetsMap[page] = newTargetId;
                     return;
                 }
             }
             logger_1.default.warn(`Provisional target for app '${app}' found, but no suitable existing target found. This may cause problems`);
-            logger_1.default.warn(`Old target: '${oldTargetId}', new target: '${newTargetId}'. Existing targets: ${JSON.stringify(targets)}`);
+            logger_1.default.warn(`Old target: '${oldTargetId}', new target: '${newTargetId}'. Existing targets: ${JSON.stringify(appTargetsMap)}`);
         }
         // if there is no waiting provisional target, just get rid of the existing one
         const targets = this.targets[app];
@@ -485,9 +528,7 @@ class RpcClient {
      * @returns {Promise<void>}
      */
     async selectPage(appIdKey, pageIdKey) {
-        /** @type {[import('../types').AppIdKey, import('../types').PageIdKey]} */
-        this.pendingTargetNotification = [appIdKey, pageIdKey];
-        this.shouldCheckForTarget = false;
+        this._pendingTargetNotification = [appIdKey, pageIdKey];
         // go through the steps that the Desktop Safari system
         // goes through to initialize the Web Inspector session
         const sendOpts = {
@@ -502,47 +543,15 @@ class RpcClient {
         }
         await this.send('setSenderKey', sendOpts);
         logger_1.default.debug('Sender key set');
+        if (!this.isTargetBased) {
+            await this._initializePage(appIdKey, pageIdKey);
+            return;
+        }
         if (this.isTargetBased && support_1.util.compareVersions(this.platformVersion, '<', MIN_PLATFORM_NO_TARGET_EXISTS)) {
             await this.send('Target.exists', sendOpts, false);
         }
-        this.shouldCheckForTarget = true;
         await this.waitForTarget(appIdKey, pageIdKey);
-        if (this.fullPageInitialization) {
-            await this.initializePageFull(appIdKey, pageIdKey);
-        }
-        else {
-            await this.initializePage(appIdKey, pageIdKey);
-        }
-    }
-    /**
-     * Perform the minimal initialization to get the Web Inspector working
-     * @param {import('../types').AppIdKey} appIdKey
-     * @param {import('../types').PageIdKey} pageIdKey
-     * @returns {Promise<void>}
-     */
-    async initializePage(appIdKey, pageIdKey) {
-        const sendOpts = {
-            appIdKey,
-            pageIdKey,
-        };
-        // The sequence of domains is important
-        for (const domain of [
-            'Inspector.enable',
-            'Page.enable',
-            'Runtime.enable',
-            'Network.enable',
-            'Heap.enable',
-            'Debugger.enable',
-            'Console.enable',
-            'Inspector.initialized',
-        ]) {
-            try {
-                await this.send(domain, sendOpts);
-            }
-            catch (err) {
-                logger_1.default.info(`Cannot enable domain '${domain}' during initialization: ${err.message}`);
-            }
-        }
+        await this.waitForPageInitialization(appIdKey, pageIdKey);
     }
     /**
      * Mimic every step that Desktop Safari Develop tools uses to initialize a
@@ -550,13 +559,38 @@ class RpcClient {
      *
      * @param {import('../types').AppIdKey} appIdKey
      * @param {import('../types').PageIdKey} pageIdKey
+     * @param {import('../types').TargetId} [targetId]
      * @returns {Promise<void>}
      */
-    async initializePageFull(appIdKey, pageIdKey) {
+    async _initializePage(appIdKey, pageIdKey, targetId) {
         const sendOpts = {
             appIdKey,
             pageIdKey,
+            targetId,
         };
+        logger_1.default.debug(`Initializing page '${pageIdKey}' for app '${appIdKey}'`);
+        if (!this.fullPageInitialization) {
+            // The sequence of domains is important
+            for (const domain of [
+                'Inspector.enable',
+                'Page.enable',
+                'Runtime.enable',
+                'Network.enable',
+                'Heap.enable',
+                'Debugger.enable',
+                'Console.enable',
+                'Inspector.initialized',
+            ]) {
+                try {
+                    await this.send(domain, sendOpts);
+                }
+                catch (err) {
+                    logger_1.default.info(`Cannot enable domain '${domain}' during initialization: ${err.message}`);
+                }
+            }
+            logger_1.default.debug(`Simple initialization of page '${pageIdKey}' for app '${appIdKey}' completed`);
+            return;
+        }
         // The sequence of commands here is important
         const domainsToOptsMap = {
             'Inspector.enable': sendOpts,
@@ -634,6 +668,7 @@ class RpcClient {
                 logger_1.default.info(`Cannot enable domain '${domain}' during full initialization: ${err.message}`);
             }
         }
+        logger_1.default.debug(`Full initialization of page '${pageIdKey}' for app '${appIdKey}' completed`);
     }
     /**
      *
@@ -658,7 +693,7 @@ class RpcClient {
                     logger_1.default.debug(`We were notified we might have connected to the wrong app. ` +
                         `Using id ${correctAppIdKey} instead of ${oldAppIdKey}`);
                 }
-                reject(new Error('New application has connected'));
+                reject(new Error(exports.NEW_APP_CONNECTED_ERROR));
             };
             this.messageHandler?.prependOnceListener('_rpc_applicationConnected:', onAppChange);
             // do the actual connecting to the app
@@ -668,7 +703,7 @@ class RpcClient {
                     // 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('Empty page dictionary received'));
+                        reject(new Error(exports.EMPTY_PAGE_DICTIONARY_ERROR));
                     }
                     else {
                         resolve([connectedAppIdKey, pageDict]);
@@ -711,8 +746,54 @@ class RpcClient {
         // { scriptId: '13', url: '', startLine: 0, startColumn: 0, endLine: 82, endColumn: 3 }
         logger_1.default.debug(`Script parsed: ${JSON.stringify(scriptInfo)}`);
     }
+    /**
+     *
+     * @param {import('../types').AppIdKey} appIdKey
+     * @param {import('../types').PageIdKey} pageIdKey
+     * @param {import('../types').TargetId} [targetId]
+     * @returns {Promise<void>}
+     */
+    async _resumeTarget(appIdKey, pageIdKey, targetId) {
+        try {
+            await this.send('Target.resume', {
+                appIdKey,
+                pageIdKey,
+                targetId,
+            });
+            logger_1.default.debug(`Successfully resumed the target ${targetId}@${appIdKey}`);
+        }
+        catch { }
+    }
+    /**
+     *
+     * @param {import('../types').AppIdKey} appIdKey
+     * @param {import('../types').PageIdKey} pageIdKey
+     */
+    async waitForPageInitialization(appIdKey, pageIdKey) {
+        const appTargetsMap = this.targets[appIdKey];
+        if (!appTargetsMap) {
+            throw new Error(`No targets found for app '${appIdKey}'`);
+        }
+        /** @type {AsyncLock | undefined}  */
+        const lock = appTargetsMap.lock;
+        if (lock?.isBusy()) {
+            const timer = new support_1.timing.Timer().start();
+            logger_1.default.debug(`Waiting until page ${pageIdKey}@${appIdKey} is fully initialized`);
+            await lock.acquire(toLockKey(appIdKey, pageIdKey), async () => await bluebird_1.default.delay(0));
+            logger_1.default.debug(`The initalization of the page ${pageIdKey}@${appIdKey} took ${timer.getDuration().asMilliSeconds}ms`);
+        }
+    }
 }
 exports.RpcClient = RpcClient;
+/**
+ *
+ * @param {import('../types').AppIdKey} appIdKey
+ * @param {import('../types').PageIdKey} pageIdKey
+ * @returns {string}
+ */
+function toLockKey(appIdKey, pageIdKey) {
+    return `${appIdKey}-${pageIdKey}`;
+}
 exports.default = RpcClient;
 /**
  * @typedef {Object} RpcClientOptions
@@ -725,6 +806,12 @@ exports.default = RpcClient;
  * @property {number} [socketChunkSize]
  * @property {boolean} [fullPageInitialization=false]
  * @property {string} [udid]
- * @property {boolean} [shouldCheckForTarget]
  */
+/**
+ * @typedef {{[key: import('../types').PageIdKey]: import('../types').TargetId}} PageDict
+ */
+/**
+ * @typedef {PageDict & {provisional?: import('../types').ProvisionalTargetInfo, lock: import('async-lock').default}} PagesToTargets
+ * @typedef {{[key: import('../types').AppIdKey]: PagesToTargets}} AppToTargetsMap
+ */ 
 //# sourceMappingURL=rpc-client.js.map