feat(deepnote): Add clearNotebookSelection method and update notebook deserialization logic

- Introduced `clearNotebookSelection` method in `DeepnoteNotebookManager` to reset notebook selection for a project.
- Updated `DeepnoteFileChangeWatcher` to call `clearNotebookSelection` during file change events, ensuring the active editor is prioritized during re-deserialization.
- Modified `deserializeNotebook` method in `DeepnoteNotebookSerializer` to accept an optional `notebookId` parameter, preventing race conditions when multiple notebooks from the same project are open.

Author: tkislan

src/notebooks/deepnote/deepnoteFileChangeWatcher.ts

@@ -235,6 +235,17 @@ export class DeepnoteFileChangeWatcher implements IExtensionSyncActivationServic
                 doc.notebookType === 'deepnote' && doc.uri.with({ query: '', fragment: '' }).toString() === uriString
         );
 
+        // Clear the global notebook selection so that any VS Code-triggered
+        // re-deserialization (e.g. from workspace.save) falls back to the
+        // active editor rather than a stale global selection.
+        for (const notebook of affectedNotebooks) {
+            const projectId = notebook.metadata?.deepnoteProjectId as string | undefined;
+            if (projectId) {
+                this.notebookManager.clearNotebookSelection(projectId);
+                break;
+            }
+        }
+
         for (const notebook of affectedNotebooks) {
             const nbKey = notebook.uri.toString();
             // main-file-sync always replaces any pending operation
@@ -276,10 +287,15 @@ export class DeepnoteFileChangeWatcher implements IExtensionSyncActivationServic
             return;
         }
 
