fix: debounce output clearing during cell re-execution to prevent flash

When a notebook cell is re-run, the runtime immediately clears outputs
before sending new ones. This caused the output container to briefly
disappear and reappear, producing a distracting flash. Defer the visual
clear by 150ms when execution is active so fast-completing cells never
flash. Flush the deferred clear immediately when execution ends.

Author: nstrayer

src/vs/workbench/contrib/positronNotebook/browser/PositronNotebookCells/PositronNotebookCodeCell.ts

@@ -4,7 +4,7 @@
  *--------------------------------------------------------------------------------------------*/
 
 import { Event } from '../../../../../base/common/event.js';
-import { ISettableObservable, observableFromEvent, observableValue } from '../../../../../base/common/observable.js';
+import { ISettableObservable, observableValue } from '../../../../../base/common/observable.js';
 import { ITextModelService } from '../../../../../editor/common/services/resolverService.js';
 import { NotebookCellTextModel } from '../../../notebook/common/model/notebookCellTextModel.js';
 import { CellKind } from '../../../notebook/common/notebookCommon.js';
@@ -15,12 +15,12 @@ import { IPositronNotebookCodeCell, NotebookCellOutputs } from './IPositronNoteb
 import { IPositronWebviewPreloadService } from '../../../../services/positronWebviewPreloads/browser/positronWebviewPreloadService.js';
 import { pickPreferredOutputItem } from './notebookOutputUtils.js';
 import { getWebviewMessageType, isComplexHtml } from '../../../../services/positronIPyWidgets/common/webviewPreloadUtils.js';
-import { INotebookExecutionStateService } from '../../../notebook/common/notebookExecutionStateService.js';
+import { INotebookExecutionStateService, NotebookExecutionType } from '../../../notebook/common/notebookExecutionStateService.js';
 import { IPositronCellOutputViewModel } from '../IPositronNotebookEditor.js';
 
 export class PositronNotebookCodeCell extends PositronNotebookCellGeneral implements IPositronNotebookCodeCell {
 	override kind: CellKind.Code = CellKind.Code;
-	private readonly _outputs;
+	private readonly _outputs: ISettableObservable<NotebookCellOutputs[]>;
 
 	// Output collapse state
 	private readonly _outputIsCollapsed: ISettableObservable<boolean>;
@@ -55,9 +55,61 @@ export class PositronNotebookCodeCell extends PositronNotebookCellGeneral implem
 			undefined
 		);
 
-		this._outputs = observableFromEvent(this, Event.any(this.model.onDidChangeOutputs, this.model.onDidChangeOutputItems), () => {
-			/** @description cellOutputs */
-			return this.parseCellOutputs();
+		// Initialize with current outputs. Uses observableValue (manually updated)
+		// instead of observableFromEvent so we can defer output clearing during
+		// execution to prevent a visual flash when re-running cells.
+		this._outputs = observableValue('cellOutputs', this.parseCellOutputs());
+
+		// Debounce output clearing during cell execution to prevent visual flash.
+		// When a cell is re-run, the runtime immediately clears outputs before
+		// sending new ones. Without debouncing, the output container briefly
+		// disappears and reappears, causing a distracting flash.
+		let clearOutputsTimer: ReturnType<typeof setTimeout> | undefined;
+		this._register(Event.any(this.model.onDidChangeOutputs, this.model.onDidChangeOutputItems)(() => {
+			const newOutputs = this.parseCellOutputs();
+
+			// Cancel any pending deferred clear.
+			if (clearOutputsTimer !== undefined) {
+				clearTimeout(clearOutputsTimer);
+				clearOutputsTimer = undefined;
+			}
+
+			if (newOutputs.length > 0) {
+				// New outputs available -- show immediately.
+				this._outputs.set(newOutputs, undefined);
+			} else if (_executionStateService.getCellExecution(this.uri)) {
+				// Outputs cleared during active execution (re-run). Defer the
+				// visual clear so fast-completing executions never flash.
+				clearOutputsTimer = setTimeout(() => {
+					clearOutputsTimer = undefined;
+					this._outputs.set(this.parseCellOutputs(), undefined);
+				}, 150);
+			} else {
+				// Outputs cleared outside execution (user action) -- immediately.
+				this._outputs.set(newOutputs, undefined);
+			}
+		}));
+
+		// When execution ends, flush any deferred clear immediately.
+		// Only re-parse when a timer is pending to avoid redundant calls to
+		// parseCellOutputs() which has side effects (addNotebookOutput).
+		this._register(_executionStateService.onDidChangeExecution(e => {
+			if (e.type === NotebookExecutionType.cell && e.affectsCell(this.model.uri) && !e.changed) {
+				if (clearOutputsTimer !== undefined) {
+					clearTimeout(clearOutputsTimer);
+					clearOutputsTimer = undefined;
+					this._outputs.set(this.parseCellOutputs(), undefined);
+				}
+			}
+		}));
+
+		// Clean up timer on dispose.
+		this._register({
+			dispose: () => {
+				if (clearOutputsTimer !== undefined) {
+					clearTimeout(clearOutputsTimer);
+				}
+			}
 		});
 
 		// Reset collapse state when outputs are cleared so new outputs aren't born collapsed