@codingame/monaco-vscode-notebook-service-override 37.1.0 → 37.3.0

package/vscode/src/vs/workbench/contrib/notebook/common/notebookEditorModel.js

@@ -0,0 +1,352 @@
+
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { streamToBuffer } from '@codingame/monaco-vscode-api/vscode/vs/base/common/buffer';
+import { CancellationError } from '@codingame/monaco-vscode-api/vscode/vs/base/common/errors';
+import { Emitter } from '@codingame/monaco-vscode-api/vscode/vs/base/common/event';
+import { DisposableStore, Disposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import { Schemas } from '@codingame/monaco-vscode-api/vscode/vs/base/common/network';
+import { hasKey, assertType } from '@codingame/monaco-vscode-api/vscode/vs/base/common/types';
+import { IConfigurationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration.service';
+import { FileOperationError, FileOperationResult } from '@codingame/monaco-vscode-api/vscode/vs/platform/files/common/files';
+import { ITelemetryService } from '@codingame/monaco-vscode-api/vscode/vs/platform/telemetry/common/telemetry.service';
+import { EditorModel } from '@codingame/monaco-vscode-api/vscode/vs/workbench/common/editor/editorModel';
+import { NotebookCellsChangeType, NotebookSetting } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/notebook/common/notebookCommon';
+import { INotebookLoggingService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/notebook/common/notebookLoggingService.service';
+import { SimpleNotebookProviderInfo } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/notebook/common/notebookService';
+import { INotebookService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/notebook/common/notebookService.service';
+import { IFilesConfigurationService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/filesConfiguration/common/filesConfigurationService.service';
+import { StoredFileWorkingCopyState } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/workingCopy/common/storedFileWorkingCopy';
+import { WorkingCopyCapabilities } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/workingCopy/common/workingCopy';
+
+var SimpleNotebookEditorModel_1;
+let SimpleNotebookEditorModel = SimpleNotebookEditorModel_1 = class SimpleNotebookEditorModel extends EditorModel {
+    constructor(
+        resource,
+        _hasAssociatedFilePath,
+        viewType,
+        _workingCopyManager,
+        scratchpad,
+        _filesConfigurationService
+    ) {
+        super();
+        this.resource = resource;
+        this._hasAssociatedFilePath = _hasAssociatedFilePath;
+        this.viewType = viewType;
+        this._workingCopyManager = _workingCopyManager;
+        this._filesConfigurationService = _filesConfigurationService;
+        this._onDidChangeDirty = this._register(( new Emitter()));
+        this._onDidSave = this._register(( new Emitter()));
+        this._onDidChangeOrphaned = this._register(( new Emitter()));
+        this._onDidChangeReadonly = this._register(( new Emitter()));
+        this._onDidRevertUntitled = this._register(( new Emitter()));
+        this.onDidChangeDirty = this._onDidChangeDirty.event;
+        this.onDidSave = this._onDidSave.event;
+        this.onDidChangeOrphaned = this._onDidChangeOrphaned.event;
+        this.onDidChangeReadonly = this._onDidChangeReadonly.event;
+        this.onDidRevertUntitled = this._onDidRevertUntitled.event;
+        this._workingCopyListeners = this._register(( new DisposableStore()));
+        this.scratchPad = scratchpad;
+    }
+    dispose() {
+        this._workingCopy?.dispose();
+        super.dispose();
+    }
+    get notebook() {
+        return this._workingCopy?.model?.notebookModel;
+    }
+    isResolved() {
+        return Boolean(this._workingCopy?.model?.notebookModel);
+    }
+    async canDispose() {
+        if (!this._workingCopy) {
+            return true;
+        }
+        if (SimpleNotebookEditorModel_1._isStoredFileWorkingCopy(this._workingCopy)) {
+            return this._workingCopyManager.stored.canDispose(this._workingCopy);
+        } else {
+            return true;
+        }
+    }
+    isDirty() {
+        return this._workingCopy?.isDirty() ?? false;
+    }
+    isModified() {
+        return this._workingCopy?.isModified() ?? false;
+    }
+    isOrphaned() {
+        return SimpleNotebookEditorModel_1._isStoredFileWorkingCopy(this._workingCopy) && this._workingCopy.hasState(StoredFileWorkingCopyState.ORPHAN);
+    }
+    hasAssociatedFilePath() {
+        return !SimpleNotebookEditorModel_1._isStoredFileWorkingCopy(this._workingCopy) && !!this._workingCopy?.hasAssociatedFilePath;
+    }
+    isReadonly() {
+        if (SimpleNotebookEditorModel_1._isStoredFileWorkingCopy(this._workingCopy)) {
+            return this._workingCopy?.isReadonly();
+        } else {
+            return this._filesConfigurationService.isReadonly(this.resource);
+        }
+    }
+    get hasErrorState() {
+        if (this._workingCopy && hasKey(this._workingCopy, {
+            hasState: true
+        })) {
+            return this._workingCopy.hasState(StoredFileWorkingCopyState.ERROR);
+        }
+        return false;
+    }
+    async revert(options) {
+        assertType(this.isResolved());
+        return this._workingCopy.revert(options);
+    }
+    async save(options) {
+        assertType(this.isResolved());
+        return this._workingCopy.save(options);
+    }
+    async load(options) {
+        if (!this._workingCopy || !this._workingCopy.model) {
+            if (this.resource.scheme === Schemas.untitled) {
+                if (this._hasAssociatedFilePath) {
+                    this._workingCopy = await this._workingCopyManager.resolve({
+                        associatedResource: this.resource
+                    });
+                } else {
+                    this._workingCopy = await this._workingCopyManager.resolve({
+                        untitledResource: this.resource,
+                        isScratchpad: this.scratchPad
+                    });
+                }
+                this._register(this._workingCopy.onDidRevert(() => this._onDidRevertUntitled.fire()));
+            } else {
+                this._workingCopy = await this._workingCopyManager.resolve(this.resource, {
+                    limits: options?.limits,
+                    reload: options?.forceReadFromFile ? {
+                        async: false,
+                        force: true
+                    } : undefined
+                });
+                this._workingCopyListeners.add(this._workingCopy.onDidSave(e => this._onDidSave.fire(e)));
+                this._workingCopyListeners.add(
+                    this._workingCopy.onDidChangeOrphaned(() => this._onDidChangeOrphaned.fire())
+                );
+                this._workingCopyListeners.add(
+                    this._workingCopy.onDidChangeReadonly(() => this._onDidChangeReadonly.fire())
+                );
+            }
+            this._workingCopyListeners.add(
+                this._workingCopy.onDidChangeDirty(() => this._onDidChangeDirty.fire(), undefined)
+            );
+            this._workingCopyListeners.add(this._workingCopy.onWillDispose(() => {
+                this._workingCopyListeners.clear();
+                this._workingCopy?.model?.dispose();
+            }));
+        } else {
+            await this._workingCopyManager.resolve(this.resource, {
+                reload: {
+                    async: !options?.forceReadFromFile,
+                    force: options?.forceReadFromFile
+                },
+                limits: options?.limits
+            });
+        }
+        assertType(this.isResolved());
+        return this;
+    }
+    async saveAs(target) {
+        const newWorkingCopy = await this._workingCopyManager.saveAs(this.resource, target);
+        if (!newWorkingCopy) {
+            return undefined;
+        }
+        return {
+            resource: newWorkingCopy.resource
+        };
+    }
+    static _isStoredFileWorkingCopy(candidate) {
+        const isUntitled = candidate && candidate.capabilities & WorkingCopyCapabilities.Untitled;
+        return !isUntitled;
+    }
+};
+SimpleNotebookEditorModel = SimpleNotebookEditorModel_1 = ( __decorate([( __param(5, IFilesConfigurationService))], SimpleNotebookEditorModel));
+class NotebookFileWorkingCopyModel extends Disposable {
+    constructor(
+        _notebookModel,
+        _notebookService,
+        _configurationService,
+        _telemetryService,
+        _notebookLogService
+    ) {
+        super();
+        this._notebookModel = _notebookModel;
+        this._notebookService = _notebookService;
+        this._configurationService = _configurationService;
+        this._telemetryService = _telemetryService;
+        this._notebookLogService = _notebookLogService;
+        this._onDidChangeContent = this._register(( new Emitter()));
+        this.onDidChangeContent = this._onDidChangeContent.event;
+        this.configuration = undefined;
+        this.onWillDispose = _notebookModel.onWillDispose.bind(_notebookModel);
+        this._register(_notebookModel.onDidChangeContent(e => {
+            for (const rawEvent of e.rawEvents) {
+                if (rawEvent.kind === NotebookCellsChangeType.Initialize) {
+                    continue;
+                }
+                if (rawEvent.transient) {
+                    continue;
+                }
+                this._onDidChangeContent.fire({
+                    isRedoing: false,
+                    isUndoing: false,
+                    isInitial: false
+                });
+                break;
+            }
+        }));
+        const saveWithReducedCommunication = this._configurationService.getValue(NotebookSetting.remoteSaving);
+        if (saveWithReducedCommunication || _notebookModel.uri.scheme === Schemas.vscodeRemote) {
+            this.configuration = {
+                backupDelay: 10000
+            };
+        }
+        if (saveWithReducedCommunication) {
+            this.setSaveDelegate().catch(
+                error => this._notebookLogService.error("WorkingCopyModel", `Failed to set save delegate: ${error}`)
+            );
+        }
+    }
+    async setSaveDelegate() {
+        await this.getNotebookSerializer();
+        this.save = async (options, token) => {
+            try {
+                let serializer = this._notebookService.tryGetDataProviderSync(this.notebookModel.viewType)?.serializer;
+                if (!serializer) {
+                    this._notebookLogService.info(
+                        "WorkingCopyModel",
+                        "No serializer found for notebook model, checking if provider still needs to be resolved"
+                    );
+                    serializer = await this.getNotebookSerializer().catch(error => {
+                        this._notebookLogService.error("WorkingCopyModel", `Failed to get notebook serializer: ${error}`);
+                        this.save = undefined;
+                        throw ( new NotebookSaveError("Failed to get notebook serializer"));
+                    });
+                }
+                if (token.isCancellationRequested) {
+                    throw ( new CancellationError());
+                }
+                const stat = await serializer.save(this._notebookModel.uri, this._notebookModel.versionId, options, token);
+                return stat;
+            } catch (error) {
+                if (!token.isCancellationRequested && error.name !== "Canceled") {
+                    const isIPynb = this._notebookModel.viewType === "jupyter-notebook" || this._notebookModel.viewType === "interactive";
+                    const errorMessage = getSaveErrorMessage(error);
+                    this._telemetryService.publicLogError2("notebook/SaveError", {
+                        isRemote: this._notebookModel.uri.scheme === Schemas.vscodeRemote,
+                        isIPyNbWorkerSerializer: isIPynb && this._configurationService.getValue("ipynb.experimental.serialization"),
+                        error: errorMessage
+                    });
+                }
+                throw error;
+            }
+        };
+    }
+    dispose() {
+        this._notebookModel.dispose();
+        super.dispose();
+    }
+    get notebookModel() {
+        return this._notebookModel;
+    }
+    async snapshot(context, token) {
+        return this._notebookService.createNotebookTextDocumentSnapshot(this._notebookModel.uri, context, token);
+    }
+    async update(stream, token) {
+        const serializer = await this.getNotebookSerializer();
+        const bytes = await streamToBuffer(stream);
+        const data = await serializer.dataToNotebook(bytes);
+        if (token.isCancellationRequested) {
+            throw ( new CancellationError());
+        }
+        this._notebookLogService.info(
+            "WorkingCopyModel",
+            "Notebook content updated from file system - " + ( this._notebookModel.uri.toString())
+        );
+        this._notebookModel.reset(data.cells, data.metadata, serializer.options);
+    }
+    async getNotebookSerializer() {
+        const info = await this._notebookService.withNotebookDataProvider(this.notebookModel.viewType);
+        if (!(info instanceof SimpleNotebookProviderInfo)) {
+            const message = "CANNOT open notebook with this provider";
+            throw ( new NotebookSaveError(message));
+        }
+        return info.serializer;
+    }
+    get versionId() {
+        return this._notebookModel.alternativeVersionId;
+    }
+    pushStackElement() {
+        this._notebookModel.pushStackElement();
+    }
+}
+let NotebookFileWorkingCopyModelFactory = class NotebookFileWorkingCopyModelFactory {
+    constructor(
+        _viewType,
+        _notebookService,
+        _configurationService,
+        _telemetryService,
+        _notebookLogService
+    ) {
+        this._viewType = _viewType;
+        this._notebookService = _notebookService;
+        this._configurationService = _configurationService;
+        this._telemetryService = _telemetryService;
+        this._notebookLogService = _notebookLogService;
+    }
+    async createModel(resource, stream, token) {
+        const notebookModel = this._notebookService.getNotebookTextModel(resource) ?? (await this._notebookService.createNotebookTextModel(this._viewType, resource, stream));
+        return ( new NotebookFileWorkingCopyModel(
+            notebookModel,
+            this._notebookService,
+            this._configurationService,
+            this._telemetryService,
+            this._notebookLogService
+        ));
+    }
+};
+NotebookFileWorkingCopyModelFactory = ( __decorate([( __param(1, INotebookService)), ( __param(2, IConfigurationService)), ( __param(3, ITelemetryService)), ( __param(4, INotebookLoggingService))], NotebookFileWorkingCopyModelFactory));
+class NotebookSaveError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "NotebookSaveError";
+    }
+}
+function getSaveErrorMessage(error) {
+    if (error.name === "NotebookSaveError") {
+        return error.message;
+    } else if (error instanceof FileOperationError) {
+        switch (error.fileOperationResult) {
+        case FileOperationResult.FILE_IS_DIRECTORY:
+            return "File is a directory";
+        case FileOperationResult.FILE_NOT_FOUND:
+            return "File not found";
+        case FileOperationResult.FILE_NOT_MODIFIED_SINCE:
+            return "File not modified since";
+        case FileOperationResult.FILE_MODIFIED_SINCE:
+            return "File modified since";
+        case FileOperationResult.FILE_MOVE_CONFLICT:
+            return "File move conflict";
+        case FileOperationResult.FILE_WRITE_LOCKED:
+            return "File write locked";
+        case FileOperationResult.FILE_PERMISSION_DENIED:
+            return "File permission denied";
+        case FileOperationResult.FILE_TOO_LARGE:
+            return "File too large";
+        case FileOperationResult.FILE_INVALID_PATH:
+            return "File invalid path";
+        case FileOperationResult.FILE_NOT_DIRECTORY:
+            return "File not directory";
+        case FileOperationResult.FILE_OTHER_ERROR:
+            return "File other error";
+        }
+    }
+    return "Unknown error";
+}
+
+export { NotebookFileWorkingCopyModel, NotebookFileWorkingCopyModelFactory, SimpleNotebookEditorModel };

package/vscode/src/vs/workbench/contrib/notebook/common/notebookEditorModelResolverServiceImpl.js

@@ -3,7 +3,7 @@ import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib
 import { IInstantiationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation';
 import { URI } from '@codingame/monaco-vscode-api/vscode/vs/base/common/uri';
 import { NotebookWorkingCopyTypeIdentifier, NotebookSetting, CellUri } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/notebook/common/notebookCommon';
-import { NotebookFileWorkingCopyModelFactory, SimpleNotebookEditorModel } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/notebook/common/notebookEditorModel';
+import { NotebookFileWorkingCopyModelFactory, SimpleNotebookEditorModel } from './notebookEditorModel.js';
 import { ReferenceCollection, DisposableStore, dispose, combinedDisposable, toDisposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
 import { INotebookService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/notebook/common/notebookService.service';
 import { Emitter, AsyncEmitter } from '@codingame/monaco-vscode-api/vscode/vs/base/common/event';

package/vscode/src/vs/workbench/contrib/notebook/common/notebookOutputRenderer.js

@@ -32,9 +32,9 @@ class NotebookOutputRendererInfo {
         }
         this.displayName = descriptor.displayName;
         this.mimeTypes = descriptor.mimeTypes;
-        this.mimeTypeGlobs = ( this.mimeTypes.map(pattern => parse(pattern, {
+        this.mimeTypeGlobs = this.mimeTypes.map(pattern => parse(pattern, {
             ignoreCase: true
-        })));
+        }));
         this.hardDependencies = ( new DependencyList(descriptor.dependencies ?? Iterable.empty()));
         this.optionalDependencies = ( new DependencyList(descriptor.optionalDependencies ?? Iterable.empty()));
         this.messaging = descriptor.requiresMessaging ?? RendererMessagingSpec.Never;
@@ -72,7 +72,7 @@ class NotebookStaticPreloadInfo {
         this.type = descriptor.type;
         this.entrypoint = joinPath(descriptor.extension.extensionLocation, descriptor.entrypoint);
         this.extensionLocation = descriptor.extension.extensionLocation;
-        this.localResourceRoots = ( descriptor.localResourceRoots.map(root => joinPath(descriptor.extension.extensionLocation, root)));
+        this.localResourceRoots = descriptor.localResourceRoots.map(root => joinPath(descriptor.extension.extensionLocation, root));
     }
 }
 

package/vscode/src/vs/workbench/contrib/notebook/common/services/notebookWebWorker.js

@@ -10,9 +10,9 @@ import { MirrorModel } from '@codingame/monaco-vscode-api/vscode/vs/editor/commo
 import { DefaultEndOfLine } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/model';
 import { filter } from '@codingame/monaco-vscode-api/vscode/vs/base/common/objects';
 import { matchCellBasedOnSimilarties } from './notebookCellMatching.js';
-import '@codingame/monaco-vscode-api/vscode/vs/base/common/uuid';
+import { generateUuid } from '@codingame/monaco-vscode-api/vscode/vs/base/common/uuid';
 import { DiffChange } from '@codingame/monaco-vscode-api/vscode/vs/base/common/diff/diffChange';
-import { computeDiff } from '@codingame/monaco-vscode-katex-common/vscode/vs/workbench/contrib/notebook/common/notebookDiff';
+import { computeDiff } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/notebook/common/notebookDiff';
 
 const PREFIX_FOR_UNMATCHED_ORIGINAL_CELLS = `unmatchedOriginalCell`;
 class MirrorCell {
@@ -65,7 +65,7 @@ class MirrorCell {
                 hashValue = doHash(output.mime, hashValue);
             }
         }
-        const digests = this.outputs.flatMap(op => ( op.outputs.map(o => hash(Array.from(o.data.buffer)))));
+        const digests = this.outputs.flatMap(op => op.outputs.map(o => hash(Array.from(o.data.buffer))));
         for (const digest of digests) {
             hashValue = numberHash(digest, hashValue);
         }
@@ -114,26 +114,26 @@ class MirrorNotebookDocument {
     _spliceNotebookCells(splices) {
         splices.reverse().forEach(splice => {
             const cellDtos = splice[2];
-            const newCells = ( cellDtos.map(cell => {
+            const newCells = cellDtos.map(cell => {
                 return ( new MirrorCell(cell.handle, ( URI.parse(cell.url)), cell.source, cell.eol, cell.versionId, cell.language, cell.cellKind, cell.outputs, cell.metadata));
-            }));
+            });
             this.cells.splice(splice[0], splice[1], ...newCells);
         });
     }
 }
 class CellSequence {
     static create(textModel) {
-        const hashValue = ( textModel.cells.map(c => c.getComparisonValue()));
+        const hashValue = textModel.cells.map(c => c.getComparisonValue());
         return ( new CellSequence(hashValue));
     }
     static createWithCellId(cells, includeCellContents) {
-        const hashValue = ( cells.map(c => {
+        const hashValue = cells.map(c => {
             if (includeCellContents) {
                 return `${doHash(c.internalMetadata?.internalId, numberHash(104579, 0))}#${c.getComparisonValue()}`;
             } else {
                 return `${doHash(c.internalMetadata?.internalId, numberHash(104579, 0))}}`;
             }
-        }));
+        });
         return ( new CellSequence(hashValue));
     }
     constructor(hashValue) {
@@ -150,7 +150,7 @@ class NotebookWorker {
     }
     dispose() {}
     $acceptNewModel(uri, metadata, transientDocumentMetadata, cells) {
-        this._models[uri] = ( new MirrorNotebookDocument(( URI.parse(uri)), ( cells.map(dto => ( new MirrorCell(dto.handle, ( URI.parse(dto.url)), dto.source, dto.eol, dto.versionId, dto.language, dto.cellKind, dto.outputs, dto.metadata, dto.internalMetadata)))), metadata, transientDocumentMetadata));
+        this._models[uri] = ( new MirrorNotebookDocument(( URI.parse(uri)), cells.map(dto => ( new MirrorCell(dto.handle, ( URI.parse(dto.url)), dto.source, dto.eol, dto.versionId, dto.language, dto.cellKind, dto.outputs, dto.metadata, dto.internalMetadata))), metadata, transientDocumentMetadata));
     }
     $acceptModelChanged(strURL, event) {
         const model = this._models[strURL];
@@ -286,40 +286,66 @@ class NotebookWorker {
         return this.canComputeDiffWithCellInternalIds(original, modified) || this.canComputeDiffWithCellMetadataIds(original, modified);
     }
     canComputeDiffWithCellInternalIds(original, modified) {
-        const originalCellIndexIds = ( original.cells.map((cell, index) => ({
+        const originalCellIndexIds = original.cells.map((cell, index) => ({
             index,
             id: (cell.internalMetadata?.internalId || "")
-        })));
-        const modifiedCellIndexIds = ( modified.cells.map((cell, index) => ({
+        }));
+        const modifiedCellIndexIds = modified.cells.map((cell, index) => ({
             index,
             id: (cell.internalMetadata?.internalId || "")
-        })));
+        }));
         if (( originalCellIndexIds.some(c => !c.id)) || ( modifiedCellIndexIds.some(c => !c.id))) {
             return false;
         }
         return ( originalCellIndexIds.some(c => modifiedCellIndexIds.find(m => m.id === c.id)));
     }
     canComputeDiffWithCellMetadataIds(original, modified) {
-        const originalCellIndexIds = ( original.cells.map((cell, index) => ({
+        const originalCellIndexIds = original.cells.map((cell, index) => ({
             index,
             id: (cell.metadata?.id || "")
-        })));
-        const modifiedCellIndexIds = ( modified.cells.map((cell, index) => ({
+        }));
+        const modifiedCellIndexIds = modified.cells.map((cell, index) => ({
             index,
             id: (cell.metadata?.id || "")
-        })));
+        }));
         if (( originalCellIndexIds.some(c => !c.id)) || ( modifiedCellIndexIds.some(c => !c.id))) {
             return false;
         }
         if (originalCellIndexIds.every(c => !modifiedCellIndexIds.find(m => m.id === c.id))) {
             return false;
         }
+        original.cells.map((cell, index) => {
+            cell.internalMetadata = cell.internalMetadata || {};
+            cell.internalMetadata.internalId = cell.metadata?.id || "";
+        });
+        modified.cells.map((cell, index) => {
+            cell.internalMetadata = cell.internalMetadata || {};
+            cell.internalMetadata.internalId = cell.metadata?.id || "";
+        });
         return true;
     }
     isOriginalCellMatchedWithModifiedCell(originalCell) {
         return (originalCell.internalMetadata?.internalId || "").startsWith(PREFIX_FOR_UNMATCHED_ORIGINAL_CELLS);
     }
     updateCellIdsBasedOnMappings(mappings, originalCells, modifiedCells) {
+        const uuids = ( new Map());
+        originalCells.map((cell, index) => {
+            cell.internalMetadata = cell.internalMetadata || {
+                internalId: ""
+            };
+            cell.internalMetadata.internalId = `${PREFIX_FOR_UNMATCHED_ORIGINAL_CELLS}${generateUuid()}`;
+            const found = mappings.find(r => r.original === index);
+            if (found) {
+                cell.internalMetadata.internalId = generateUuid();
+                uuids.set(found.modified, cell.internalMetadata.internalId);
+            }
+        });
+        modifiedCells.map((cell, index) => {
+            cell.internalMetadata = cell.internalMetadata || {
+                internalId: ""
+            };
+            cell.internalMetadata.internalId = uuids.get(index) ?? generateUuid();
+        });
         return true;
     }
     $canPromptRecommendation(modelUrl) {
@@ -362,7 +388,7 @@ function create() {
 class NotebookTextModelFacade {
     constructor(notebook) {
         this.notebook = notebook;
-        this.cells = ( notebook.cells.map(cell => ( new NotebookCellTextModelFacade(cell))));
+        this.cells = notebook.cells.map(cell => ( new NotebookCellTextModelFacade(cell)));
     }
 }
 class NotebookCellTextModelFacade {

package/vscode/src/vs/workbench/contrib/replNotebook/browser/repl.contribution.js

@@ -43,9 +43,9 @@ import { REPL_EDITOR_ID, NotebookSetting, NotebookWorkingCopyTypeIdentifier, Cel
 import { MOST_RECENT_REPL_EDITOR, IS_COMPOSITE_NOTEBOOK, NOTEBOOK_CELL_LIST_FOCUSED, NOTEBOOK_EDITOR_FOCUSED } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/notebook/common/notebookContextKeys';
 import { INotebookEditorModelResolverService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/notebook/common/notebookEditorModelResolverService.service';
 import { INotebookService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/notebook/common/notebookService.service';
-import { ReplEditor, isReplEditorControl } from '@codingame/monaco-vscode-katex-common/vscode/vs/workbench/contrib/replNotebook/browser/replEditor';
+import { ReplEditor, isReplEditorControl } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/replNotebook/browser/replEditor';
 import { ReplEditorInputAccessibilityHelp, ReplEditorHistoryAccessibilityHelp } from './replEditorAccessibilityHelp.js';
-import { ReplEditorInput } from '@codingame/monaco-vscode-katex-common/vscode/vs/workbench/contrib/replNotebook/browser/replEditorInput';
+import { ReplEditorInput } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/replNotebook/browser/replEditorInput';
 
 class ReplEditorSerializer {
     canSerialize(input) {
@@ -232,7 +232,7 @@ registerAction2(class extends Action2 {
     constructor() {
         super({
             id: "repl.focusLastItemExecuted",
-            title: ( localize2(15602, "Focus Most Recent REPL Execution")),
+            title: ( localize2(17741, "Focus Most Recent REPL Execution")),
             category: "REPL",
             menu: {
                 id: MenuId.CommandPalette,
@@ -282,7 +282,7 @@ registerAction2(class extends Action2 {
     constructor() {
         super({
             id: "repl.input.focus",
-            title: ( localize2(15603, "Focus Input Editor")),
+            title: ( localize2(17742, "Focus Input Editor")),
             category: "REPL",
             menu: {
                 id: MenuId.CommandPalette,
@@ -327,7 +327,7 @@ registerAction2(class extends Action2 {
     constructor() {
         super({
             id: "repl.execute",
-            title: ( localize2(15604, "Execute REPL input")),
+            title: ( localize2(17743, "Execute REPL input")),
             category: "REPL",
             keybinding: [{
                 when: ( ContextKeyExpr.and(IS_COMPOSITE_NOTEBOOK, ( ContextKeyExpr.equals("activeEditor", "workbench.editor.repl")), ( NOTEBOOK_CELL_LIST_FOCUSED.negate()))),

package/vscode/src/vs/workbench/contrib/replNotebook/browser/replEditorAccessibilityHelp.js

@@ -19,28 +19,28 @@ class ReplEditorInputAccessibilityHelp {
 }
 function getAccessibilityInputHelpText() {
     return [( localize(
-        15606,
+        17745,
         "You are in a REPL Editor Input box which will accept code to be executed in the REPL."
     )), ( localize(
-        15607,
+        17746,
         "The Execute command{0} will evaluate the expression in the input box.",
         "<keybinding:repl.execute>"
     )), ( localize(
-        15608,
+        17747,
         "The setting `accessibility.replEditor.readLastExecutionOutput` controls if output will be automatically read when execution completes."
     )), ( localize(
-        15609,
+        17748,
         "The setting `accessibility.replEditor.autoFocusReplExecution` controls if focus will automatically move to the REPL after executing code."
     )), ( localize(
-        15610,
+        17749,
         "The Focus Last executed command{0} will move focus to the last executed item in the REPL history.",
         "<keybinding:repl.focusLastItemExecuted>"
     )), ( localize(
-        15611,
+        17750,
         "When you run the Open Accessbility View command{0} from this input box, the output from the last execution will be shown in the accessibility view.",
         "<keybinding:editor.action.accessibleView>"
     )), ( localize(
-        15612,
+        17751,
         "The Focus Input Editor command{0} will bring the focus back to this editor.",
         "<keybinding:repl.input.focus>"
     ))].join("\n");
@@ -58,30 +58,30 @@ class ReplEditorHistoryAccessibilityHelp {
 }
 function getAccessibilityHistoryHelpText() {
     return [( localize(
-        15613,
+        17752,
         "You are in a REPL History which is a list of cells that have been executed in the REPL. Each cell has an input, an output, and the cell container."
     )), ( localize(
-        15614,
+        17753,
         "The Edit Cell command{0} will move focus to the read-only editor for the input of the cell.",
         "<keybinding:notebook.cell.edit>"
     )), ( localize(
-        15615,
+        17754,
         "The Quit Edit command{0} will move focus to the cell container, where the up and down arrows will also move focus between cells in the history.",
         "<keybinding:notebook.cell.quitEdit>"
     )), ( localize(
-        15616,
+        17755,
         "Run the Open Accessbility View command{0} while navigating the history for an accessible view of the item's output.",
         "<keybinding:editor.action.accessibleView>"
     )), ( localize(
-        15617,
+        17756,
         "The Focus Output command{0} will set focus on the output when focused on a previously executed item.",
         "<keybinding:notebook.cell.focusInOutput>"
     )), ( localize(
-        15618,
+        17757,
         "The Focus Input Editor command{0} will move focus to the REPL input box.",
         "<keybinding:repl.input.focus>"
     )), ( localize(
-        15610,
+        17749,
         "The Focus Last executed command{0} will move focus to the last executed item in the REPL history.",
         "<keybinding:repl.focusLastItemExecuted>"
     ))].join("\n");

package/vscode/src/vs/workbench/services/workingCopy/common/abstractFileWorkingCopyManager.js

@@ -54,11 +54,11 @@ let BaseFileWorkingCopyManager = class BaseFileWorkingCopyManager extends Dispos
     }
     async destroy() {
         try {
-            await Promises.settled(( this.workingCopies.map(async workingCopy => {
+            await Promises.settled(this.workingCopies.map(async workingCopy => {
                 if (workingCopy.isDirty()) {
                     await this.saveWithFallback(workingCopy);
                 }
-            })));
+            }));
         } catch (error) {
             this.logService.error(error);
         }