+        // Pass the notebook ID explicitly to avoid mutating the global selection state.
+        // Multiple notebooks from the same project may be open simultaneously, and
+        // mutating selectedNotebookByProject would cause race conditions.
+        const notebookNotebookId = notebook.metadata?.deepnoteNotebookId as string | undefined;
+
         const tokenSource = new CancellationTokenSource();
         let newData;
         try {
-            newData = await this.serializer.deserializeNotebook(content, tokenSource.token);
+            newData = await this.serializer.deserializeNotebook(content, tokenSource.token, notebookNotebookId);
         } catch (error) {
             logger.warn(`[FileChangeWatcher] Failed to parse changed file: ${fileUri.path}`, error);
             return;

src/notebooks/deepnote/deepnoteNotebookManager.ts

@@ -14,6 +14,14 @@ export class DeepnoteNotebookManager implements IDeepnoteNotebookManager {
     private readonly projectsWithInitNotebookRun = new Set<string>();
     private readonly selectedNotebookByProject = new Map<string, string>();
 
+    /**
+     * Clears the notebook selection for a project so that subsequent
+     * deserializations fall back to the active editor or open documents.
+     */
+    clearNotebookSelection(projectId: string): void {
+        this.selectedNotebookByProject.delete(projectId);
+    }
+
     /**
      * Gets the currently selected notebook ID for a project.
      * @param projectId Project identifier

src/notebooks/deepnote/deepnoteNotebookManager.unit.test.ts

@@ -123,6 +123,33 @@ suite('DeepnoteNotebookManager', () => {
         });
     });
 
+    suite('clearNotebookSelection', () => {
+        test('should clear selection for a project', () => {
+            manager.selectNotebookForProject('project-123', 'notebook-456');
+            manager.clearNotebookSelection('project-123');
+
+            const selectedNotebook = manager.getTheSelectedNotebookForAProject('project-123');
+
+            assert.strictEqual(selectedNotebook, undefined);
+        });
+
+        test('should not affect other projects', () => {
+            manager.selectNotebookForProject('project-1', 'notebook-1');
+            manager.selectNotebookForProject('project-2', 'notebook-2');
+            manager.clearNotebookSelection('project-1');
+
+            assert.strictEqual(manager.getTheSelectedNotebookForAProject('project-1'), undefined);
+            assert.strictEqual(manager.getTheSelectedNotebookForAProject('project-2'), 'notebook-2');
+        });
+
+        test('should be idempotent for unknown project', () => {
+            assert.doesNotThrow(() => {
+                manager.clearNotebookSelection('unknown-project');
+                manager.clearNotebookSelection('unknown-project');
+            });
+        });
+    });
+
     suite('storeOriginalProject', () => {
         test('should store both project and current notebook ID', () => {
             manager.storeOriginalProject('project-123', mockProject, 'notebook-456');

src/notebooks/deepnote/deepnoteSerializer.ts

@@ -67,7 +67,11 @@ export class DeepnoteNotebookSerializer implements NotebookSerializer {
      * @param token Cancellation token (unused)
      * @returns Promise resolving to notebook data
      */
-    async deserializeNotebook(content: Uint8Array, token: CancellationToken): Promise<NotebookData> {
+    async deserializeNotebook(
+        content: Uint8Array,
+        token: CancellationToken,
+        notebookId?: string
+    ): Promise<NotebookData> {
         logger.debug('DeepnoteSerializer: Deserializing Deepnote notebook');
 
         if (token?.isCancellationRequested) {
@@ -90,16 +94,16 @@ export class DeepnoteNotebookSerializer implements NotebookSerializer {
             }
 
             const projectId = deepnoteFile.project.id;
-            const notebookId = this.findCurrentNotebookId(projectId);
+            const resolvedNotebookId = notebookId ?? this.findCurrentNotebookId(projectId);
 
-            logger.debug(`DeepnoteSerializer: Project ID: ${projectId}, Selected notebook ID: ${notebookId}`);
+            logger.debug(`DeepnoteSerializer: Project ID: ${projectId}, Selected notebook ID: ${resolvedNotebookId}`);
 
             if (deepnoteFile.project.notebooks.length === 0) {
                 throw new Error('Deepnote project contains no notebooks.');
             }
 
-            const selectedNotebook = notebookId
-                ? deepnoteFile.project.notebooks.find((nb) => nb.id === notebookId)
+            const selectedNotebook = resolvedNotebookId
+                ? deepnoteFile.project.notebooks.find((nb) => nb.id === resolvedNotebookId)
                 : this.findDefaultNotebook(deepnoteFile);
 
             if (!selectedNotebook) {

src/notebooks/deepnote/deepnoteSerializer.unit.test.ts

@@ -147,6 +147,34 @@ project:
                 /no notebooks|notebooks.*must contain at least 1/i
             );
         });
+
+        test('should deserialize the specified notebook when notebookId is passed', async () => {
+            const content = projectToYaml(mockProject);
+            const result = await serializer.deserializeNotebook(content, {} as any, 'notebook-2');
+
+            assert.strictEqual(result.metadata?.deepnoteNotebookId, 'notebook-2');
+            assert.strictEqual(result.metadata?.deepnoteNotebookName, 'Second Notebook');
+            assert.strictEqual(result.cells.length, 1);
+            assert.include(result.cells[0].value, 'Title');
+        });
+
+        test('should ignore stored selection when explicit notebookId is provided', async () => {
+            manager.selectNotebookForProject('project-123', 'notebook-1');
+            const content = projectToYaml(mockProject);
+            const result = await serializer.deserializeNotebook(content, {} as any, 'notebook-2');
+
+            assert.strictEqual(result.metadata?.deepnoteNotebookId, 'notebook-2');
+            assert.strictEqual(result.metadata?.deepnoteNotebookName, 'Second Notebook');
+        });
+
+        test('should fall back to findCurrentNotebookId when notebookId is undefined', async () => {
+            manager.selectNotebookForProject('project-123', 'notebook-1');
+            const content = projectToYaml(mockProject);
+            const result = await serializer.deserializeNotebook(content, {} as any);
+
+            assert.strictEqual(result.metadata?.deepnoteNotebookId, 'notebook-1');
+            assert.strictEqual(result.metadata?.deepnoteNotebookName, 'First Notebook');
+        });
     });
 
     suite('serializeNotebook', () => {
@@ -420,6 +448,36 @@ project:
             manager.selectNotebookForProject('project-123', 'notebook-3');
             assert.strictEqual(serializer.findCurrentNotebookId('project-123'), 'notebook-3');
         });
+
+        test('should return undefined when selection is cleared and no active editor', () => {
+            manager.selectNotebookForProject('project-123', 'notebook-456');
+            manager.clearNotebookSelection('project-123');
+
+            const result = serializer.findCurrentNotebookId('project-123');
+
+            assert.strictEqual(result, undefined);
+        });
+
+        test('should fall back to active editor after selection is cleared', () => {
+            manager.selectNotebookForProject('project-123', 'stored-wrong');
+            manager.clearNotebookSelection('project-123');
+
+            const mockActiveNotebook = {
+                notebookType: 'deepnote',
+                metadata: {
+                    deepnoteProjectId: 'project-123',
+                    deepnoteNotebookId: 'active-editor-notebook'
+                }
+            };
+
+            when(mockedVSCodeNamespaces.window.activeNotebookEditor).thenReturn({
+                notebook: mockActiveNotebook
+            } as any);
+
+            const result = serializer.findCurrentNotebookId('project-123');
+
+            assert.strictEqual(result, 'active-editor-notebook');
+        });
     });
 
     suite('component integration', () => {

src/notebooks/types.ts

@@ -37,6 +37,7 @@ export interface ProjectIntegration {
 
 export const IDeepnoteNotebookManager = Symbol('IDeepnoteNotebookManager');
 export interface IDeepnoteNotebookManager {
+    clearNotebookSelection(projectId: string): void;
     getCurrentNotebookId(projectId: string): string | undefined;
     getOriginalProject(projectId: string): DeepnoteProject | undefined;
     getTheSelectedNotebookForAProject(projectId: string): string | undefined;