chrome-devtools-frontend 1.0.1536371 → 1.0.1537268

package/front_end/third_party/puppeteer/package/lib/types.d.ts

@@ -254,7 +254,7 @@ export declare abstract class Browser extends EventEmitter<BrowserEvents> {
      * Creates a new {@link Page | page} in the
      * {@link Browser.defaultBrowserContext | default browser context}.
      */
-    abstract newPage(): Promise<Page>;
+    abstract newPage(options?: CreatePageOptions): Promise<Page>;
     /**
      * Gets all active {@link Target | targets}.
      *
@@ -513,7 +513,7 @@ export declare abstract class BrowserContext extends EventEmitter<BrowserContext
      * Creates a new {@link Page | page} in this
      * {@link BrowserContext | browser context}.
      */
-    abstract newPage(): Promise<Page>;
+    abstract newPage(options?: CreatePageOptions): Promise<Page>;
     /**
      * Gets the {@link Browser | browser} associated with this
      * {@link BrowserContext | browser context}.
@@ -1497,6 +1497,15 @@ export declare interface CoverageEntry {
     }>;
 }
 
+/**
+ * @public
+ */
+export declare type CreatePageOptions = {
+    type: 'tab';
+} | {
+    type: 'window';
+};
+
 /**
  * @public
  */
@@ -5449,7 +5458,7 @@ export declare abstract class Page extends EventEmitter<PageEvents> {
      * multiple redirects, the navigation will resolve with the response of the
      * last redirect.
      */
-    abstract reload(options?: WaitForOptions): Promise<HTTPResponse | null>;
+    abstract reload(options?: ReloadOptions): Promise<HTTPResponse | null>;
     /**
      * Waits for the page to navigate to a new URL or to reload. It is useful when
      * you run code that will indirectly cause the page to navigate.
@@ -6895,6 +6904,7 @@ declare namespace Puppeteer_2 {
         BrowserEvent,
         BrowserEvents,
         DebugInfo,
+        CreatePageOptions,
         Browser,
         BrowserContextEvent,
         BrowserContextEvents,
@@ -6961,6 +6971,7 @@ declare namespace Puppeteer_2 {
         PageEvent,
         PageEvents,
         NewDocumentScriptEvaluation,
+        ReloadOptions,
         Page,
         TargetType,
         Target,
@@ -7259,6 +7270,19 @@ export declare interface QueryOptions {
     isolate: boolean;
 }
 
+/**
+ * @public
+ */
+export declare interface ReloadOptions extends WaitForOptions {
+    /**
+     * If set to true, the browser caches are ignored for the page reload.
+     *
+     * @defaultValue true
+     * @public
+     */
+    ignoreCache?: boolean;
+}
+
 /**
  * @public
  */
@@ -7581,6 +7605,7 @@ export declare interface SerializedAXNode {
      * Children of this node, if there are any.
      */
     children?: SerializedAXNode[];
+
     /**
      * Get an ElementHandle for this AXNode if available.
      *

package/front_end/third_party/puppeteer/package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "puppeteer-core",
-  "version": "24.26.1",
+  "version": "24.27.0",
   "description": "A high-level API to control headless Chrome over the DevTools Protocol",
   "keywords": [
     "puppeteer",
@@ -152,7 +152,7 @@
     "@puppeteer/browsers": "2.10.12",
     "chromium-bidi": "10.5.1",
     "debug": "^4.4.3",
-    "devtools-protocol": "0.0.1508733",
+    "devtools-protocol": "0.0.1521046",
     "typed-query-selector": "^2.12.0",
     "webdriver-bidi-protocol": "0.3.8",
     "ws": "^8.18.3"

package/front_end/third_party/puppeteer/package/src/api/Browser.ts

@@ -210,6 +210,18 @@ export interface DebugInfo {
   pendingProtocolErrors: Error[];
 }
 
+/**
+ * @public
+ */
+export type CreatePageOptions =
+  | {
+      type: 'tab';
+    }
+  | {
+      type: 'window';
+      // TODO: window-specific params will be added here.
+    };
+
 /**
  * {@link Browser} represents a browser instance that is either:
  *
@@ -324,7 +336,7 @@ export abstract class Browser extends EventEmitter<BrowserEvents> {
    * Creates a new {@link Page | page} in the
    * {@link Browser.defaultBrowserContext | default browser context}.
    */
-  abstract newPage(): Promise<Page>;
+  abstract newPage(options?: CreatePageOptions): Promise<Page>;
 
   /**
    * Gets all active {@link Target | targets}.

package/front_end/third_party/puppeteer/package/src/api/BrowserContext.ts

@@ -25,7 +25,12 @@ import {
 import {asyncDisposeSymbol, disposeSymbol} from '../util/disposable.js';
 import {Mutex} from '../util/Mutex.js';
 
-import type {Browser, Permission, WaitForTargetOptions} from './Browser.js';
+import type {
+  Browser,
+  CreatePageOptions,
+  Permission,
+  WaitForTargetOptions,
+} from './Browser.js';
 import type {Page} from './Page.js';
 import type {Target} from './Target.js';
 
@@ -230,7 +235,7 @@ export abstract class BrowserContext extends EventEmitter<BrowserContextEvents>
    * Creates a new {@link Page | page} in this
    * {@link BrowserContext | browser context}.
    */
-  abstract newPage(): Promise<Page>;
+  abstract newPage(options?: CreatePageOptions): Promise<Page>;
 
   /**
    * Gets the {@link Browser | browser} associated with this

package/front_end/third_party/puppeteer/package/src/api/Page.ts

@@ -633,6 +633,19 @@ export function setDefaultScreenshotOptions(options: ScreenshotOptions): void {
   options.captureBeyondViewport ??= true;
 }
 
+/**
+ * @public
+ */
+export interface ReloadOptions extends WaitForOptions {
+  /**
+   * If set to true, the browser caches are ignored for the page reload.
+   *
+   * @defaultValue true
+   * @public
+   */
+  ignoreCache?: boolean;
+}
+
 /**
  * Page provides methods to interact with a single tab or
  * {@link https://developer.chrome.com/extensions/background_pages | extension background page}
@@ -1743,7 +1756,7 @@ export abstract class Page extends EventEmitter<PageEvents> {
    * multiple redirects, the navigation will resolve with the response of the
    * last redirect.
    */
-  abstract reload(options?: WaitForOptions): Promise<HTTPResponse | null>;
+  abstract reload(options?: ReloadOptions): Promise<HTTPResponse | null>;
 
   /**
    * Waits for the page to navigate to a new URL or to reload. It is useful when

package/front_end/third_party/puppeteer/package/src/bidi/BrowserContext.ts

@@ -6,7 +6,7 @@
 
 import * as Bidi from 'webdriver-bidi-protocol';
 
-import type {Permission} from '../api/Browser.js';
+import type {CreatePageOptions, Permission} from '../api/Browser.js';
 import {WEB_PERMISSION_TO_PROTOCOL_PERMISSION} from '../api/Browser.js';
 import type {BrowserContextEvents} from '../api/BrowserContext.js';
 import {BrowserContext, BrowserContextEvent} from '../api/BrowserContext.js';
@@ -181,12 +181,15 @@ export class BidiBrowserContext extends BrowserContext {
     });
   }
 
-  override async newPage(): Promise<Page> {
+  override async newPage(options?: CreatePageOptions): Promise<Page> {
     using _guard = await this.waitForScreenshotOperations();
 
-    const context = await this.userContext.createBrowsingContext(
-      Bidi.BrowsingContext.CreateType.Tab,
-    );
+    const type =
+      options?.type === 'window'
+        ? Bidi.BrowsingContext.CreateType.Window
+        : Bidi.BrowsingContext.CreateType.Tab;
+
+    const context = await this.userContext.createBrowsingContext(type);
     const page = this.#pages.get(context)!;
     if (!page) {
       throw new Error('Page is not found');

package/front_end/third_party/puppeteer/package/src/bidi/Page.ts

@@ -17,6 +17,7 @@ import type {
   GeolocationOptions,
   MediaFeature,
   PageEvents,
+  ReloadOptions,
   WaitTimeoutOptions,
 } from '../api/Page.js';
 import {
@@ -332,11 +333,13 @@ export class BidiPage extends Page {
   }
 
   override async reload(
-    options: WaitForOptions = {},
+    options: ReloadOptions = {},
   ): Promise<BidiHTTPResponse | null> {
     const [response] = await Promise.all([
       this.#frame.waitForNavigation(options),
-      this.#frame.browsingContext.reload(),
+      this.#frame.browsingContext.reload({
+        ignoreCache: options.ignoreCache ? true : undefined,
+      }),
     ]).catch(
       rewriteNavigationError(
         this.url(),

package/front_end/third_party/puppeteer/package/src/cdp/Accessibility.ts

@@ -86,6 +86,13 @@ export interface SerializedAXNode {
    */
   children?: SerializedAXNode[];
 
+  /**
+   * CDP-specifc ID to reference the DOM node.
+   *
+   * @internal
+   */
+  backendNodeId?: number;
+
   /**
    * Get an ElementHandle for this AXNode if available.
    *
@@ -539,6 +546,7 @@ class AXNode {
           return node.nodeType === Node.TEXT_NODE ? node.parentElement : node;
         })) as ElementHandle<Element>;
       },
+      backendNodeId: this.payload.backendDOMNodeId,
     };
 
     type UserStringProperty =

package/front_end/third_party/puppeteer/package/src/cdp/Browser.ts

@@ -8,7 +8,7 @@ import type {ChildProcess} from 'node:child_process';
 
 import type {Protocol} from 'devtools-protocol';
 
-import type {DebugInfo} from '../api/Browser.js';
+import type {CreatePageOptions, DebugInfo} from '../api/Browser.js';
 import {
   Browser as BrowserBase,
   BrowserEvent,
@@ -347,10 +347,19 @@ export class CdpBrowser extends BrowserBase {
     return await this.#defaultContext.newPage();
   }
 
-  async _createPageInContext(contextId?: string): Promise<Page> {
+  async _createPageInContext(
+    contextId?: string,
+    options?: CreatePageOptions,
+  ): Promise<Page> {
+    const hasTargets =
+      this.targets().filter(t => {
+        return t.browserContext().id === contextId;
+      }).length > 0;
     const {targetId} = await this.#connection.send('Target.createTarget', {
       url: 'about:blank',
       browserContextId: contextId || undefined,
+      // Works around crbug.com/454825274.
+      newWindow: hasTargets && options?.type === 'window' ? true : undefined,
     });
     const target = (await this.waitForTarget(t => {
       return (t as CdpTarget)._targetId === targetId;

package/front_end/third_party/puppeteer/package/src/cdp/BrowserContext.ts

@@ -4,6 +4,7 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 
+import type {CreatePageOptions} from '../api/Browser.js';
 import {
   WEB_PERMISSION_TO_PROTOCOL_PERMISSION,
   type Permission,
@@ -88,9 +89,9 @@ export class CdpBrowserContext extends BrowserContext {
     });
   }
 
-  override async newPage(): Promise<Page> {
+  override async newPage(options?: CreatePageOptions): Promise<Page> {
     using _guard = await this.waitForScreenshotOperations();
-    return await this.#browser._createPageInContext(this.#id);
+    return await this.#browser._createPageInContext(this.#id, options);
   }
 
   override browser(): CdpBrowser {

package/front_end/third_party/puppeteer/package/src/cdp/Page.ts

@@ -14,7 +14,7 @@ import type {ElementHandle} from '../api/ElementHandle.js';
 import type {Frame, WaitForOptions} from '../api/Frame.js';
 import type {HTTPResponse} from '../api/HTTPResponse.js';
 import type {JSHandle} from '../api/JSHandle.js';
-import type {Credentials} from '../api/Page.js';
+import type {Credentials, ReloadOptions} from '../api/Page.js';
 import {
   Page,
   PageEvent,
@@ -898,15 +898,15 @@ export class CdpPage extends Page {
     this.emit(PageEvent.Dialog, dialog);
   }
 
-  override async reload(
-    options?: WaitForOptions,
-  ): Promise<HTTPResponse | null> {
+  override async reload(options?: ReloadOptions): Promise<HTTPResponse | null> {
     const [result] = await Promise.all([
       this.waitForNavigation({
         ...options,
         ignoreSameDocumentNavigation: true,
       }),
-      this.#primaryTargetClient.send('Page.reload'),
+      this.#primaryTargetClient.send('Page.reload', {
+        ignoreCache: options?.ignoreCache ?? false,
+      }),
     ]);
 
     return result;

package/front_end/third_party/puppeteer/package/src/revisions.ts

@@ -8,7 +8,7 @@
  * @internal
  */
 export const PUPPETEER_REVISIONS = Object.freeze({
-  chrome: '141.0.7390.122',
-  'chrome-headless-shell': '141.0.7390.122',
-  firefox: 'stable_144.0',
+  chrome: '142.0.7444.59',
+  'chrome-headless-shell': '142.0.7444.59',
+  firefox: 'stable_144.0.2',
 });

package/front_end/third_party/puppeteer/package/src/util/disposable.ts

@@ -45,7 +45,7 @@ export const asyncDisposeSymbol: typeof Symbol.asyncDispose =
 /**
  * @internal
  */
-class DisposableStackPolyfill {
+export class DisposableStackPolyfill {
   #disposed = false;
   #stack: Disposable[] = [];
 
@@ -194,7 +194,7 @@ export const DisposableStack: typeof DisposableStackPolyfill =
 /**
  * @internal
  */
-class AsyncDisposableStackPolyfill {
+export class AsyncDisposableStackPolyfill {
   #disposed = false;
   #stack: AsyncDisposable[] = [];
 

package/front_end/third_party/puppeteer/package/src/util/util.ts

@@ -10,3 +10,4 @@ export * from './Mutex.js';
 export * from './ErrorLike.js';
 export * from './AsyncIterableUtil.js';
 export * from './disposable.js';
+export * from './incremental-id-generator.js';

package/front_end/third_party/puppeteer/package/src/util/version.ts

@@ -6,5 +6,5 @@
 
 // If moved update release-please config
 // x-release-please-start-version
-export const packageVersion = '24.26.1';
+export const packageVersion = '24.27.0';
 // x-release-please-end

package/front_end/ui/components/text_editor/AiCodeCompletionProvider.ts

@@ -0,0 +1,280 @@
+// Copyright 2025 The Chromium Authors
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+import * as Common from '../../../core/common/common.js';
+import * as Host from '../../../core/host/host.js';
+import * as i18n from '../../../core/i18n/i18n.js';
+import * as Root from '../../../core/root/root.js';
+import * as PanelCommon from '../../../panels/common/common.js';
+import * as CodeMirror from '../../../third_party/codemirror.next/codemirror.next.js';
+import * as UI from '../../legacy/legacy.js';
+import * as VisualLogging from '../../visual_logging/visual_logging.js';
+
+import {AiCodeCompletionTeaserPlaceholder} from './AiCodeCompletionTeaserPlaceholder.js';
+import {
+  aiAutoCompleteSuggestion,
+  aiAutoCompleteSuggestionState,
+  setAiAutoCompleteSuggestion,
+} from './config.js';
+import type {TextEditor} from './TextEditor.js';
+
+export enum AiCodeCompletionTeaserMode {
+  OFF = 'off',
+  ON = 'on',
+  ONLY_SHOW_ON_EMPTY = 'onlyShowOnEmpty',
+}
+
+export const setAiCodeCompletionTeaserMode = CodeMirror.StateEffect.define<AiCodeCompletionTeaserMode>();
+
+export const aiCodeCompletionTeaserModeState = CodeMirror.StateField.define<AiCodeCompletionTeaserMode>({
+  create: () => AiCodeCompletionTeaserMode.OFF,
+  update(value, tr) {
+    return tr.effects.find(effect => effect.is(setAiCodeCompletionTeaserMode))?.value ?? value;
+  },
+});
+
+export interface AiCodeCompletionConfig {
+  completionContext: {
+    additionalFiles?: Host.AidaClient.AdditionalFile[],
+    inferenceLanguage?: Host.AidaClient.AidaInferenceLanguage,
+    getPrefix?: () => string,
+    stopSequences?: string[],
+  };
+  onFeatureEnabled: () => void;
+  onFeatureDisabled: () => void;
+  onSuggestionAccepted: () => void;
+  onRequestTriggered: () => void;
+  onResponseReceived: (citations: Host.AidaClient.Citation[]) => void;
+}
+
+export const DELAY_BEFORE_SHOWING_RESPONSE_MS = 500;
+export const AIDA_REQUEST_DEBOUNCE_TIMEOUT_MS = 200;
+
+// TODO(samiyac): Add code relevant to AiCodeCompletion and for triggering requests
+export class AiCodeCompletionProvider {
+  #aidaClient?: Host.AidaClient.AidaClient;
+  #aiCodeCompletionSetting = Common.Settings.Settings.instance().createSetting('ai-code-completion-enabled', false);
+  #aiCodeCompletionTeaserDismissedSetting =
+      Common.Settings.Settings.instance().createSetting('ai-code-completion-teaser-dismissed', false);
+  #teaserCompartment = new CodeMirror.Compartment();
+  #teaser?: PanelCommon.AiCodeCompletionTeaser;
+  #suggestionRenderingTimeout?: number;
+  #editor?: TextEditor;
+  #aiCodeCompletionConfig?: AiCodeCompletionConfig;
+
+  #boundOnUpdateAiCodeCompletionState = this.#updateAiCodeCompletionState.bind(this);
+
+  constructor(aiCodeCompletionConfig: AiCodeCompletionConfig) {
+    if (!this.#isAiCodeCompletionEnabled()) {
+      throw new Error('AI code completion feature is not enabled.');
+    }
+    this.#aiCodeCompletionConfig = aiCodeCompletionConfig;
+  }
+
+  extension(): CodeMirror.Extension[] {
+    return [
+      this.#teaserCompartment.of([]),
+      aiAutoCompleteSuggestion,
+      aiCodeCompletionTeaserModeState,
+      aiAutoCompleteSuggestionState,
+    ];
+  }
+
+  dispose(): void {
+    this.#detachTeaser();
+    this.#teaser = undefined;
+    this.#aiCodeCompletionSetting.removeChangeListener(this.#boundOnUpdateAiCodeCompletionState);
+    Host.AidaClient.HostConfigTracker.instance().removeEventListener(
+        Host.AidaClient.Events.AIDA_AVAILABILITY_CHANGED, this.#boundOnUpdateAiCodeCompletionState);
+    this.#cleanupAiCodeCompletion();
+  }
+
+  editorInitialized(editor: TextEditor): void {
+    this.#editor = editor;
+    if (!this.#aiCodeCompletionSetting.get() && !this.#aiCodeCompletionTeaserDismissedSetting.get()) {
+      this.#teaser = new PanelCommon.AiCodeCompletionTeaser({
+        onDetach: () => this.#detachTeaser.bind(this),
+      });
+      this.#editor.editor.dispatch(
+          {effects: this.#teaserCompartment.reconfigure([aiCodeCompletionTeaserExtension(this.#teaser)])});
+    }
+    Host.AidaClient.HostConfigTracker.instance().addEventListener(
+        Host.AidaClient.Events.AIDA_AVAILABILITY_CHANGED, this.#boundOnUpdateAiCodeCompletionState);
+    this.#aiCodeCompletionSetting.addChangeListener(this.#boundOnUpdateAiCodeCompletionState);
+    void this.#updateAiCodeCompletionState();
+  }
+
+  #setupAiCodeCompletion(): void {
+    if (!this.#editor || !this.#aiCodeCompletionConfig) {
+      return;
+    }
+    if (!this.#aidaClient) {
+      this.#aidaClient = new Host.AidaClient.AidaClient();
+    }
+    this.#aiCodeCompletionConfig.onFeatureEnabled();
+  }
+
+  #cleanupAiCodeCompletion(): void {
+    if (this.#suggestionRenderingTimeout) {
+      clearTimeout(this.#suggestionRenderingTimeout);
+      this.#suggestionRenderingTimeout = undefined;
+    }
+    this.#editor?.dispatch({
+      effects: setAiAutoCompleteSuggestion.of(null),
+    });
+    this.#aiCodeCompletionConfig?.onFeatureDisabled();
+  }
+
+  async #updateAiCodeCompletionState(): Promise<void> {
+    const aidaAvailability = await Host.AidaClient.AidaClient.checkAccessPreconditions();
+    const isAvailable = aidaAvailability === Host.AidaClient.AidaAccessPreconditions.AVAILABLE;
+    const isEnabled = this.#aiCodeCompletionSetting.get();
+    if (isAvailable && isEnabled) {
+      this.#detachTeaser();
+      this.#setupAiCodeCompletion();
+    } else if (isAvailable && !isEnabled) {
+      if (this.#teaser && !this.#aiCodeCompletionTeaserDismissedSetting.get()) {
+        this.#editor?.editor.dispatch(
+            {effects: this.#teaserCompartment.reconfigure([aiCodeCompletionTeaserExtension(this.#teaser)])});
+      }
+      this.#cleanupAiCodeCompletion();
+    } else if (!isAvailable) {
+      this.#detachTeaser();
+      this.#cleanupAiCodeCompletion();
+    }
+  }
+
+  #detachTeaser(): void {
+    if (!this.#teaser) {
+      return;
+    }
+    this.#editor?.editor.dispatch({effects: this.#teaserCompartment.reconfigure([])});
+  }
+
+  // TODO(samiyac): Define static method in AiCodeCompletion and use that instead
+  #isAiCodeCompletionEnabled(): boolean {
+    const devtoolsLocale = i18n.DevToolsLocale.DevToolsLocale.instance();
+    const aidaAvailability = Root.Runtime.hostConfig.aidaAvailability;
+    if (!devtoolsLocale.locale.startsWith('en-')) {
+      return false;
+    }
+    if (!aidaAvailability || aidaAvailability.blockedByGeo || aidaAvailability.blockedByAge ||
+        aidaAvailability.blockedByEnterprisePolicy) {
+      return false;
+    }
+    return Boolean(aidaAvailability.enabled && Root.Runtime.hostConfig.devToolsAiCodeCompletion?.enabled);
+  }
+}
+
+function aiCodeCompletionTeaserExtension(teaser: PanelCommon.AiCodeCompletionTeaser): CodeMirror.Extension {
+  return CodeMirror.ViewPlugin.fromClass(class {
+    teaser: PanelCommon.AiCodeCompletionTeaser;
+    #teaserDecoration: CodeMirror.DecorationSet = CodeMirror.Decoration.none;
+    #teaserMode: AiCodeCompletionTeaserMode;
+    #teaserDisplayTimeout?: number;
+
+    constructor(readonly view: CodeMirror.EditorView) {
+      this.teaser = teaser;
+      this.#teaserMode = view.state.field(aiCodeCompletionTeaserModeState);
+      this.#setupDecoration();
+    }
+
+    destroy(): void {
+      window.clearTimeout(this.#teaserDisplayTimeout);
+    }
+
+    update(update: CodeMirror.ViewUpdate): void {
+      const currentTeaserMode = update.state.field(aiCodeCompletionTeaserModeState);
+      if (currentTeaserMode !== this.#teaserMode) {
+        this.#teaserMode = currentTeaserMode;
+        this.#setupDecoration();
+        return;
+      }
+      if (this.#teaserMode === AiCodeCompletionTeaserMode.ONLY_SHOW_ON_EMPTY && update.docChanged) {
+        this.#updateTeaserDecorationForOnlyShowOnEmptyMode();
+      } else if (this.#teaserMode === AiCodeCompletionTeaserMode.ON) {
+        if (update.docChanged) {
+          this.#teaserDecoration = CodeMirror.Decoration.none;
+          window.clearTimeout(this.#teaserDisplayTimeout);
+          this.#updateTeaserDecorationForOnMode();
+        } else if (update.selectionSet && update.state.doc.length > 0) {
+          this.#teaserDecoration = CodeMirror.Decoration.none;
+        }
+      }
+    }
+
+    get decorations(): CodeMirror.DecorationSet {
+      return this.#teaserDecoration;
+    }
+
+    #setupDecoration(): void {
+      switch (this.#teaserMode) {
+        case AiCodeCompletionTeaserMode.ON:
+          this.#updateTeaserDecorationForOnModeImmediately();
+          return;
+        case AiCodeCompletionTeaserMode.ONLY_SHOW_ON_EMPTY:
+          this.#updateTeaserDecorationForOnlyShowOnEmptyMode();
+          return;
+        case AiCodeCompletionTeaserMode.OFF:
+          this.#teaserDecoration = CodeMirror.Decoration.none;
+          return;
+      }
+    }
+
+    #updateTeaserDecorationForOnlyShowOnEmptyMode(): void {
+      if (this.view.state.doc.length === 0) {
+        this.#addTeaserWidget(0);
+      } else {
+        this.#teaserDecoration = CodeMirror.Decoration.none;
+      }
+    }
+
+    #updateTeaserDecorationForOnMode = Common.Debouncer.debounce(() => {
+      this.#teaserDisplayTimeout = window.setTimeout(() => {
+        this.#updateTeaserDecorationForOnModeImmediately();
+        this.view.dispatch({});
+      }, DELAY_BEFORE_SHOWING_RESPONSE_MS);
+    }, AIDA_REQUEST_DEBOUNCE_TIMEOUT_MS);
+
+    #updateTeaserDecorationForOnModeImmediately(): void {
+      const cursorPosition = this.view.state.selection.main.head;
+      const line = this.view.state.doc.lineAt(cursorPosition);
+      if (cursorPosition >= line.to) {
+        this.#addTeaserWidget(cursorPosition);
+      }
+    }
+
+    #addTeaserWidget(pos: number): void {
+      this.#teaserDecoration = CodeMirror.Decoration.set([
+        CodeMirror.Decoration.widget({widget: new AiCodeCompletionTeaserPlaceholder(this.teaser), side: 1}).range(pos),
+      ]);
+    }
+  }, {
+    decorations: v => v.decorations,
+    eventHandlers: {
+      mousedown(event: MouseEvent): boolean {
+        // Required for mouse click to propagate to the "Don't show again" span in teaser.
+        return (event.target instanceof Node && teaser.contentElement.contains(event.target));
+      },
+      keydown(event: KeyboardEvent): boolean {
+        if (!UI.KeyboardShortcut.KeyboardShortcut.eventHasCtrlEquivalentKey(event) || !teaser.isShowing()) {
+          return false;
+        }
+        if (event.key === 'i') {
+          event.consume(true);
+          void VisualLogging.logKeyDown(event.currentTarget, event, 'ai-code-completion-teaser.fre');
+          void this.teaser.onAction(event);
+          return true;
+        }
+        if (event.key === 'x') {
+          event.consume(true);
+          void VisualLogging.logKeyDown(event.currentTarget, event, 'ai-code-completion-teaser.dismiss');
+          this.teaser.onDismiss(event);
+          return true;
+        }
+        return false;
+      }
+    },
+  });
+}

package/front_end/ui/components/text_editor/text_editor.ts

@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
+export * as AiCodeCompletionProvider from './AiCodeCompletionProvider.js';
 export * as AiCodeCompletionTeaserPlaceholder from './AiCodeCompletionTeaserPlaceholder.js';
 export * as AutocompleteHistory from './AutocompleteHistory.js';
 export * as Config from './config.js';