@modelprofile.com/browser-runtime 5.2.1 → 5.4.0

package/ts/classes.runtime.ts

@@ -105,6 +105,7 @@ interface INormalizedRuntimeOptions {
   frameAcknowledgementTimeoutMs: number;
   screencast: INormalizedScreencastOptions;
   video: Required<plugins.smartpuppeteer.ILiveVideoOptions>;
+  devTools: boolean;
   egress: NonNullable<IBrowserRuntimeOptions['egress']>;
   ownership?: IBrowserRuntimeTestingOptions['ownership'];
   beforeLeasePublication?: IBrowserRuntimeTestingOptions['beforeLeasePublication'];
@@ -144,10 +145,25 @@ interface ILeaseRecord {
   videoPeerId: string;
   videoPeerMayExist: boolean;
   frameCaptureUsed: boolean;
+  devTools?: IDevToolsRecord;
   heldKeys: Map<string, plugins.smartpuppeteer.ILiveBrowserKeyInput>;
   heldButtons: Map<string, plugins.smartpuppeteer.ILiveBrowserMouseInput>;
 }
 
+interface IDevToolsRecord {
+  authority: TBrowserRuntimeLeaseAuthority;
+  session: ILiveBrowserSessionLike;
+  controller: AbortController;
+  connection?: plugins.smartpuppeteer.ILiveBrowserDevToolsConnection;
+  opening?: Promise<plugins.smartpuppeteer.ILiveBrowserDevToolsConnection>;
+  closePromise?: Promise<void>;
+  pending: Set<Promise<void>>;
+  commands: number;
+  interrupts: number;
+  closed: boolean;
+  removeAbortListener(): void;
+}
+
 export interface IBrowserRuntimeLeaseRenewalOptions {
   signal?: AbortSignal;
   /** Lifetime from successful reauthorization; defaults to the runtime capability lifetime. */
@@ -246,7 +262,9 @@ interface IResourceSlot {
   profileDirectory?: string;
   unsubscribeSession?: () => void;
   leases: Map<string, ILeaseRecord>;
-  operation?: IOperationRecord;
+  operations: Set<IOperationRecord>;
+  activeQueuedOperations: Set<IQueuedOperationRecord>;
+  inputCleanup?: { session: ILiveBrowserSessionLike; incarnationGeneration: number; promise: Promise<void> };
   operationQueue: IQueuedOperationRecord[];
   operationSchedulerRunning: boolean;
   frameSubscriptions: Map<string, IFrameSubscriptionRecord>;
@@ -318,6 +336,9 @@ export class BrowserRuntime {
     if (options.beforeOperation !== undefined && typeof options.beforeOperation !== 'function') {
       throw new BrowserRuntimeError('INVALID_INPUT', 'beforeOperation must be a function');
     }
+    if (options.devTools !== undefined && typeof options.devTools !== 'boolean') {
+      throw new BrowserRuntimeError('INVALID_INPUT', 'devTools must be a boolean');
+    }
     const testingOptions = browserRuntimeTesting in options
       && options[browserRuntimeTesting] === true
       ? options as IBrowserRuntimeTestingOptions
@@ -570,6 +591,7 @@ export class BrowserRuntime {
       ),
       screencast,
       video: plugins.smartpuppeteer.normalizeLiveVideoOptions(options.video ?? {}),
+      devTools: options.devTools ?? false,
       egress: options.egress ?? {},
       ownership: testingOptions?.ownership,
       beforeLeasePublication: testingOptions?.beforeLeasePublication,
@@ -723,6 +745,8 @@ export class BrowserRuntime {
       frameSubscriptions: new Map(),
       highestFrameSequence: 0,
       producerAcknowledgements: new Set(),
+      operations: new Set(),
+      activeQueuedOperations: new Set(),
       operationQueue: [],
       operationSchedulerRunning: false,
       lifecycleTail: Promise.resolve(),
@@ -1374,6 +1398,148 @@ export class BrowserRuntime {
     });
   }
 
+  /** @internal */
+  public async leaseOpenDevTools(lease: ILeaseRecord, options: plugins.smartpuppeteer.ILiveBrowserDevToolsOptions,
+    operationOptions: IBrowserRuntimeOperationOptions = {}): Promise<plugins.smartpuppeteer.ILiveBrowserDevToolsConnection> {
+    this.requireHuman(lease);
+    if (!this.options.devTools) throw new BrowserRuntimeError('CAPABILITY_INVALID', 'DevTools is not enabled.');
+    if (!options || typeof options.onMessage !== 'function' || typeof options.onClose !== 'function') {
+      throw new BrowserRuntimeError('INVALID_INPUT');
+    }
+    const tabId = validateBoundedString(options.tabId, 'tabId', 1, 128);
+    let created: IDevToolsRecord | undefined;
+    try {
+      return await this.runOperation(lease, 'openDevTools', 'devtools', operationOptions, async (signal, session) => {
+        if (!session.openDevTools) throw new BrowserRuntimeError('CAPABILITY_INVALID', 'The browser adapter does not support DevTools.');
+        if (lease.devTools) await this.closeLeaseDevTools(lease, lease.devTools);
+        const controller = new AbortController();
+        const record: IDevToolsRecord = {
+          authority: this.createLeaseAuthority(lease), session, controller,
+          pending: new Set(), commands: 0, interrupts: 0, closed: false,
+          removeAbortListener: () => lease.controller.signal.removeEventListener('abort', abort),
+        };
+        const abort = (): void => { this.trackCleanup(this.closeLeaseDevTools(lease, record)); };
+        lease.controller.signal.addEventListener('abort', abort, { once: true });
+        created = record;
+        lease.devTools = record;
+        record.opening = session.openDevTools({ tabId,
+          onMessage: async message => {
+            this.requireDevToolsAuthority(lease, record);
+            await options.onMessage(message);
+            this.requireDevToolsAuthority(lease, record);
+          },
+          onClose: reason => {
+            record.closed = true;
+            controller.abort(new BrowserRuntimeError('ABORTED'));
+            record.removeAbortListener();
+            options.onClose(reason);
+          },
+        }, { signal });
+        const connection = await record.opening;
+        record.connection = connection;
+        try {
+          signal.throwIfAborted();
+          this.requireDevToolsAuthority(lease, record);
+        } catch (error) { await this.closeLeaseDevTools(lease, record); throw error; }
+        return {
+          tabId: connection.tabId,
+          browserVersion: connection.browserVersion,
+          send: message => this.sendLeaseDevTools(lease, record, message),
+          close: () => this.closeLeaseDevTools(lease, record),
+        };
+      });
+    } catch (error) {
+      if (created) await this.closeLeaseDevTools(lease, created);
+      throw error;
+    }
+  }
+
+  private requireDevToolsAuthority(lease: ILeaseRecord, record: IDevToolsRecord): void {
+    this.requireHuman(lease);
+    if (record.closed || record.controller.signal.aborted || lease.devTools !== record
+      || lease.slot.session !== record.session || !this.isLeaseAuthorityCurrent(lease, record.authority)) {
+      throw new BrowserRuntimeError('CAPABILITY_REVOKED');
+    }
+  }
+
+  private async sendLeaseDevTools(lease: ILeaseRecord, record: IDevToolsRecord, message: string): Promise<void> {
+    this.requireDevToolsAuthority(lease, record);
+    const limits = plugins.smartpuppeteer.liveBrowserDevToolsLimits;
+    if (typeof message !== 'string' || plugins.Buffer.byteLength(message) > limits.commandBytes) {
+      throw new BrowserRuntimeError('INVALID_INPUT');
+    }
+    let command: { method?: unknown };
+    try { command = JSON.parse(message); } catch { throw new BrowserRuntimeError('INVALID_INPUT'); }
+    if (!command || typeof command.method !== 'string' || !/^[A-Za-z]+\.[A-Za-z]+$/.test(command.method)) {
+      throw new BrowserRuntimeError('INVALID_INPUT');
+    }
+    const action = command.method;
+    const interrupt = limits.interruptMethods.includes(action);
+    if (interrupt ? record.interrupts >= limits.interruptCommands : record.commands >= limits.commands) {
+      throw new BrowserRuntimeError('QUOTA_EXCEEDED');
+    }
+    if (interrupt) record.interrupts++; else record.commands++;
+    const startedAt = Date.now();
+    const operation: IOperationRecord = {
+      operationId: randomId(), lease, controller: record.controller, action, startedAt,
+      session: record.session, incarnationGeneration: record.authority.incarnationGeneration,
+      promise: Promise.resolve(),
+    };
+    const identity = this.createOperationIdentity(lease, operation, action, 'devtools', startedAt);
+    const task = (async () => {
+      let failed = false;
+      let failure: unknown;
+      try {
+        await this.runBeforeOperation(identity, record.controller.signal);
+        this.requireDevToolsAuthority(lease, record);
+        await record.connection!.send(message);
+        this.requireDevToolsAuthority(lease, record);
+      } catch (error) { failed = true; failure = error; }
+      finally {
+        try {
+          await this.emitAudit(Object.freeze({ ...identity, phase: failed ? 'failed' : 'completed',
+            finishedAt: Date.now(), ...(failed ? { errorCode: this.operationErrorCode(failure) } : {}) }));
+        } finally {
+          if (interrupt) record.interrupts--; else record.commands--;
+        }
+      }
+      if (failed) throw failure;
+    })();
+    record.pending.add(task);
+    void task.then(() => record.pending.delete(task), () => record.pending.delete(task));
+    return task;
+  }
+
+  private closeLeaseDevTools(lease: ILeaseRecord, record: IDevToolsRecord): Promise<void> {
+    if (record.closePromise) return record.closePromise;
+    record.closed = true;
+    record.controller.abort(new BrowserRuntimeError('ABORTED'));
+    record.removeAbortListener();
+    const closing = (async () => {
+      try {
+        const detached = await waitBounded((async () => {
+          // Opening may still be completing when lease revocation arrives.
+          await Promise.resolve();
+          const connection = record.connection ?? await record.opening?.catch(() => undefined);
+          await connection?.close();
+        })(), this.options.quiescenceTimeoutMs + 3500);
+        if (!detached.settled) throw new BrowserRuntimeError('TIMEOUT');
+        const pending = await waitBounded(Promise.allSettled([...record.pending]),
+          this.options.quiescenceTimeoutMs + this.options.auditTimeoutMs + this.options.beforeOperationTimeoutMs);
+        if (!pending.settled) throw new BrowserRuntimeError('TIMEOUT');
+      } catch (error) {
+        await this.terminateRegisteredResourceInternal(lease.slot, false, {
+          session: record.session, incarnationGeneration: record.authority.incarnationGeneration,
+        });
+        throw error;
+      } finally {
+        if (lease.devTools === record) lease.devTools = undefined;
+      }
+    })();
+    record.closePromise = closing;
+    return closing;
+  }
+
   /** @internal */
   public async leaseAnswerVideoPeer(lease: ILeaseRecord, negotiationId: string,
     description: plugins.smartpuppeteer.ILiveVideoDescription, options: IBrowserRuntimeOperationOptions = {}): Promise<void> {
@@ -1478,6 +1644,24 @@ export class BrowserRuntime {
     );
   }
 
+  /** @internal */
+  public async leaseRespondToDialog(lease: ILeaseRecord,
+    input: plugins.smartpuppeteer.ILiveBrowserDialogResponse,
+    options: IBrowserRuntimeOperationOptions = {}): Promise<void> {
+    this.requireHuman(lease);
+    const record = validateExactKeys(input, ['tabId', 'dialogId', 'accept', 'promptText'], 'dialog');
+    const tabId = validateBoundedString(record.tabId, 'tabId', 1, 128);
+    const dialogId = validateBoundedString(record.dialogId, 'dialogId', 1, 128);
+    if (typeof record.accept !== 'boolean' || (record.promptText !== undefined
+      && (typeof record.promptText !== 'string' || record.promptText.length > 32768))) {
+      throw new BrowserRuntimeError('INVALID_INPUT');
+    }
+    const response = { tabId, dialogId, accept: record.accept,
+      ...(record.promptText !== undefined ? { promptText: record.promptText as string } : {}) };
+    return this.runOperation(lease, 'respondToDialog', 'dialog', options,
+      async (signal, session) => session.respondToDialog(response, { signal }));
+  }
+
   /** @internal */
   public async leaseDispatchRawInput(
     lease: ILeaseRecord,
@@ -1560,7 +1744,7 @@ export class BrowserRuntime {
     const tab = state.tabs.find((value) => value.id === state.activeTabId);
     if (!tab || tab.status !== 'open' || tab.id !== input.tabId
       || tab.generation !== input.generation || state.viewportRevision !== input.viewportRevision
-    ) throw new BrowserRuntimeError('INVALID_INPUT');
+    ) throw new BrowserRuntimeError('STALE_INPUT');
   }
 
   private mouseOwnershipKey(input: plugins.smartpuppeteer.ILiveBrowserMouseInput): string {
@@ -1608,6 +1792,29 @@ export class BrowserRuntime {
     return modifiers;
   }
 
+  private async releaseStaleParticipantInput(slot: IResourceSlot, session: ILiveBrowserSessionLike): Promise<void> {
+    const incarnationGeneration = slot.incarnationGeneration;
+    if (slot.session !== session) throw new BrowserRuntimeError('ABORTED');
+    if (slot.inputCleanup?.session === session
+      && slot.inputCleanup.incarnationGeneration === incarnationGeneration) return slot.inputCleanup.promise;
+    const state = session.getState();
+    const tab = state.tabs.find(tab => tab.id === state.activeTabId);
+    if (!tab?.streaming || tab.dialog) return;
+    const affected = [...slot.leases.values()].filter(lease => [...lease.heldKeys.values(), ...lease.heldButtons.values()]
+      .some(input => input.tabId !== tab.id || input.generation !== tab.generation
+        || input.viewportRevision !== state.viewportRevision));
+    if (!affected.length) return;
+    // The runtime owns native held input, including link navigation that bypasses its command queue.
+    const cleanup = { session, incarnationGeneration, promise: (async () => {
+      for (const lease of affected) {
+        if (slot.session !== session || slot.incarnationGeneration !== incarnationGeneration) return;
+        await this.releaseParticipantInput(lease, session);
+      }
+    })() };
+    slot.inputCleanup = cleanup;
+    try { await cleanup.promise; } finally { if (slot.inputCleanup === cleanup) slot.inputCleanup = undefined; }
+  }
+
   private async releaseAllParticipantInput(
     slot: IResourceSlot, session: ILiveBrowserSessionLike,
   ): Promise<void> {
@@ -1762,10 +1969,9 @@ export class BrowserRuntime {
   /** @internal */
   public cancelLeaseOperation(lease: ILeaseRecord): boolean {
     this.requireValidLease(lease);
-    const operation = lease.slot.operation;
-    if (!operation || operation.lease !== lease) return false;
-    operation.controller.abort(new BrowserRuntimeError('ABORTED'));
-    return true;
+    const operations = [...lease.slot.operations].filter(operation => operation.lease === lease);
+    for (const operation of operations) operation.controller.abort(new BrowserRuntimeError('ABORTED'));
+    return operations.length > 0;
   }
 
   /** @internal */
@@ -2013,6 +2219,7 @@ export class BrowserRuntime {
         usePipe: true,
         allowEvaluation: true,
         video: this.options.video,
+        allowDevTools: this.options.devTools,
         screencast: {
           enabled: false,          maxOutstandingFrames: this.options.maxOutstandingFrames,
           quality: this.options.screencast.quality,
@@ -2228,37 +2435,42 @@ export class BrowserRuntime {
   private drainOperationQueue(slot: IResourceSlot): void {
     if (slot.operationSchedulerRunning) return;
     slot.operationSchedulerRunning = true;
-    const scheduler = (async () => {
-      while (slot.operationQueue.length > 0) {
-        const queued = slot.operationQueue.shift()!;
-        if (queued.state === 'settled') continue;
-        queued.state = 'starting';
-        try {
-          const result = await this.executeQueuedOperation(queued);
-          if ((queued as IQueuedOperationRecord).state !== 'settled') {
-            queued.state = 'settled';
-            queued.resolve(result);
-          }
-        } catch (error) {
-          if (queued.state !== 'settled') {
-            queued.state = 'settled';
-            queued.reject(error);
-          }
-        } finally {
-          if (queued.onQueuedAbort) {
-            queued.signal.removeEventListener('abort', queued.onQueuedAbort);
-            queued.onQueuedAbort = undefined;
-          }
+    void (async () => {
+      try {
+        while (slot.operationQueue.length > 0) {
+          // Dialog replies must unblock a page operation already waiting on Chrome.
+          const dialogIndex = slot.operationQueue.findIndex(entry => entry.classification === 'dialog');
+          const index = dialogIndex >= 0 ? dialogIndex : 0;
+          const queued = slot.operationQueue[index]!;
+          const active = [...slot.activeQueuedOperations];
+          if (queued.classification === 'dialog') {
+            if (active.some(entry => entry.classification === 'dialog')) break;
+          } else if (active.length > 0 && !(queued.action === 'dispatchWheel'
+            && active.length < 4 && active.every(entry => entry.action === 'dispatchWheel'))) break;
+          slot.operationQueue.splice(index, 1);
+          if (queued.state === 'settled') continue;
+          queued.state = 'starting';
+          slot.activeQueuedOperations.add(queued);
+          let dispatched!: () => void;
+          const admission = new Promise<void>(resolve => { dispatched = resolve; });
+          void this.executeQueuedOperation(queued, dispatched).then(result => {
+            if (queued.state !== 'settled') { queued.state = 'settled'; queued.resolve(result); }
+          }, error => {
+            if (queued.state !== 'settled') { queued.state = 'settled'; queued.reject(error); }
+          }).finally(() => {
+            dispatched();
+            if (queued.onQueuedAbort) queued.signal.removeEventListener('abort', queued.onQueuedAbort);
+            slot.activeQueuedOperations.delete(queued);
+            this.drainOperationQueue(slot);
+          });
+          // Preserve authorization and native-send order without waiting for wheel ACKs.
+          await admission;
         }
-      }
-    })().finally(() => {
-      slot.operationSchedulerRunning = false;
-      if (slot.operationQueue.length > 0) this.drainOperationQueue(slot);
-    });
-    void scheduler.catch(() => undefined);
+      } finally { slot.operationSchedulerRunning = false; }
+    })();
   }
 
-  private async executeQueuedOperation(queued: IQueuedOperationRecord): Promise<unknown> {
+  private async executeQueuedOperation(queued: IQueuedOperationRecord, dispatched: () => void): Promise<unknown> {
     const { lease, action, classification } = queued;
     const slot = lease.slot;
     const release = await slot.mutex.acquire();
@@ -2278,7 +2490,12 @@ export class BrowserRuntime {
       queued.signal.throwIfAborted();
       this.requireQueuedLease(lease, queued.participantCleanup);
       this.assertSlotAvailable(slot);
-      if (slot.operation) throw new BrowserRuntimeError('BUSY');
+      const active = [...slot.operations];
+      if (classification === 'dialog' ? active.some(operation => operation.action === 'respondToDialog')
+        : active.length > 0 && !(action === 'dispatchWheel' && active.length < 4
+          && active.every(operation => operation.action === 'dispatchWheel'))) {
+        throw new BrowserRuntimeError('BUSY');
+      }
       session = slot.session!;
       generation = slot.arbitrationGeneration;
       incarnationGeneration = slot.incarnationGeneration;
@@ -2308,7 +2525,7 @@ export class BrowserRuntime {
         incarnationGeneration,
         promise: new Promise<void>((resolve) => { resolvePreflight = resolve; }),
       };
-      slot.operation = operation;
+      slot.operations.add(operation);
       queued.state = 'active';
       if (queued.onQueuedAbort) {
         queued.signal.removeEventListener('abort', queued.onQueuedAbort);
@@ -2344,7 +2561,7 @@ export class BrowserRuntime {
         this.requireQueuedLease(lease, queued.participantCleanup);
         this.assertSlotAvailable(slot);
         if (
-          slot.operation !== operation
+          !slot.operations.has(operation)
           || slot.session !== session
           || slot.arbitrationGeneration !== generation
           || slot.incarnationGeneration !== incarnationGeneration
@@ -2354,8 +2571,11 @@ export class BrowserRuntime {
           if (classification === 'navigation' || classification === 'tab') {
             await this.releaseAllParticipantInput(slot, session);
           }
+          if (classification !== 'dialog') await this.releaseStaleParticipantInput(slot, session);
           combinedSignal.throwIfAborted();
-          return queued.execute(combinedSignal, session);
+          const result = queued.execute(combinedSignal, session);
+          dispatched();
+          return result;
         })();
         operation.promise = executionPromise.then(() => undefined, () => undefined).finally(() => {
           executionSettled = true;
@@ -2385,10 +2605,11 @@ export class BrowserRuntime {
       clearTimeout(timeout!);
       queued.externalSignal?.removeEventListener('abort', onExternalAbort!);
       resolvePreflight();
+      dispatched();
       const cleanupSlot = async (): Promise<void> => {
         const cleanupRelease = await slot.mutex.acquire();
         try {
-          if (slot.operation === operation) slot.operation = undefined;
+          slot.operations.delete(operation);
         } finally {
           cleanupRelease();
         }
@@ -2397,7 +2618,7 @@ export class BrowserRuntime {
         if (combinedSignal!.aborted) {
           await this.enforceOperationQuiescence(operation).catch(() => undefined);
         }
-        if (slot.operation === operation) {
+        if (slot.operations.has(operation)) {
           const settled = await waitBounded(operation.promise, this.options.quiescenceTimeoutMs);
           if (settled.settled) await cleanupSlot();
         }
@@ -2407,7 +2628,7 @@ export class BrowserRuntime {
       if (
         queued.finalize
         && (!executionStarted || executionSettled)
-        && slot.operation !== operation
+        && !slot.operations.has(operation)
       ) {
         try {
           await queued.finalize();
@@ -2455,6 +2676,8 @@ export class BrowserRuntime {
       );
     }
     if (errorArg instanceof BrowserRuntimeError) return errorArg;
+    if (errorArg instanceof plugins.smartpuppeteer.LiveBrowserInputStaleError) return new BrowserRuntimeError('STALE_INPUT');
+    if (errorArg instanceof plugins.smartpuppeteer.LiveBrowserDialogPendingError) return new BrowserRuntimeError('DIALOG_PENDING');
     if (errorArg instanceof Error && errorArg.name === 'TimeoutError') {
       return new BrowserRuntimeError('TIMEOUT');
     }
@@ -2727,6 +2950,7 @@ export class BrowserRuntime {
         generation: tab.generation,
         appliedViewportRevision: tab.appliedViewportRevision,
         streaming: tab.streaming,
+        ...(tab.dialog ? { dialog: { ...tab.dialog } } : {}),
       })),
       ...(state.lastError
         ? {
@@ -3094,7 +3318,7 @@ export class BrowserRuntime {
         lease.released = true;
         lease.controller.abort(new BrowserRuntimeError('CAPABILITY_REVOKED'));
       }
-      slot.operation?.controller.abort(new BrowserRuntimeError('CAPABILITY_REVOKED'));
+      for (const operation of slot.operations) operation.controller.abort(new BrowserRuntimeError('CAPABILITY_REVOKED'));
       for (const subscription of subscribers) {
         try { subscription.listener(runtimeEvent); } catch { /* Producer failure owns cleanup. */ }
       }
@@ -3286,7 +3510,7 @@ export class BrowserRuntime {
         lease.controller.abort(new BrowserRuntimeError('CAPABILITY_REVOKED'));
         this.notifyFramedLeaseEnded(lease);
       }
-      slot.operation?.controller.abort(new BrowserRuntimeError('CAPABILITY_REVOKED'));
+      for (const operation of slot.operations) operation.controller.abort(new BrowserRuntimeError('CAPABILITY_REVOKED'));
     } finally {
       release();
     }
@@ -3302,7 +3526,7 @@ export class BrowserRuntime {
           slot.leases.delete(lease.leaseId);
           if (lease.capability.lease === lease) lease.capability.lease = undefined;
         }
-        slot.operation = undefined;
+        slot.operations.clear();
         slot.fencingGeneration = undefined;
       }
     } finally {
@@ -3467,17 +3691,18 @@ export class BrowserRuntime {
     const slot = lease.slot;
     if (slot.leases.get(lease.leaseId) !== lease) return;
     const release = await slot.mutex.acquire();
-    let operation: IOperationRecord | undefined;
+    let operations: IOperationRecord[];
     try {
       lease.released = true;
       lease.controller.abort(new BrowserRuntimeError('ABORTED'));
-      operation = slot.operation?.lease === lease ? slot.operation : undefined;
-      operation?.controller.abort(new BrowserRuntimeError('ABORTED'));
+      operations = [...slot.operations].filter(operation => operation.lease === lease);
+      for (const operation of operations) operation.controller.abort(new BrowserRuntimeError('ABORTED'));
     } finally {
       release();
     }
     await this.closeFrameSubscriptionIfLease(lease);
-    if (operation) {
+    if (lease.devTools) await this.closeLeaseDevTools(lease, lease.devTools);
+    for (const operation of operations) {
       const settled = await waitBounded(operation.promise, this.options.quiescenceTimeoutMs);
       if (!settled.settled) {
         // An unquiescent operation belongs to the browser process, so its incarnation must end.
@@ -3525,13 +3750,12 @@ export class BrowserRuntime {
   }
 
   private async quiesceSlot(slot: IResourceSlot): Promise<void> {
-    const operation = slot.operation;
-    if (!operation) return;
-    operation.controller.abort(new BrowserRuntimeError('ABORTED'));
-    const settled = await waitBounded(operation.promise, this.options.quiescenceTimeoutMs);
+    const operations = [...slot.operations];
+    for (const operation of operations) operation.controller.abort(new BrowserRuntimeError('ABORTED'));
+    const settled = await waitBounded(Promise.all(operations.map(operation => operation.promise)), this.options.quiescenceTimeoutMs);
     if (settled.settled) return;
     await this.terminateSlotSession(slot);
-    if (slot.operation === operation) slot.operation = undefined;
+    for (const operation of operations) slot.operations.delete(operation);
   }
 
   private async enforceOperationQuiescence(operation: IOperationRecord): Promise<void> {
@@ -3547,7 +3771,7 @@ export class BrowserRuntime {
     } catch (error) {
       cleanupError = error;
     }
-    if (operation.lease.slot.operation !== operation) {
+    if (!operation.lease.slot.operations.has(operation)) {
       if (cleanupError) throw cleanupError;
       return;
     }
@@ -3557,7 +3781,7 @@ export class BrowserRuntime {
       return;
     }
     const slot = operation.lease.slot;
-    if (slot.operation === operation && slot.session === operation.session
+    if (slot.operations.has(operation) && slot.session === operation.session
       && slot.incarnationGeneration === operation.incarnationGeneration) {
       await this.terminateRegisteredResourceInternal(slot, false, {
         session: operation.session, incarnationGeneration: operation.incarnationGeneration,
@@ -3566,13 +3790,13 @@ export class BrowserRuntime {
     const release = await slot.mutex.acquire();
     try {
       if (
-        slot.operation === operation
+        slot.operations.has(operation)
         && (
           slot.permanentlyFenced
           || slot.session !== operation.session
           || slot.incarnationGeneration !== operation.incarnationGeneration
         )
-      ) slot.operation = undefined;
+      ) slot.operations.delete(operation);
     } finally {
       release();
     }
@@ -3614,6 +3838,7 @@ export class BrowserRuntime {
       }
       slot.unsubscribeSession?.();
       slot.unsubscribeSession = undefined;
+      if (slot.inputCleanup?.session === session) slot.inputCleanup = undefined;
       slot.session = undefined;
       slot.highestFrameSequence = 0;
       slot.producerAcknowledgements.clear();
@@ -3698,7 +3923,7 @@ export class BrowserRuntime {
         lease.controller.abort(new BrowserRuntimeError('ABORTED'));
         if (!stopping) this.notifyFramedLeaseEnded(lease);
       }
-      slot.operation?.controller.abort(new BrowserRuntimeError('ABORTED'));
+      for (const operation of slot.operations) operation.controller.abort(new BrowserRuntimeError('ABORTED'));
     } finally {
       release();
     }
@@ -3714,7 +3939,7 @@ export class BrowserRuntime {
         if (lease.capability.lease === lease) lease.capability.lease = undefined;
         slot.leases.delete(lease.leaseId);
       }
-      slot.operation = undefined;
+      slot.operations.clear();
       slot.fencingGeneration = undefined;
     } finally {
       finalRelease();
@@ -3815,8 +4040,8 @@ export class BrowserRuntime {
           lease.controller.abort(new BrowserRuntimeError('CAPABILITY_REVOKED'));
         }
       }
-      if (slot.operation?.lease.role === 'agent') {
-        slot.operation.controller.abort(new BrowserRuntimeError('CAPABILITY_REVOKED'));
+      for (const operation of slot.operations) {
+        if (operation.lease.role === 'agent') operation.controller.abort(new BrowserRuntimeError('CAPABILITY_REVOKED'));
       }
     } finally {
       release();
@@ -4342,6 +4567,11 @@ export class BrowserRuntimeLease {
     return this.runtime.leaseSetViewport(this.record, viewport, operationOptions);
   }
 
+  public respondToDialog(input: plugins.smartpuppeteer.ILiveBrowserDialogResponse,
+    options: IBrowserRuntimeOperationOptions = {}): Promise<void> {
+    return this.runtime.leaseRespondToDialog(this.record, input, options);
+  }
+
   public dispatchMouse(
     input: plugins.smartpuppeteer.ILiveBrowserMouseInput,
     operationOptions?: IBrowserRuntimeOperationOptions,
@@ -4381,6 +4611,11 @@ export class BrowserRuntimeLease {
     return this.runtime.leaseOpenVideoPeer(this.record, options);
   }
 
+  public openDevTools(options: plugins.smartpuppeteer.ILiveBrowserDevToolsOptions,
+    operationOptions?: IBrowserRuntimeOperationOptions): Promise<plugins.smartpuppeteer.ILiveBrowserDevToolsConnection> {
+    return this.runtime.leaseOpenDevTools(this.record, options, operationOptions);
+  }
+
   public answerVideoPeer(negotiationId: string, description: plugins.smartpuppeteer.ILiveVideoDescription,
     options?: IBrowserRuntimeOperationOptions): Promise<void> {
     return this.runtime.leaseAnswerVideoPeer(this.record, negotiationId, description, options);

package/ts/errors.ts

@@ -11,6 +11,8 @@ export type TBrowserRuntimeErrorCode =
   | 'FENCED'
   | 'FRAME_STREAM_FAILED'
   | 'FRAME_TOO_LARGE'
+  | 'DIALOG_PENDING'
+  | 'STALE_INPUT'
   | 'INVALID_INPUT'
   | 'LOCKED'
   | 'NOT_RUNNING'
@@ -33,6 +35,8 @@ const publicMessages: Record<TBrowserRuntimeErrorCode, string> = {
   FENCED: 'The browser resource is permanently fenced.',
   FRAME_STREAM_FAILED: 'The browser frame stream failed.',
   FRAME_TOO_LARGE: 'The browser frame exceeded its limit.',
+  DIALOG_PENDING: 'Respond to the website dialog before sending input.',
+  STALE_INPUT: 'The input belongs to a previous document or dialog.',
   INVALID_INPUT: 'The request is invalid.',
   LOCKED: 'The browser runtime is already locked.',
   NOT_RUNNING: 'The browser runtime is not running.',