match upstream default setting for editor.editContext (enabled) (#11006)

### Summary

- addresses #9327
- approach: update default `editor.editContext` setting to match
upstream, to fix output copying issue. If this setting is disabled in VS
Code, the same issue occurs there as well.
- small code change, but has widespread implications for e2e tests as
the target locators and corresponding methods now need to be compatible
with the `.native-edit-context` div, instead of a `textarea`

<details><summary>Range of tests failing (hoping to fix these in this
PR)</summary>
    
Essentially anything that is backed with a monaco editor involving copy
or paste, so Console, Notebook, Connections, Output, Assistant chat,
etc.
    
<img width="303" height="264" alt="image"
src="https://github.com/user-attachments/assets/a20e97f4-a3a9-4882-a7ba-2a256a9dda65"
/>
    
<img width="306" height="423" alt="image"
src="https://github.com/user-attachments/assets/bbbf0a43-096b-4150-8061-b35dce2d3b61"
/>
    
<img width="343" height="423" alt="image"
src="https://github.com/user-attachments/assets/a126b8e6-0abc-40ae-b9c8-d8046300d3de"
/>
    
    </details> 

### Release Notes

#### Bug Fixes

- Fix issue preventing text from being copied from Output pane (#9327)

### QA Notes

@:output

- added a test to copy ~1000 characters from the output pane and paste
to an editor
- the test is skipped because the assertion is failing in CI, though
passing locally for me. Seems like an issue with newlines/normalization
getting in the way of the string match

This setting was originally disabled by default for this reason:
> // Disable the edit context which is normally enabled.
> // It causes test failures due to changes in the DOM.

This was when the setting was still experimental, and the setting was
called `editor.experimentalEditContextEnabled` during that time

This setting was migrated to be non-experimental (with the current
setting name `editor.editContext`) in 1.102:
microsoft/vscode@312284e

Now that we are enabling `editor.editContext` by default, locators using
`textarea` have been updated to `.native-edit-context`, with the
exception of `test/e2e/pages/search.ts`, which seems to still actually
use a textarea.

Because of this change from `textarea` --> `.native-edit-context` div,
we can no longer call `.fill()` on the locators, because `Error:
locator.fill: Error: Element is not an <input>, <textarea> or
[contenteditable] element`, so `.fill()` has been replaced with
`.pressSequentially()`.

Author: sharon-wang

src/vs/editor/common/config/editorOptions.ts

@@ -6284,12 +6284,7 @@ export const EditorOptions = {
 	emptySelectionClipboard: register(new EditorEmptySelectionClipboard()),
 	dropIntoEditor: register(new EditorDropIntoEditor()),
 	editContext: register(new EditorBooleanOption(
-		// --- Start Positron ---
-		// Disable the edit context which is normally enabled.
-		// It causes test failures due to changes in the DOM.
-		// https://positpbc.slack.com/archives/C04FPQK3H9C/p1740750244836859
-		EditorOption.editContext, 'editContext', false,
-		// --- End Positron ---
+		EditorOption.editContext, 'editContext', true,
 		{
 			description: nls.localize('editContext', "Sets whether the EditContext API should be used instead of the text area to power input in the editor."),
 			included: platform.isChrome || platform.isEdge || platform.isNative

test/e2e/pages/console.ts

@@ -299,11 +299,11 @@ export class Console {
 		text: string,
 		maxRetries = 3
 	): Promise<void> {
-		const textarea = locator.locator('textarea');
+		const editContext = locator.locator('.native-edit-context');
 
 		for (let attempt = 1; attempt <= maxRetries; attempt++) {
 			// Attempt paste
-			await textarea.evaluate(async (element, evalText) => {
+			await editContext.evaluate(async (element, evalText) => {
 				const clipboardData = new DataTransfer();
 				clipboardData.setData('text/plain', evalText);
 				const clipboardEvent = new ClipboardEvent('paste', {

test/e2e/pages/editor.ts

@@ -133,12 +133,12 @@ export class Editor {
 	async waitForEditorFocus(filename: string, lineNumber: number, selectorPrefix = ''): Promise<void> {
 		const editor = [selectorPrefix || '', EDITOR(filename)].join(' ');
 		const line = `${editor} .view-lines > .view-line:nth-child(${lineNumber})`;
-		const textarea = `${editor} textarea`;
+		const editContext = `${editor} .native-edit-context`;
 
 		await this.code.driver.page.locator(line).click();
 
 		await expect(async () => {
-			await expect(this.code.driver.page.locator(textarea)).toBeFocused();
+			await expect(this.code.driver.page.locator(editContext)).toBeFocused();
 		}).toPass();
 	}
 

test/e2e/pages/editors.ts

@@ -83,7 +83,7 @@ export class Editors {
 	}
 
 	async waitForActiveEditor(fileName: string): Promise<any> {
-		const selector = `.editor-instance .monaco-editor[data-uri$="${fileName}"] textarea`;
+		const selector = `.editor-instance .monaco-editor[data-uri$="${fileName}"] .native-edit-context`;
 		await expect(this.code.driver.page.locator(selector)).toBeFocused();
 	}
 

test/e2e/pages/extensions.ts

@@ -13,7 +13,7 @@ export class Extensions {
 
 	async searchForExtension(id: string): Promise<void> {
 		await this.quickaccess.runCommand('Extensions: Focus on Extensions View', { exactLabelMatch: true });
-		await this.code.driver.page.locator('div.extensions-viewlet[id="workbench.view.extensions"] .monaco-editor textarea').fill(`@id:${id}`);
+		await this.code.driver.page.locator('div.extensions-viewlet[id="workbench.view.extensions"] .monaco-editor .native-edit-context').pressSequentially(`@id:${id}`);
 		await expect(this.code.driver.page.locator(`div.part.sidebar div.composite.title h2`)).toHaveText('Extensions: Marketplace');
 
 		let retrials = 1;

test/e2e/pages/notebooks.ts

@@ -194,12 +194,10 @@ export class Notebooks {
 
 			await this.code.driver.page.locator(editor).isVisible();
 
-			const textarea = `${editor} textarea`;
-			await expect(this.code.driver.page.locator(textarea)).toBeFocused();
+			const editContext = `${editor} .native-edit-context`;
+			await expect(this.code.driver.page.locator(editContext)).toBeFocused();
 
-			delay
-				? await this.code.driver.page.locator(textarea).pressSequentially(text, { delay })
-				: await this.code.driver.page.locator(textarea).fill(text);
+			await this.code.driver.page.locator(editContext).pressSequentially(text, { delay });
 		});
 	}
 

test/e2e/pages/notebooksPositron.ts

@@ -27,7 +27,7 @@ export class PositronNotebooks extends Notebooks {
 	private positronNotebook = this.code.driver.page.locator('.positron-notebook').first();
 	private newCellButton = this.code.driver.page.getByLabel(/new code cell/i);
 	private spinner = this.code.driver.page.getByLabel(/cell is executing/i);
-	editorAtIndex = (index: number) => this.cell.nth(index).locator('.positron-cell-editor-monaco-widget textarea');
+	editorAtIndex = (index: number) => this.cell.nth(index).locator('.positron-cell-editor-monaco-widget .native-edit-context');
 	cell = this.code.driver.page.locator('[data-testid="notebook-cell"]');
 	codeCell = this.code.driver.page.locator('[data-testid="notebook-cell"][aria-label="Code cell"]');
 	markdownCell = this.code.driver.page.locator(`[data-testid="notebook-cell"][aria-label="${MARKDOWN_ARIA_LABEL}"]`);
@@ -427,11 +427,7 @@ export class PositronNotebooks extends Notebooks {
 			const editor = this.editorAtIndex(cellIndex);
 			await editor.focus();
 
-			if (delay) {
-				await editor.pressSequentially(code, { delay });
-			} else {
-				await editor.fill(code);
-			}
+			await editor.pressSequentially(code, { delay });
 
 			if (run) {
 				await this.runCellButtonAtIndex(cellIndex).click();

test/e2e/pages/output.ts

@@ -1,14 +1,16 @@
 /*---------------------------------------------------------------------------------------------
- *  Copyright (C) 2024 Posit Software, PBC. All rights reserved.
+ *  Copyright (C) 2024-2025 Posit Software, PBC. All rights reserved.
  *  Licensed under the Elastic License 2.0. See LICENSE.txt for license information.
  *--------------------------------------------------------------------------------------------*/
 
 
+import * as os from 'os';
 import { Code } from '../infra/code';
 import { QuickAccess } from './quickaccess';
 import { QuickInput } from './quickInput';
 
 const OUTPUT_LINE = '.view-line';
+const OUTPUT_PANE = 'div[id="workbench.panel.output"]';
 
 /*
  *  Reuseable Positron output functionality for tests to leverage.
@@ -32,7 +34,78 @@ export class Output {
 	}
 
 	async waitForOutContaining(fragment: string) {
-		const outputLine = this.code.driver.page.locator(OUTPUT_LINE);
+		const outputPane = this.code.driver.page.locator(OUTPUT_PANE);
+		const outputLine = outputPane.locator(OUTPUT_LINE);
 		await outputLine.getByText(fragment).first().isVisible();
 	}
+
+	/**
+	 * Scroll to the top of the output pane
+	 */
+	async scrollToTop(): Promise<void> {
+		// First, ensure the output pane is focused
+		await this.quickaccess.runCommand('workbench.panel.output.focus');
+
+		// Use platform-specific keyboard shortcuts to scroll to top
+		const platform = os.platform();
+		if (platform === 'darwin') {
+			// On macOS, use Cmd+ArrowUp
+			await this.code.driver.page.keyboard.press('Meta+ArrowUp');
+		} else {
+			// On Windows/Linux, use Ctrl+Home
+			await this.code.driver.page.keyboard.press('Control+Home');
+		}
+	}
+
+	/**
+	 * Copy selected text from the output pane and return it
+	 */
+	async copySelectedText(): Promise<string> {
+		const isMac = os.platform() === 'darwin';
+		const modifier = isMac ? 'Meta' : 'Control';
+
+		await this.code.driver.page.keyboard.press(`${modifier}+C`);
+
+		// Wait a bit for the copy operation to complete
+		await this.code.driver.page.waitForTimeout(100);
+
+		// Grant permissions to read from clipboard
+		await this.code.driver.context.grantPermissions(['clipboard-read']);
+
+		// Read the clipboard content
+		const clipboardText = await this.code.driver.page.evaluate(async () => {
+			try {
+				return await navigator.clipboard.readText();
+			} catch (error) {
+				console.error('Failed to read clipboard text:', error);
+				return '';
+			}
+		});
+
+		return clipboardText;
+	}
+
+	/**
+	 * Select the first N lines of output text
+	 */
+	async selectFirstNLines(lineCount: number): Promise<void> {
+		const outputPane = this.code.driver.page.locator(OUTPUT_PANE);
+		const outputLines = outputPane.locator('.view-line');
+		const totalLines = await outputLines.count();
+
+		if (totalLines === 0) {
+			throw new Error('No output lines found in the output pane');
+		}
+
+		// Calculate how many lines to select (or all lines if less than N)
+		const linesToSelect = Math.min(lineCount, totalLines);
+		const endLineIndex = linesToSelect - 1;
+
+		// Click on the first line and then shift+click on the last line of selection
+		const startLine = outputLines.nth(0);
+		const endLine = outputLines.nth(endLineIndex);
+
+		await startLine.click();
+		await endLine.click({ modifiers: ['Shift'] });
+	}
 }

test/e2e/pages/positronAssistant.ts

@@ -32,7 +32,7 @@ const COPY_BUTTON = 'a.action-label.codicon.codicon-copy[role="button"][aria-lab
 const INSERT_NEW_FILE_BUTTON = 'a.action-label.codicon.codicon-new-file[role="button"][aria-label="Insert into New File"]';
 const OAUTH_RADIO = '.language-model-authentication-method-container input#oauth[type="radio"]';
 const APIKEY_RADIO = '.language-model-authentication-method-container input#apiKey[type="radio"]';
-const CHAT_INPUT = '.chat-editor-container .interactive-input-editor textarea.inputarea';
+const CHAT_INPUT = '.chat-editor-container .interactive-input-editor .native-edit-context';
 const SEND_MESSAGE_BUTTON = '.actions-container .action-label.codicon-send[aria-label^="Send"]';
 const NEW_CHAT_BUTTON = '.composite.title .actions-container[aria-label="Chat actions"] .action-item .action-label.codicon-plus[aria-label^="New Chat"]';
 const INLINE_CHAT_TOOLBAR = '.interactive-input-part.compact .chat-input-toolbars';
@@ -199,7 +199,7 @@ export class Assistant {
 	async enterChatMessage(message: string, waitForResponse: boolean = true) {
 		const chatInput = this.code.driver.page.locator(CHAT_INPUT);
 		await chatInput.waitFor({ state: 'visible' });
-		await chatInput.fill(message);
+		await chatInput.pressSequentially(message);
 		await this.code.driver.page.locator(SEND_MESSAGE_BUTTON).click();
 		// It can take a moment for the loading locator to become visible.
 		await this.code.driver.page.locator('.chat-most-recent-response.chat-response-loading').waitFor({ state: 'visible' });

test/e2e/pages/scm.ts

@@ -12,7 +12,7 @@ import { Layouts } from './layouts';
  */
 
 const VIEWLET = 'div[id="workbench.view.scm"]';
-const SCM_INPUT_TEXTAREA = `${VIEWLET} .scm-editor textarea`;
+const SCM_INPUT_EDIT_CONTEXT = `${VIEWLET} .scm-editor .native-edit-context`;
 const SCM_RESOURCE_CLICK = (name: string) => `${VIEWLET} .monaco-list-row .resource .monaco-icon-label[aria-label*="${name}"] .label-name`;
 const SCM_RESOURCE_ACTION_CLICK = (name: string, actionName: string) => `.monaco-list-row .resource .monaco-icon-label[aria-label*="${name}"] .actions .action-label[aria-label="${actionName}"]`;
 const COMMIT_COMMAND = `div[id="workbench.parts.sidebar"] .actions-container a.action-label[aria-label="Commit"]`;
@@ -24,7 +24,7 @@ export class SCM {
 
 	async openSCMViewlet(): Promise<any> {
 		await this.code.driver.page.keyboard.press('Control+Shift+G');
-		await expect(this.code.driver.page.locator(SCM_INPUT_TEXTAREA)).toBeVisible();
+		await expect(this.code.driver.page.locator(SCM_INPUT_EDIT_CONTEXT)).toBeVisible();
 	}
 
 	async waitForChange(name: string, type: 'Staged' | 'Modified'): Promise<void> {
@@ -57,9 +57,9 @@ export class SCM {
 
 	async commit(message: string): Promise<void> {
 		await this.code.driver.page.keyboard.press('Control+Shift+G'); // need to switch to scm view as it may have reset
-		await this.code.driver.page.locator(SCM_INPUT_TEXTAREA).click({ force: true });
-		await expect(this.code.driver.page.locator(SCM_INPUT_TEXTAREA)).toBeFocused();
-		await this.code.driver.page.locator(SCM_INPUT_TEXTAREA).fill(message);
+		await this.code.driver.page.locator(SCM_INPUT_EDIT_CONTEXT).click({ force: true });
+		await expect(this.code.driver.page.locator(SCM_INPUT_EDIT_CONTEXT)).toBeFocused();
+		await this.code.driver.page.locator(SCM_INPUT_EDIT_CONTEXT).pressSequentially(message);
 		await this.code.driver.page.locator(COMMIT_COMMAND).click();
 	}