aurora-langium 0.0.8 → 0.0.11

package/out/extension/main.cjs

@@ -6719,8 +6719,8 @@ var require_protocolCodeAction = __commonJS({
   "node_modules/vscode-languageclient/lib/common/protocolCodeAction.js"(exports2) {
     "use strict";
     Object.defineProperty(exports2, "__esModule", { value: true });
-    var vscode = require("vscode");
-    var ProtocolCodeAction = class extends vscode.CodeAction {
+    var vscode2 = require("vscode");
+    var ProtocolCodeAction = class extends vscode2.CodeAction {
       constructor(title, data) {
         super(title);
         this.data = data;
@@ -6736,7 +6736,7 @@ var require_protocolDiagnostic = __commonJS({
     "use strict";
     Object.defineProperty(exports2, "__esModule", { value: true });
     exports2.ProtocolDiagnostic = exports2.DiagnosticCode = void 0;
-    var vscode = require("vscode");
+    var vscode2 = require("vscode");
     var Is = require_is();
     var DiagnosticCode;
     (function(DiagnosticCode2) {
@@ -6746,7 +6746,7 @@ var require_protocolDiagnostic = __commonJS({
       }
       DiagnosticCode2.is = is;
     })(DiagnosticCode || (exports2.DiagnosticCode = DiagnosticCode = {}));
-    var ProtocolDiagnostic = class extends vscode.Diagnostic {
+    var ProtocolDiagnostic = class extends vscode2.Diagnostic {
       constructor(range, message, severity, data) {
         super(range, message, severity);
         this.data = data;
@@ -10783,7 +10783,7 @@ var require_notebook = __commonJS({
     "use strict";
     Object.defineProperty(exports2, "__esModule", { value: true });
     exports2.NotebookDocumentSyncFeature = void 0;
-    var vscode = require("vscode");
+    var vscode2 = require("vscode");
     var minimatch = require_minimatch();
     var proto = require_main3();
     var UUID = require_uuid();
@@ -10838,9 +10838,9 @@ var require_notebook = __commonJS({
         c2p2.asNotebookCell = asNotebookCell;
         function asNotebookCellKind(kind) {
           switch (kind) {
-            case vscode.NotebookCellKind.Markup:
+            case vscode2.NotebookCellKind.Markup:
               return proto.NotebookCellKind.Markup;
-            case vscode.NotebookCellKind.Code:
+            case vscode2.NotebookCellKind.Code:
               return proto.NotebookCellKind.Code;
           }
         }
@@ -11092,25 +11092,25 @@ var require_notebook = __commonJS({
         this.notebookDidOpen = /* @__PURE__ */ new Set();
         this.disposables = [];
         this.selector = client2.protocol2CodeConverter.asDocumentSelector($NotebookDocumentSyncOptions.asDocumentSelector(options));
-        vscode.workspace.onDidOpenNotebookDocument((notebookDocument) => {
+        vscode2.workspace.onDidOpenNotebookDocument((notebookDocument) => {
           this.notebookDidOpen.add(notebookDocument.uri.toString());
           this.didOpen(notebookDocument);
         }, void 0, this.disposables);
-        for (const notebookDocument of vscode.workspace.notebookDocuments) {
+        for (const notebookDocument of vscode2.workspace.notebookDocuments) {
           this.notebookDidOpen.add(notebookDocument.uri.toString());
           this.didOpen(notebookDocument);
         }
-        vscode.workspace.onDidChangeNotebookDocument((event) => this.didChangeNotebookDocument(event), void 0, this.disposables);
+        vscode2.workspace.onDidChangeNotebookDocument((event) => this.didChangeNotebookDocument(event), void 0, this.disposables);
         if (this.options.save === true) {
-          vscode.workspace.onDidSaveNotebookDocument((notebookDocument) => this.didSave(notebookDocument), void 0, this.disposables);
+          vscode2.workspace.onDidSaveNotebookDocument((notebookDocument) => this.didSave(notebookDocument), void 0, this.disposables);
         }
-        vscode.workspace.onDidCloseNotebookDocument((notebookDocument) => {
+        vscode2.workspace.onDidCloseNotebookDocument((notebookDocument) => {
           this.didClose(notebookDocument);
           this.notebookDidOpen.delete(notebookDocument.uri.toString());
         }, void 0, this.disposables);
       }
       getState() {
-        for (const notebook of vscode.workspace.notebookDocuments) {
+        for (const notebook of vscode2.workspace.notebookDocuments) {
           const matchingCells = this.getMatchingCells(notebook);
           if (matchingCells !== void 0) {
             return { kind: "document", id: "$internal", registrations: true, matches: true };
@@ -11122,10 +11122,10 @@ var require_notebook = __commonJS({
         return "notebook";
       }
       handles(textDocument) {
-        return vscode.languages.match(this.selector, textDocument) > 0;
+        return vscode2.languages.match(this.selector, textDocument) > 0;
       }
       didOpenNotebookCellTextDocument(notebookDocument, cell) {
-        if (vscode.languages.match(this.selector, cell.document) === 0) {
+        if (vscode2.languages.match(this.selector, cell.document) === 0) {
           return;
         }
         if (!this.notebookDidOpen.has(notebookDocument.uri.toString())) {
@@ -11156,7 +11156,7 @@ var require_notebook = __commonJS({
         }
       }
       didChangeNotebookCellTextDocument(notebookDocument, event) {
-        if (vscode.languages.match(this.selector, event.document) === 0) {
+        if (vscode2.languages.match(this.selector, event.document) === 0) {
           return;
         }
         this.doSendChange({
@@ -11436,7 +11436,7 @@ var require_notebook = __commonJS({
         this.client = client2;
         this.registrations = /* @__PURE__ */ new Map();
         this.registrationType = proto.NotebookDocumentSyncRegistrationType.type;
-        vscode.workspace.onDidOpenTextDocument((textDocument) => {
+        vscode2.workspace.onDidOpenTextDocument((textDocument) => {
           if (textDocument.uri.scheme !== _NotebookDocumentSyncFeature.CellScheme) {
             return;
           }
@@ -11450,7 +11450,7 @@ var require_notebook = __commonJS({
             }
           }
         });
-        vscode.workspace.onDidChangeTextDocument((event) => {
+        vscode2.workspace.onDidChangeTextDocument((event) => {
           if (event.contentChanges.length === 0) {
             return;
           }
@@ -11468,7 +11468,7 @@ var require_notebook = __commonJS({
             }
           }
         });
-        vscode.workspace.onDidCloseTextDocument((textDocument) => {
+        vscode2.workspace.onDidCloseTextDocument((textDocument) => {
           if (textDocument.uri.scheme !== _NotebookDocumentSyncFeature.CellScheme) {
             return;
           }
@@ -11534,7 +11534,7 @@ var require_notebook = __commonJS({
         if (textDocument.uri.scheme !== _NotebookDocumentSyncFeature.CellScheme) {
           return false;
         }
-        if (this.dedicatedChannel !== void 0 && vscode.languages.match(this.dedicatedChannel, textDocument) > 0) {
+        if (this.dedicatedChannel !== void 0 && vscode2.languages.match(this.dedicatedChannel, textDocument) > 0) {
           return true;
         }
         for (const provider of this.registrations.values()) {
@@ -11554,7 +11554,7 @@ var require_notebook = __commonJS({
       }
       findNotebookDocumentAndCell(textDocument) {
         const uri = textDocument.uri.toString();
-        for (const notebookDocument of vscode.workspace.notebookDocuments) {
+        for (const notebookDocument of vscode2.workspace.notebookDocuments) {
           for (const cell of notebookDocument.getCells()) {
             if (cell.document.uri.toString() === uri) {
               return [notebookDocument, cell];
@@ -14073,7 +14073,7 @@ var require_semanticTokens = __commonJS({
     "use strict";
     Object.defineProperty(exports2, "__esModule", { value: true });
     exports2.SemanticTokensFeature = void 0;
-    var vscode = require("vscode");
+    var vscode2 = require("vscode");
     var vscode_languageserver_protocol_1 = require_main3();
     var features_1 = require_features();
     var Is = require_is();
@@ -14151,7 +14151,7 @@ var require_semanticTokens = __commonJS({
         const selector = options.documentSelector;
         const fullProvider = Is.boolean(options.full) ? options.full : options.full !== void 0;
         const hasEditProvider = options.full !== void 0 && typeof options.full !== "boolean" && options.full.delta === true;
-        const eventEmitter = new vscode.EventEmitter();
+        const eventEmitter = new vscode2.EventEmitter();
         const documentProvider = fullProvider ? {
           onDidChangeSemanticTokens: eventEmitter.event,
           provideDocumentSemanticTokens: (document, token) => {
@@ -14223,12 +14223,12 @@ var require_semanticTokens = __commonJS({
         const legend = client2.protocol2CodeConverter.asSemanticTokensLegend(options.legend);
         const documentSelector = client2.protocol2CodeConverter.asDocumentSelector(selector);
         if (documentProvider !== void 0) {
-          disposables.push(vscode.languages.registerDocumentSemanticTokensProvider(documentSelector, documentProvider, legend));
+          disposables.push(vscode2.languages.registerDocumentSemanticTokensProvider(documentSelector, documentProvider, legend));
         }
         if (rangeProvider !== void 0) {
-          disposables.push(vscode.languages.registerDocumentRangeSemanticTokensProvider(documentSelector, rangeProvider, legend));
+          disposables.push(vscode2.languages.registerDocumentRangeSemanticTokensProvider(documentSelector, rangeProvider, legend));
         }
-        return [new vscode.Disposable(() => disposables.forEach((item) => item.dispose())), { range: rangeProvider, full: documentProvider, onDidChangeSemanticTokensEmitter: eventEmitter }];
+        return [new vscode2.Disposable(() => disposables.forEach((item) => item.dispose())), { range: rangeProvider, full: documentProvider, onDidChangeSemanticTokensEmitter: eventEmitter }];
       }
     };
     exports2.SemanticTokensFeature = SemanticTokensFeature;
@@ -14952,12 +14952,12 @@ var require_client = __commonJS({
       CloseAction2[CloseAction2["DoNotRestart"] = 1] = "DoNotRestart";
       CloseAction2[CloseAction2["Restart"] = 2] = "Restart";
     })(CloseAction || (exports2.CloseAction = CloseAction = {}));
-    var State;
-    (function(State2) {
-      State2[State2["Stopped"] = 1] = "Stopped";
-      State2[State2["Starting"] = 3] = "Starting";
-      State2[State2["Running"] = 2] = "Running";
-    })(State || (exports2.State = State = {}));
+    var State2;
+    (function(State3) {
+      State3[State3["Stopped"] = 1] = "Stopped";
+      State3[State3["Starting"] = 3] = "Starting";
+      State3[State3["Running"] = 2] = "Running";
+    })(State2 || (exports2.State = State2 = {}));
     var SuspendMode;
     (function(SuspendMode2) {
       SuspendMode2["off"] = "off";
@@ -15162,11 +15162,11 @@ var require_client = __commonJS({
       getPublicState() {
         switch (this.$state) {
           case ClientState.Starting:
-            return State.Starting;
+            return State2.Starting;
           case ClientState.Running:
-            return State.Running;
+            return State2.Running;
           default:
-            return State.Stopped;
+            return State2.Stopped;
         }
       }
       get initializeResult() {
@@ -18063,6 +18063,2784 @@ var require_node3 = __commonJS({
   }
 });
 
+// node_modules/sprotty-vscode-protocol/lib/lsp/editing/editing.js
+var require_editing = __commonJS({
+  "node_modules/sprotty-vscode-protocol/lib/lsp/editing/editing.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.DeleteWithWorkspaceEditAction = exports2.WorkspaceEditAction = exports2.LspLabelEditAction = void 0;
+    var LspLabelEditAction;
+    (function(LspLabelEditAction2) {
+      LspLabelEditAction2.KIND = "languageLabelEdit";
+      function is(action) {
+        return action.kind === LspLabelEditAction2.KIND;
+      }
+      LspLabelEditAction2.is = is;
+    })(LspLabelEditAction || (exports2.LspLabelEditAction = LspLabelEditAction = {}));
+    var WorkspaceEditAction;
+    (function(WorkspaceEditAction2) {
+      WorkspaceEditAction2.KIND = "workspaceEdit";
+      function is(action) {
+        return action.kind === WorkspaceEditAction2.KIND;
+      }
+      WorkspaceEditAction2.is = is;
+    })(WorkspaceEditAction || (exports2.WorkspaceEditAction = WorkspaceEditAction = {}));
+    var DeleteWithWorkspaceEditAction;
+    (function(DeleteWithWorkspaceEditAction2) {
+      DeleteWithWorkspaceEditAction2.KIND = "deleteWithWorkspaceEdit";
+      function is(action) {
+        return action.kind === DeleteWithWorkspaceEditAction2.KIND;
+      }
+      DeleteWithWorkspaceEditAction2.is = is;
+    })(DeleteWithWorkspaceEditAction || (exports2.DeleteWithWorkspaceEditAction = DeleteWithWorkspaceEditAction = {}));
+  }
+});
+
+// node_modules/sprotty-vscode-protocol/lib/lsp/editing/index.js
+var require_editing2 = __commonJS({
+  "node_modules/sprotty-vscode-protocol/lib/lsp/editing/index.js"(exports2) {
+    "use strict";
+    var __createBinding = exports2 && exports2.__createBinding || (Object.create ? function(o, m, k, k2) {
+      if (k2 === void 0)
+        k2 = k;
+      var desc = Object.getOwnPropertyDescriptor(m, k);
+      if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+        desc = { enumerable: true, get: function() {
+          return m[k];
+        } };
+      }
+      Object.defineProperty(o, k2, desc);
+    } : function(o, m, k, k2) {
+      if (k2 === void 0)
+        k2 = k;
+      o[k2] = m[k];
+    });
+    var __exportStar = exports2 && exports2.__exportStar || function(m, exports3) {
+      for (var p in m)
+        if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports3, p))
+          __createBinding(exports3, m, p);
+    };
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    __exportStar(require_editing(), exports2);
+  }
+});
+
+// node_modules/sprotty-vscode/lib/default-contributions.js
+var require_default_contributions = __commonJS({
+  "node_modules/sprotty-vscode/lib/default-contributions.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.registerLspEditCommands = exports2.registerTextEditorSync = exports2.registerDefaultCommands = void 0;
+    var editing_1 = require_editing2();
+    var vscode2 = require("vscode");
+    function registerDefaultCommands2(manager, context, options) {
+      function getURI(commandArgs) {
+        if (commandArgs.length > 0 && commandArgs[0] instanceof vscode2.Uri) {
+          return commandArgs[0];
+        }
+        if (vscode2.window.activeTextEditor) {
+          return vscode2.window.activeTextEditor.document.uri;
+        }
+        return void 0;
+      }
+      context.subscriptions.push(vscode2.commands.registerCommand(options.extensionPrefix + ".diagram.open", async (...commandArgs) => {
+        const uri = getURI(commandArgs);
+        if (uri) {
+          manager.openDiagram(uri, { reveal: true });
+        }
+      }));
+      context.subscriptions.push(vscode2.commands.registerCommand(options.extensionPrefix + ".diagram.fit", () => {
+        const activeWebview = manager.findActiveWebview();
+        if (activeWebview) {
+          activeWebview.sendAction({
+            kind: "fit",
+            elementIds: [],
+            animate: true
+          });
+        }
+      }));
+      context.subscriptions.push(vscode2.commands.registerCommand(options.extensionPrefix + ".diagram.center", () => {
+        const activeWebview = manager.findActiveWebview();
+        if (activeWebview) {
+          activeWebview.sendAction({
+            kind: "center",
+            elementIds: [],
+            animate: true
+          });
+        }
+      }));
+      context.subscriptions.push(vscode2.commands.registerCommand(options.extensionPrefix + ".diagram.export", () => {
+        const activeWebview = manager.findActiveWebview();
+        if (activeWebview) {
+          activeWebview.sendAction({
+            kind: "requestExportSvg"
+          });
+        }
+      }));
+    }
+    exports2.registerDefaultCommands = registerDefaultCommands2;
+    function registerTextEditorSync2(manager, context) {
+      context.subscriptions.push(vscode2.window.onDidChangeActiveTextEditor(async (editor) => {
+        if (editor) {
+          manager.openDiagram(editor.document.uri);
+        }
+      }));
+    }
+    exports2.registerTextEditorSync = registerTextEditorSync2;
+    function registerLspEditCommands(manager, context, options) {
+      context.subscriptions.push(vscode2.commands.registerCommand(options.extensionPrefix + ".diagram.delete", () => {
+        const activeWebview = manager.findActiveWebview();
+        if (activeWebview) {
+          activeWebview.sendAction({
+            kind: editing_1.DeleteWithWorkspaceEditAction.KIND
+          });
+        }
+      }));
+    }
+    exports2.registerLspEditCommands = registerLspEditCommands;
+  }
+});
+
+// node_modules/vscode-messenger-common/lib/messages.js
+var require_messages3 = __commonJS({
+  "node_modules/vscode-messenger-common/lib/messages.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.isNotificationMessage = exports2.isResponseMessage = exports2.isRequestMessage = exports2.isMessage = exports2.equalParticipants = exports2.BROADCAST = exports2.isWebviewTypeMessageParticipant = exports2.isWebviewIdMessageParticipant = exports2.HOST_EXTENSION = void 0;
+    exports2.HOST_EXTENSION = { type: "extension" };
+    function isWebviewIdMessageParticipant(participant) {
+      return participant.type === "webview" && typeof participant.webviewId === "string";
+    }
+    exports2.isWebviewIdMessageParticipant = isWebviewIdMessageParticipant;
+    function isWebviewTypeMessageParticipant(participant) {
+      return participant.type === "webview" && typeof participant.webviewType === "string";
+    }
+    exports2.isWebviewTypeMessageParticipant = isWebviewTypeMessageParticipant;
+    exports2.BROADCAST = { type: "broadcast" };
+    function equalParticipants(p1, p2) {
+      if (p1.type === "extension" && p2.type === "extension") {
+        return p1.extensionId === p2.extensionId;
+      }
+      if (p1.type === "webview" && p2.type === "webview") {
+        if (isWebviewIdMessageParticipant(p1) && isWebviewIdMessageParticipant(p2)) {
+          return p1.webviewId === p2.webviewId;
+        }
+        if (isWebviewTypeMessageParticipant(p1) && isWebviewTypeMessageParticipant(p2)) {
+          return p1.webviewType === p2.webviewType;
+        }
+      }
+      return p1.type === p2.type;
+    }
+    exports2.equalParticipants = equalParticipants;
+    function isMessage(obj) {
+      return typeof obj === "object" && obj !== null && typeof obj.receiver === "object";
+    }
+    exports2.isMessage = isMessage;
+    function isRequestMessage(msg) {
+      return !!msg.id && !!msg.method;
+    }
+    exports2.isRequestMessage = isRequestMessage;
+    function isResponseMessage(msg) {
+      return !!msg.id && !msg.method;
+    }
+    exports2.isResponseMessage = isResponseMessage;
+    function isNotificationMessage(msg) {
+      return !msg.id && !!msg.method;
+    }
+    exports2.isNotificationMessage = isNotificationMessage;
+  }
+});
+
+// node_modules/vscode-messenger-common/lib/index.js
+var require_lib = __commonJS({
+  "node_modules/vscode-messenger-common/lib/index.js"(exports2) {
+    "use strict";
+    var __createBinding = exports2 && exports2.__createBinding || (Object.create ? function(o, m, k, k2) {
+      if (k2 === void 0)
+        k2 = k;
+      var desc = Object.getOwnPropertyDescriptor(m, k);
+      if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+        desc = { enumerable: true, get: function() {
+          return m[k];
+        } };
+      }
+      Object.defineProperty(o, k2, desc);
+    } : function(o, m, k, k2) {
+      if (k2 === void 0)
+        k2 = k;
+      o[k2] = m[k];
+    });
+    var __exportStar = exports2 && exports2.__exportStar || function(m, exports3) {
+      for (var p in m)
+        if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports3, p))
+          __createBinding(exports3, m, p);
+    };
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    __exportStar(require_messages3(), exports2);
+  }
+});
+
+// node_modules/vscode-messenger/lib/messenger.js
+var require_messenger = __commonJS({
+  "node_modules/vscode-messenger/lib/messenger.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.Messenger = void 0;
+    var vscode_messenger_common_1 = require_lib();
+    var Messenger2 = class {
+      constructor(options) {
+        this.idProvider = new IdProvider();
+        this.viewTypeRegistry = /* @__PURE__ */ new Map();
+        this.viewRegistry = /* @__PURE__ */ new Map();
+        this.handlerRegistry = /* @__PURE__ */ new Map();
+        this.requests = /* @__PURE__ */ new Map();
+        this.eventListeners = /* @__PURE__ */ new Map();
+        this.nextMsgId = 0;
+        const defaultOptions = {
+          ignoreHiddenViews: true,
+          debugLog: false
+        };
+        this.options = Object.assign(Object.assign({}, defaultOptions), options);
+      }
+      registerWebviewPanel(panel, options = {}) {
+        return this.registerViewContainer(panel, options);
+      }
+      registerWebviewView(view, options = {}) {
+        return this.registerViewContainer(view, options);
+      }
+      registerViewContainer(view, options) {
+        const viewTypeEntry = this.viewTypeRegistry.get(view.viewType);
+        if (viewTypeEntry) {
+          viewTypeEntry.add(view);
+        } else {
+          this.viewTypeRegistry.set(view.viewType, /* @__PURE__ */ new Set([view]));
+        }
+        const viewEntry = {
+          id: this.idProvider.getWebviewId(view),
+          container: view,
+          options
+        };
+        this.viewRegistry.set(viewEntry.id, viewEntry);
+        const viewType = view.viewType;
+        view.onDidDispose(() => {
+          var _a;
+          this.viewRegistry.delete(viewEntry.id);
+          const removed = (_a = this.viewTypeRegistry.get(viewType)) === null || _a === void 0 ? void 0 : _a.delete(view);
+          if (!removed) {
+            this.log(`Attempt to remove non-existing registry entry for View: ${viewEntry.id} (type ${viewType})`, "warn");
+          }
+        });
+        view.webview.onDidReceiveMessage(async (msg) => {
+          if ((0, vscode_messenger_common_1.isMessage)(msg)) {
+            if (!msg.sender) {
+              msg.sender = {
+                type: "webview",
+                webviewId: viewEntry.id,
+                webviewType: view.viewType
+              };
+            }
+            return this.processMessage(msg, (res) => {
+              this.notifyEventListeners(res);
+              return view.webview.postMessage(res);
+            }).catch((err) => this.log(String(err), "error"));
+          }
+        });
+        return {
+          type: "webview",
+          webviewId: viewEntry.id
+        };
+      }
+      /**
+       * Process an incoming message by forwarding it to the respective receiver or handling it with
+       * a locally registered message handler.
+       */
+      async processMessage(msg, responseCallback) {
+        this.notifyEventListeners(msg);
+        if (msg.receiver.type === "extension") {
+          if ((0, vscode_messenger_common_1.isRequestMessage)(msg)) {
+            await this.processRequestMessage(msg, responseCallback);
+          } else if ((0, vscode_messenger_common_1.isNotificationMessage)(msg)) {
+            await this.processNotificationMessage(msg);
+          } else if ((0, vscode_messenger_common_1.isResponseMessage)(msg)) {
+            await this.processResponseMessage(msg);
+          } else {
+            this.log(`Invalid message: ${JSON.stringify(msg)}`, "error");
+          }
+        } else if (msg.receiver.type === "webview") {
+          if ((0, vscode_messenger_common_1.isWebviewIdMessageParticipant)(msg.receiver)) {
+            const receiverView = this.viewRegistry.get(msg.receiver.webviewId);
+            if (receiverView) {
+              const result = await receiverView.container.webview.postMessage(msg);
+              if (!result) {
+                this.log(`Failed to forward message to view: ${msg.receiver.webviewId}`, "error");
+              }
+            } else {
+              this.log(`No webview with id ${msg.receiver.webviewId} is registered.`, "warn");
+            }
+          } else if (msg.receiver.webviewType) {
+            const webViewType = msg.receiver.webviewType;
+            const receiverViews = this.viewTypeRegistry.get(webViewType);
+            if (receiverViews) {
+              receiverViews.forEach(async (view) => {
+                const result = await view.webview.postMessage(msg);
+                if (!result) {
+                  this.log(`Failed to forward message to view: ${webViewType}`, "error");
+                }
+              });
+            } else {
+              this.log(`No webview with type ${webViewType} is registered.`, "warn");
+            }
+          } else {
+            this.log(`A receiver of type 'webview' must specify a 'webviewId' or a 'webviewType': ${JSON.stringify(msg)}`, "error");
+          }
+        } else if (msg.receiver.type === "broadcast") {
+          if ((0, vscode_messenger_common_1.isNotificationMessage)(msg)) {
+            for (const view of this.viewRegistry.values()) {
+              if (view.options.broadcastMethods && view.options.broadcastMethods.indexOf(msg.method) >= 0) {
+                view.container.webview.postMessage(msg);
+              }
+            }
+            await this.processNotificationMessage(msg);
+          } else {
+            this.log(`Only notification messages are allowed for broadcast: ${JSON.stringify(msg)}`, "error");
+          }
+        }
+      }
+      /**
+       * Process an incoming request message with a registered handler.
+       */
+      async processRequestMessage(msg, responseCallback) {
+        this.log(`Host received Request message: ${msg.method} (id ${msg.id})`);
+        const regs = this.handlerRegistry.get(msg.method);
+        if (!regs) {
+          this.log(`Received request with unknown method: ${msg.method}`, "warn");
+          return this.sendErrorResponse(`Unknown method: ${msg.method}`, msg, responseCallback);
+        }
+        const filtered = regs.filter((reg) => !reg.sender || (0, vscode_messenger_common_1.equalParticipants)(reg.sender, msg.sender));
+        if (filtered.length === 0) {
+          this.log(`No request handler for ${msg.method} matching sender: ${participantToString(msg.sender)}`, "warn");
+          return this.sendErrorResponse("No matching request handler", msg, responseCallback);
+        }
+        if (filtered.length > 1) {
+          this.log(`Multiple request handlers for ${msg.method} matching sender: ${participantToString(msg.sender)}`, "warn");
+          return this.sendErrorResponse("Multiple matching request handlers", msg, responseCallback);
+        }
+        try {
+          const result = await filtered[0].handler(msg.params, msg.sender);
+          const response = {
+            id: msg.id,
+            sender: vscode_messenger_common_1.HOST_EXTENSION,
+            receiver: msg.sender,
+            result
+          };
+          const posted = await responseCallback(response);
+          if (!posted) {
+            this.log(`Failed to send result message: ${participantToString(response.receiver)}`, "error");
+          }
+        } catch (error) {
+          this.sendErrorResponse(this.createResponseError(error), msg, responseCallback);
+        }
+      }
+      async sendErrorResponse(error, msg, responseCallback) {
+        const response = {
+          id: msg.id,
+          sender: vscode_messenger_common_1.HOST_EXTENSION,
+          receiver: msg.sender,
+          error: typeof error === "string" ? { message: error } : error
+        };
+        const posted = await responseCallback(response);
+        if (!posted) {
+          this.log(`Failed to send error message: ${participantToString(response.receiver)}`, "error");
+        }
+      }
+      createResponseError(error) {
+        if (error instanceof Error) {
+          return { message: error.message, data: error.stack };
+        } else if (typeof error === "object" && error !== null && typeof error.message === "string") {
+          return { message: error.message, data: error.data };
+        } else {
+          return { message: String(error) };
+        }
+      }
+      /**
+       * Process an incoming notification message with a registered handler.
+       */
+      async processNotificationMessage(msg) {
+        this.log(`Host received Notification message: ${msg.method}`);
+        const regs = this.handlerRegistry.get(msg.method);
+        if (regs) {
+          const filtered = regs.filter((reg) => !reg.sender || (0, vscode_messenger_common_1.equalParticipants)(reg.sender, msg.sender));
+          if (filtered.length > 0) {
+            await Promise.all(filtered.map((reg) => reg.handler(msg.params, msg.sender)));
+          }
+        } else if (msg.receiver.type !== "broadcast") {
+          this.log(`Received notification with unknown method: ${msg.method}`, "warn");
+        }
+      }
+      /**
+       * Process an incoming response message by resolving or rejecting the associated promise.
+       */
+      async processResponseMessage(msg) {
+        this.log(`Host received Response message: ${msg.id} `);
+        const request = this.requests.get(msg.id);
+        if (request) {
+          if (msg.error) {
+            request.reject(msg.error);
+          } else {
+            request.resolve(msg.result);
+          }
+          this.requests.delete(msg.id);
+        } else {
+          this.log(`Received response for untracked message id: ${msg.id} (participant: ${participantToString(msg.sender)})`, "warn");
+        }
+      }
+      onRequest(type, handler, options = {}) {
+        return this.registerHandler(type, handler, options);
+      }
+      onNotification(type, handler, options = {}) {
+        return this.registerHandler(type, handler, options);
+      }
+      registerHandler(type, handler, options) {
+        let handlers = this.handlerRegistry.get(type.method);
+        if (handlers && this.options.uniqueHandlers) {
+          throw new Error(`A message handler is already registered for method ${type.method}.`);
+        }
+        if (!handlers) {
+          handlers = [];
+          this.handlerRegistry.set(type.method, handlers);
+        }
+        const registration = { handler, sender: options.sender };
+        handlers.push(registration);
+        return {
+          dispose: () => {
+            const handlers2 = this.handlerRegistry.get(type.method);
+            if (handlers2) {
+              const index = handlers2.indexOf(registration);
+              if (index >= 0) {
+                handlers2.splice(index, 1);
+                if (handlers2.length === 0) {
+                  this.handlerRegistry.delete(type.method);
+                }
+              }
+            }
+          }
+        };
+      }
+      async sendRequest(type, receiver, params) {
+        if (receiver.type === "extension") {
+          throw new Error("Requests to other extensions are not supported yet.");
+        } else if (receiver.type === "webview") {
+          if ((0, vscode_messenger_common_1.isWebviewIdMessageParticipant)(receiver)) {
+            const receiverView = this.viewRegistry.get(receiver.webviewId);
+            if (receiverView) {
+              return this.sendRequestToWebview(type, receiver, params, receiverView.container);
+            } else {
+              return Promise.reject(new Error(`No webview with id ${receiver.webviewId} is registered.`));
+            }
+          } else if (receiver.webviewType) {
+            const receiverViews = this.viewTypeRegistry.get(receiver.webviewType);
+            if (receiverViews) {
+              const results = Array.from(receiverViews).map((view) => this.sendRequestToWebview(type, receiver, params, view));
+              return Promise.race(results);
+            } else {
+              return Promise.reject(new Error(`No webview with type ${receiver.webviewType} is registered.`));
+            }
+          } else {
+            throw new Error("Unspecified webview receiver: neither webviewId nor webviewType was set.");
+          }
+        } else if (receiver.type === "broadcast") {
+          throw new Error("Only notification messages are allowed for broadcast.");
+        }
+        throw new Error(`Invalid receiver: ${JSON.stringify(receiver)}`);
+      }
+      async sendRequestToWebview(type, receiver, params, view) {
+        var _a;
+        if (!view.visible && this.options.ignoreHiddenViews) {
+          return Promise.reject(new Error(`Skipped request for hidden view: ${participantToString(receiver)}`));
+        }
+        const msgId = this.createMsgId();
+        const result = new Promise((resolve, reject) => {
+          this.requests.set(msgId, { resolve, reject });
+        });
+        const message = {
+          id: msgId,
+          method: type.method,
+          sender: vscode_messenger_common_1.HOST_EXTENSION,
+          receiver,
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          params
+        };
+        this.notifyEventListeners(message);
+        const posted = await view.webview.postMessage(message);
+        if (!posted) {
+          this.log(`Failed to send message to view: ${participantToString(receiver)}`, "error");
+          (_a = this.requests.get(msgId)) === null || _a === void 0 ? void 0 : _a.reject(new Error(`Failed to send message to view: ${participantToString(receiver)}`));
+          this.requests.delete(msgId);
+        }
+        return result;
+      }
+      sendNotification(type, receiver, params) {
+        if (receiver.type === "extension") {
+          throw new Error("Notifications to other extensions are not supported yet.");
+        } else if (receiver.type === "webview") {
+          if ((0, vscode_messenger_common_1.isWebviewIdMessageParticipant)(receiver)) {
+            const receiverView = this.viewRegistry.get(receiver.webviewId);
+            if (receiverView) {
+              this.sendNotificationToWebview(type, receiver, params, receiverView.container).catch((err) => this.log(String(err), "error"));
+            } else {
+              this.log(`No webview with id ${receiver.webviewId} is registered.`, "warn");
+            }
+          } else if (receiver.webviewType) {
+            const receiverViews = this.viewTypeRegistry.get(receiver.webviewType);
+            if (receiverViews) {
+              receiverViews.forEach((view) => {
+                this.sendNotificationToWebview(type, receiver, params, view).catch((err) => this.log(String(err), "error"));
+              });
+            } else {
+              this.log(`No webview with type ${receiver.webviewType} is registered.`, "warn");
+            }
+          } else {
+            throw new Error("Unspecified webview receiver: neither webviewId nor webviewType was set.");
+          }
+        } else if (receiver.type === "broadcast") {
+          for (const view of this.viewRegistry.values()) {
+            if (view.options.broadcastMethods && view.options.broadcastMethods.indexOf(type.method) >= 0) {
+              this.sendNotificationToWebview(type, receiver, params, view.container).catch((err) => this.log(String(err), "error"));
+            }
+          }
+        }
+      }
+      async sendNotificationToWebview(type, receiver, params, view) {
+        if (!view.visible && this.options.ignoreHiddenViews) {
+          this.log(`Skipped notification for hidden view: ${participantToString(receiver)}`, "debug");
+          return;
+        }
+        const message = {
+          method: type.method,
+          sender: vscode_messenger_common_1.HOST_EXTENSION,
+          receiver,
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          params
+        };
+        this.notifyEventListeners(message);
+        const result = await view.webview.postMessage(message);
+        if (!result) {
+          this.log(`Failed to send message to view: ${participantToString(receiver)}`, "error");
+        }
+      }
+      async notifyEventListeners(msg) {
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k;
+        if (this.eventListeners.size > 0) {
+          const event = {
+            type: "unknown",
+            sender: participantToString(msg.sender),
+            receiver: participantToString(msg.receiver),
+            size: 0,
+            timestamp: Date.now()
+          };
+          if ((0, vscode_messenger_common_1.isRequestMessage)(msg)) {
+            event.type = "request";
+            event.id = msg.id;
+            event.method = msg.method;
+            event.parameter = msg.params;
+            event.size = (_b = (_a = JSON.stringify(msg.params)) === null || _a === void 0 ? void 0 : _a.length) !== null && _b !== void 0 ? _b : 0;
+          } else if ((0, vscode_messenger_common_1.isNotificationMessage)(msg)) {
+            event.type = "notification";
+            event.method = msg.method;
+            event.parameter = msg.params;
+            event.size = (_d = (_c = JSON.stringify(msg.params)) === null || _c === void 0 ? void 0 : _c.length) !== null && _d !== void 0 ? _d : 0;
+          } else if ((0, vscode_messenger_common_1.isResponseMessage)(msg)) {
+            event.type = "response";
+            event.id = msg.id;
+            event.size = (_f = (_e = JSON.stringify(msg.result)) === null || _e === void 0 ? void 0 : _e.length) !== null && _f !== void 0 ? _f : 0;
+            if (msg.error) {
+              event.error = ((_g = msg.error) === null || _g === void 0 ? void 0 : _g.message) ? (_h = msg.error) === null || _h === void 0 ? void 0 : _h.message : "No error message provided";
+              if (msg.error.data) {
+                event.size += (_k = (_j = JSON.stringify(msg.error.data)) === null || _j === void 0 ? void 0 : _j.length) !== null && _k !== void 0 ? _k : 0;
+              }
+            }
+          } else {
+            event.error = `Unknown message to ${msg.receiver}`;
+          }
+          this.eventListeners.forEach((options, listener) => {
+            if (!(options === null || options === void 0 ? void 0 : options.withParameterData)) {
+              event.parameter = void 0;
+            }
+            listener(event);
+          });
+        }
+        return Promise.resolve();
+      }
+      /**
+       *  Exposes diagnostic api to be used by message interaction tracking tools.
+       *  True if payload data (parameter, response value) should be added to diagnostic API
+       * @param options Configurations to control the behavior of diagnostic message provider.
+       */
+      diagnosticApi(options) {
+        return {
+          extensionInfo: () => {
+            return {
+              diagnosticListeners: this.eventListeners.size,
+              pendingRequest: this.requests.size,
+              handlers: Array.from(this.handlerRegistry.entries()).map((entry) => {
+                return { method: entry[0], count: entry[1].length };
+              }),
+              webviews: Array.from(this.viewRegistry.entries()).map((entry) => {
+                return { id: entry[0], type: entry[1].container.viewType };
+              })
+            };
+          },
+          addEventListener: (listener) => {
+            this.eventListeners.set(listener, options);
+            return {
+              dispose: () => this.eventListeners.delete(listener)
+            };
+          },
+          removeEventListener: (listener) => this.eventListeners.delete(listener)
+        };
+      }
+      createMsgId() {
+        return "req_" + this.nextMsgId++;
+      }
+      log(text, level = "debug") {
+        switch (level) {
+          case "debug": {
+            if (this.options.debugLog) {
+              console.debug(text);
+            }
+            break;
+          }
+          case "warn": {
+            console.warn(text);
+            break;
+          }
+          case "error": {
+            console.error(text);
+            break;
+          }
+        }
+      }
+    };
+    exports2.Messenger = Messenger2;
+    var IdProvider = class {
+      constructor() {
+        this.counter = 0;
+      }
+      /**
+       * Provide an identifier for the given webview. This should be called only once per webview
+       * instance because the result will be different for every call.
+       */
+      getWebviewId(view) {
+        return view.viewType + "_" + this.counter++;
+      }
+    };
+    function participantToString(participant) {
+      if (!participant) {
+        return "undefined";
+      }
+      switch (participant.type) {
+        case "extension":
+          return "host extension";
+        case "webview":
+          if ((0, vscode_messenger_common_1.isWebviewIdMessageParticipant)(participant)) {
+            return participant.webviewId;
+          } else if (participant.webviewType) {
+            return participant.webviewType;
+          } else {
+            return "unspecified webview";
+          }
+        case "broadcast":
+          return "broadcast";
+      }
+    }
+  }
+});
+
+// node_modules/vscode-messenger/lib/diagnostic-api.js
+var require_diagnostic_api = __commonJS({
+  "node_modules/vscode-messenger/lib/diagnostic-api.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.isMessengerDiagnostic = void 0;
+    function isMessengerDiagnostic(obj) {
+      return typeof obj === "object" && obj !== null && !!obj.extensionInfo && !!obj.addEventListener && !!obj.removeEventListener;
+    }
+    exports2.isMessengerDiagnostic = isMessengerDiagnostic;
+  }
+});
+
+// node_modules/vscode-messenger/lib/index.js
+var require_lib2 = __commonJS({
+  "node_modules/vscode-messenger/lib/index.js"(exports2) {
+    "use strict";
+    var __createBinding = exports2 && exports2.__createBinding || (Object.create ? function(o, m, k, k2) {
+      if (k2 === void 0)
+        k2 = k;
+      var desc = Object.getOwnPropertyDescriptor(m, k);
+      if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+        desc = { enumerable: true, get: function() {
+          return m[k];
+        } };
+      }
+      Object.defineProperty(o, k2, desc);
+    } : function(o, m, k, k2) {
+      if (k2 === void 0)
+        k2 = k;
+      o[k2] = m[k];
+    });
+    var __exportStar = exports2 && exports2.__exportStar || function(m, exports3) {
+      for (var p in m)
+        if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports3, p))
+          __createBinding(exports3, m, p);
+    };
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    __exportStar(require_messenger(), exports2);
+    __exportStar(require_diagnostic_api(), exports2);
+  }
+});
+
+// node_modules/sprotty-protocol/lib/action-handler.js
+var require_action_handler = __commonJS({
+  "node_modules/sprotty-protocol/lib/action-handler.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.ServerActionHandlerRegistry = void 0;
+    var ServerActionHandlerRegistry = class {
+      constructor() {
+        this.handlers = /* @__PURE__ */ new Map();
+      }
+      /**
+       * Returns the action handlers for the given action kind, or `undefined` if there are none.
+       */
+      getHandler(kind) {
+        return this.handlers.get(kind);
+      }
+      /**
+       * Add an action handler to be called when an action of the specified kind is received.
+       */
+      onAction(kind, handler) {
+        if (this.handlers.has(kind)) {
+          this.handlers.get(kind).push(handler);
+        } else {
+          this.handlers.set(kind, [handler]);
+        }
+      }
+      /**
+       * Remove an action handler that was previously added with `onAction`.
+       */
+      removeActionHandler(kind, handler) {
+        const list = this.handlers.get(kind);
+        if (list) {
+          const index = list.indexOf(handler);
+          if (index >= 0) {
+            list.splice(index, 1);
+          }
+        }
+      }
+    };
+    exports2.ServerActionHandlerRegistry = ServerActionHandlerRegistry;
+  }
+});
+
+// node_modules/sprotty-protocol/lib/utils/object.js
+var require_object = __commonJS({
+  "node_modules/sprotty-protocol/lib/utils/object.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.safeAssign = exports2.hasOwnProperty = exports2.isObject = void 0;
+    function isObject(data) {
+      return typeof data === "object" && data !== null;
+    }
+    exports2.isObject = isObject;
+    function hasOwnProperty(arg, key, type) {
+      if (!isObject(arg)) {
+        return false;
+      }
+      if (Array.isArray(key)) {
+        for (const k of key) {
+          if (!Object.prototype.hasOwnProperty.call(arg, k)) {
+            return false;
+          }
+          if (typeof type === "string" && typeof arg[k] !== type) {
+            return false;
+          } else if (typeof type === "function" && !type(arg[k])) {
+            return false;
+          }
+        }
+      } else {
+        if (!Object.prototype.hasOwnProperty.call(arg, key)) {
+          return false;
+        }
+        if (typeof type === "string") {
+          return typeof arg[key] === type;
+        }
+        if (typeof type === "function") {
+          return type(arg[key]);
+        }
+      }
+      return true;
+    }
+    exports2.hasOwnProperty = hasOwnProperty;
+    function safeAssign(target, partial) {
+      return Object.assign(target, partial);
+    }
+    exports2.safeAssign = safeAssign;
+  }
+});
+
+// node_modules/sprotty-protocol/lib/actions.js
+var require_actions = __commonJS({
+  "node_modules/sprotty-protocol/lib/actions.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.ReconnectAction = exports2.ApplyLabelEditAction = exports2.DeleteElementAction = exports2.CreateElementAction = exports2.ExportSvgAction = exports2.RequestExportSvgAction = exports2.HoverFeedbackAction = exports2.MoveAction = exports2.RedoAction = exports2.UndoAction = exports2.BringToFrontAction = exports2.ViewportResult = exports2.GetViewportAction = exports2.SetViewportAction = exports2.FitToScreenAction = exports2.CenterAction = exports2.LayoutAction = exports2.OpenAction = exports2.CollapseExpandAllAction = exports2.CollapseExpandAction = exports2.SelectionResult = exports2.GetSelectionAction = exports2.SelectAllAction = exports2.SelectAction = exports2.LoggingAction = exports2.ComputedBoundsAction = exports2.RequestBoundsAction = exports2.SetBoundsAction = exports2.SetPopupModelAction = exports2.RequestPopupModelAction = exports2.UpdateModelAction = exports2.SetModelAction = exports2.RequestModelAction = exports2.RejectAction = exports2.isResponseAction = exports2.setRequestContext = exports2.generateRequestId = exports2.isRequestAction = exports2.isAction = exports2.isActionMessage = void 0;
+    var object_1 = require_object();
+    function isActionMessage(object) {
+      return (0, object_1.hasOwnProperty)(object, "action");
+    }
+    exports2.isActionMessage = isActionMessage;
+    function isAction(object) {
+      return (0, object_1.hasOwnProperty)(object, "kind", "string");
+    }
+    exports2.isAction = isAction;
+    function isRequestAction(object) {
+      return (0, object_1.hasOwnProperty)(object, "requestId", "string");
+    }
+    exports2.isRequestAction = isRequestAction;
+    var requestContext = "";
+    var nextRequestId = 1;
+    function generateRequestId() {
+      return `${requestContext}_${nextRequestId++}`;
+    }
+    exports2.generateRequestId = generateRequestId;
+    function setRequestContext(context) {
+      requestContext = context;
+    }
+    exports2.setRequestContext = setRequestContext;
+    function isResponseAction(object) {
+      return (0, object_1.hasOwnProperty)(object, "responseId", "string") && object.responseId !== "";
+    }
+    exports2.isResponseAction = isResponseAction;
+    var RejectAction;
+    (function(RejectAction2) {
+      RejectAction2.KIND = "rejectRequest";
+      function create(options) {
+        return {
+          kind: RejectAction2.KIND,
+          message: options.message,
+          detail: options.detail,
+          responseId: options.requestId
+        };
+      }
+      RejectAction2.create = create;
+    })(RejectAction || (exports2.RejectAction = RejectAction = {}));
+    var RequestModelAction;
+    (function(RequestModelAction2) {
+      RequestModelAction2.KIND = "requestModel";
+      function create(options) {
+        return {
+          kind: RequestModelAction2.KIND,
+          options,
+          requestId: generateRequestId()
+        };
+      }
+      RequestModelAction2.create = create;
+    })(RequestModelAction || (exports2.RequestModelAction = RequestModelAction = {}));
+    var SetModelAction;
+    (function(SetModelAction2) {
+      SetModelAction2.KIND = "setModel";
+      function create(newRoot, requestId = "") {
+        return {
+          kind: SetModelAction2.KIND,
+          newRoot,
+          responseId: requestId
+        };
+      }
+      SetModelAction2.create = create;
+    })(SetModelAction || (exports2.SetModelAction = SetModelAction = {}));
+    var UpdateModelAction;
+    (function(UpdateModelAction2) {
+      UpdateModelAction2.KIND = "updateModel";
+      function create(input, options = {}) {
+        if (Array.isArray(input)) {
+          return {
+            kind: UpdateModelAction2.KIND,
+            matches: input,
+            animate: options.animate,
+            cause: options.cause
+          };
+        } else {
+          return {
+            kind: UpdateModelAction2.KIND,
+            newRoot: input,
+            animate: options.animate,
+            cause: options.cause
+          };
+        }
+      }
+      UpdateModelAction2.create = create;
+    })(UpdateModelAction || (exports2.UpdateModelAction = UpdateModelAction = {}));
+    var RequestPopupModelAction;
+    (function(RequestPopupModelAction2) {
+      RequestPopupModelAction2.KIND = "requestPopupModel";
+      function create(options) {
+        return {
+          kind: RequestPopupModelAction2.KIND,
+          elementId: options.elementId,
+          bounds: options.bounds,
+          requestId: generateRequestId()
+        };
+      }
+      RequestPopupModelAction2.create = create;
+    })(RequestPopupModelAction || (exports2.RequestPopupModelAction = RequestPopupModelAction = {}));
+    var SetPopupModelAction;
+    (function(SetPopupModelAction2) {
+      SetPopupModelAction2.KIND = "setPopupModel";
+      function create(newRoot, requestId = "") {
+        return {
+          kind: SetPopupModelAction2.KIND,
+          newRoot,
+          responseId: requestId
+        };
+      }
+      SetPopupModelAction2.create = create;
+    })(SetPopupModelAction || (exports2.SetPopupModelAction = SetPopupModelAction = {}));
+    var SetBoundsAction;
+    (function(SetBoundsAction2) {
+      SetBoundsAction2.KIND = "setBounds";
+      function create(bounds) {
+        return {
+          kind: SetBoundsAction2.KIND,
+          bounds
+        };
+      }
+      SetBoundsAction2.create = create;
+    })(SetBoundsAction || (exports2.SetBoundsAction = SetBoundsAction = {}));
+    var RequestBoundsAction;
+    (function(RequestBoundsAction2) {
+      RequestBoundsAction2.KIND = "requestBounds";
+      function create(newRoot) {
+        return {
+          kind: RequestBoundsAction2.KIND,
+          newRoot,
+          requestId: generateRequestId()
+        };
+      }
+      RequestBoundsAction2.create = create;
+    })(RequestBoundsAction || (exports2.RequestBoundsAction = RequestBoundsAction = {}));
+    var ComputedBoundsAction;
+    (function(ComputedBoundsAction2) {
+      ComputedBoundsAction2.KIND = "computedBounds";
+      function create(bounds, options = {}) {
+        var _a;
+        return {
+          kind: ComputedBoundsAction2.KIND,
+          bounds,
+          revision: options.revision,
+          alignments: options.alignments,
+          responseId: (_a = options.requestId) !== null && _a !== void 0 ? _a : ""
+        };
+      }
+      ComputedBoundsAction2.create = create;
+    })(ComputedBoundsAction || (exports2.ComputedBoundsAction = ComputedBoundsAction = {}));
+    var LoggingAction;
+    (function(LoggingAction2) {
+      LoggingAction2.KIND = "logging";
+      function create(options) {
+        return Object.assign({ kind: LoggingAction2.KIND }, options);
+      }
+      LoggingAction2.create = create;
+    })(LoggingAction || (exports2.LoggingAction = LoggingAction = {}));
+    var SelectAction;
+    (function(SelectAction2) {
+      SelectAction2.KIND = "elementSelected";
+      function create(options) {
+        var _a, _b;
+        return {
+          kind: SelectAction2.KIND,
+          selectedElementsIDs: (_a = options.selectedElementsIDs) !== null && _a !== void 0 ? _a : [],
+          deselectedElementsIDs: (_b = options.deselectedElementsIDs) !== null && _b !== void 0 ? _b : []
+        };
+      }
+      SelectAction2.create = create;
+    })(SelectAction || (exports2.SelectAction = SelectAction = {}));
+    var SelectAllAction;
+    (function(SelectAllAction2) {
+      SelectAllAction2.KIND = "allSelected";
+      function create(options = {}) {
+        var _a;
+        return {
+          kind: SelectAllAction2.KIND,
+          select: (_a = options.select) !== null && _a !== void 0 ? _a : true
+        };
+      }
+      SelectAllAction2.create = create;
+    })(SelectAllAction || (exports2.SelectAllAction = SelectAllAction = {}));
+    var GetSelectionAction;
+    (function(GetSelectionAction2) {
+      GetSelectionAction2.KIND = "getSelection";
+      function create() {
+        return {
+          kind: GetSelectionAction2.KIND,
+          requestId: generateRequestId()
+        };
+      }
+      GetSelectionAction2.create = create;
+    })(GetSelectionAction || (exports2.GetSelectionAction = GetSelectionAction = {}));
+    var SelectionResult;
+    (function(SelectionResult2) {
+      SelectionResult2.KIND = "selectionResult";
+      function create(selectedElementsIDs, requestId) {
+        return {
+          kind: SelectionResult2.KIND,
+          selectedElementsIDs,
+          responseId: requestId
+        };
+      }
+      SelectionResult2.create = create;
+    })(SelectionResult || (exports2.SelectionResult = SelectionResult = {}));
+    var CollapseExpandAction;
+    (function(CollapseExpandAction2) {
+      CollapseExpandAction2.KIND = "collapseExpand";
+      function create(options) {
+        var _a, _b;
+        return {
+          kind: CollapseExpandAction2.KIND,
+          expandIds: (_a = options.expandIds) !== null && _a !== void 0 ? _a : [],
+          collapseIds: (_b = options.collapseIds) !== null && _b !== void 0 ? _b : []
+        };
+      }
+      CollapseExpandAction2.create = create;
+    })(CollapseExpandAction || (exports2.CollapseExpandAction = CollapseExpandAction = {}));
+    var CollapseExpandAllAction;
+    (function(CollapseExpandAllAction2) {
+      CollapseExpandAllAction2.KIND = "collapseExpandAll";
+      function create(options = {}) {
+        var _a;
+        return {
+          kind: CollapseExpandAllAction2.KIND,
+          expand: (_a = options.expand) !== null && _a !== void 0 ? _a : true
+        };
+      }
+      CollapseExpandAllAction2.create = create;
+    })(CollapseExpandAllAction || (exports2.CollapseExpandAllAction = CollapseExpandAllAction = {}));
+    var OpenAction;
+    (function(OpenAction2) {
+      OpenAction2.KIND = "open";
+      function create(elementId) {
+        return {
+          kind: OpenAction2.KIND,
+          elementId
+        };
+      }
+      OpenAction2.create = create;
+    })(OpenAction || (exports2.OpenAction = OpenAction = {}));
+    var LayoutAction;
+    (function(LayoutAction2) {
+      LayoutAction2.KIND = "layout";
+      function create(options = {}) {
+        return {
+          kind: LayoutAction2.KIND,
+          layoutType: options.layoutType,
+          elementIds: options.elementIds
+        };
+      }
+      LayoutAction2.create = create;
+    })(LayoutAction || (exports2.LayoutAction = LayoutAction = {}));
+    var CenterAction;
+    (function(CenterAction2) {
+      CenterAction2.KIND = "center";
+      function create(elementIds, options = {}) {
+        var _a, _b;
+        return {
+          kind: CenterAction2.KIND,
+          elementIds,
+          animate: (_a = options.animate) !== null && _a !== void 0 ? _a : true,
+          retainZoom: (_b = options.retainZoom) !== null && _b !== void 0 ? _b : false,
+          zoomScale: options.zoomScale
+        };
+      }
+      CenterAction2.create = create;
+    })(CenterAction || (exports2.CenterAction = CenterAction = {}));
+    var FitToScreenAction;
+    (function(FitToScreenAction2) {
+      FitToScreenAction2.KIND = "fit";
+      function create(elementIds, options = {}) {
+        var _a;
+        return {
+          kind: FitToScreenAction2.KIND,
+          elementIds,
+          padding: options.padding,
+          maxZoom: options.maxZoom,
+          animate: (_a = options.animate) !== null && _a !== void 0 ? _a : true
+        };
+      }
+      FitToScreenAction2.create = create;
+    })(FitToScreenAction || (exports2.FitToScreenAction = FitToScreenAction = {}));
+    var SetViewportAction;
+    (function(SetViewportAction2) {
+      SetViewportAction2.KIND = "viewport";
+      function create(elementId, newViewport, options = {}) {
+        var _a;
+        return {
+          kind: SetViewportAction2.KIND,
+          elementId,
+          newViewport,
+          animate: (_a = options.animate) !== null && _a !== void 0 ? _a : true
+        };
+      }
+      SetViewportAction2.create = create;
+    })(SetViewportAction || (exports2.SetViewportAction = SetViewportAction = {}));
+    var GetViewportAction;
+    (function(GetViewportAction2) {
+      GetViewportAction2.KIND = "getViewport";
+      function create() {
+        return {
+          kind: GetViewportAction2.KIND,
+          requestId: generateRequestId()
+        };
+      }
+      GetViewportAction2.create = create;
+    })(GetViewportAction || (exports2.GetViewportAction = GetViewportAction = {}));
+    var ViewportResult;
+    (function(ViewportResult2) {
+      ViewportResult2.KIND = "viewportResult";
+      function create(viewport, canvasBounds, requestId) {
+        return {
+          kind: ViewportResult2.KIND,
+          viewport,
+          canvasBounds,
+          responseId: requestId
+        };
+      }
+      ViewportResult2.create = create;
+    })(ViewportResult || (exports2.ViewportResult = ViewportResult = {}));
+    var BringToFrontAction;
+    (function(BringToFrontAction2) {
+      BringToFrontAction2.KIND = "bringToFront";
+      function create(elementIDs) {
+        return {
+          kind: BringToFrontAction2.KIND,
+          elementIDs
+        };
+      }
+      BringToFrontAction2.create = create;
+    })(BringToFrontAction || (exports2.BringToFrontAction = BringToFrontAction = {}));
+    var UndoAction;
+    (function(UndoAction2) {
+      UndoAction2.KIND = "undo";
+      function create() {
+        return {
+          kind: UndoAction2.KIND
+        };
+      }
+      UndoAction2.create = create;
+    })(UndoAction || (exports2.UndoAction = UndoAction = {}));
+    var RedoAction;
+    (function(RedoAction2) {
+      RedoAction2.KIND = "redo";
+      function create() {
+        return {
+          kind: RedoAction2.KIND
+        };
+      }
+      RedoAction2.create = create;
+    })(RedoAction || (exports2.RedoAction = RedoAction = {}));
+    var MoveAction;
+    (function(MoveAction2) {
+      MoveAction2.KIND = "move";
+      function create(moves, options = {}) {
+        var _a, _b, _c;
+        return {
+          kind: MoveAction2.KIND,
+          moves,
+          animate: (_a = options.animate) !== null && _a !== void 0 ? _a : true,
+          finished: (_b = options.finished) !== null && _b !== void 0 ? _b : false,
+          stoppable: (_c = options.stoppable) !== null && _c !== void 0 ? _c : false
+        };
+      }
+      MoveAction2.create = create;
+    })(MoveAction || (exports2.MoveAction = MoveAction = {}));
+    var HoverFeedbackAction;
+    (function(HoverFeedbackAction2) {
+      HoverFeedbackAction2.KIND = "hoverFeedback";
+      function create(options) {
+        return {
+          kind: HoverFeedbackAction2.KIND,
+          mouseoverElement: options.mouseoverElement,
+          mouseIsOver: options.mouseIsOver
+        };
+      }
+      HoverFeedbackAction2.create = create;
+    })(HoverFeedbackAction || (exports2.HoverFeedbackAction = HoverFeedbackAction = {}));
+    var RequestExportSvgAction;
+    (function(RequestExportSvgAction2) {
+      RequestExportSvgAction2.KIND = "requestExportSvg";
+      function create(options) {
+        return {
+          kind: RequestExportSvgAction2.KIND,
+          requestId: generateRequestId(),
+          options
+        };
+      }
+      RequestExportSvgAction2.create = create;
+    })(RequestExportSvgAction || (exports2.RequestExportSvgAction = RequestExportSvgAction = {}));
+    var ExportSvgAction;
+    (function(ExportSvgAction2) {
+      ExportSvgAction2.KIND = "exportSvg";
+      function create(svg, requestId, options) {
+        return {
+          kind: ExportSvgAction2.KIND,
+          svg,
+          responseId: requestId,
+          options
+        };
+      }
+      ExportSvgAction2.create = create;
+    })(ExportSvgAction || (exports2.ExportSvgAction = ExportSvgAction = {}));
+    var CreateElementAction;
+    (function(CreateElementAction2) {
+      CreateElementAction2.KIND = "createElement";
+      function create(elementSchema, options) {
+        return {
+          kind: CreateElementAction2.KIND,
+          elementSchema,
+          containerId: options.containerId
+        };
+      }
+      CreateElementAction2.create = create;
+    })(CreateElementAction || (exports2.CreateElementAction = CreateElementAction = {}));
+    var DeleteElementAction;
+    (function(DeleteElementAction2) {
+      DeleteElementAction2.KIND = "delete";
+      function create(elementIds) {
+        return {
+          kind: DeleteElementAction2.KIND,
+          elementIds
+        };
+      }
+      DeleteElementAction2.create = create;
+    })(DeleteElementAction || (exports2.DeleteElementAction = DeleteElementAction = {}));
+    var ApplyLabelEditAction;
+    (function(ApplyLabelEditAction2) {
+      ApplyLabelEditAction2.KIND = "applyLabelEdit";
+      function create(labelId, text) {
+        return {
+          kind: ApplyLabelEditAction2.KIND,
+          labelId,
+          text
+        };
+      }
+      ApplyLabelEditAction2.create = create;
+    })(ApplyLabelEditAction || (exports2.ApplyLabelEditAction = ApplyLabelEditAction = {}));
+    var ReconnectAction;
+    (function(ReconnectAction2) {
+      ReconnectAction2.KIND = "reconnect";
+      function create(options) {
+        return {
+          kind: ReconnectAction2.KIND,
+          routableId: options.routableId,
+          newSourceId: options.newSourceId,
+          newTargetId: options.newTargetId
+        };
+      }
+      ReconnectAction2.create = create;
+    })(ReconnectAction || (exports2.ReconnectAction = ReconnectAction = {}));
+  }
+});
+
+// node_modules/sprotty-protocol/lib/utils/async.js
+var require_async2 = __commonJS({
+  "node_modules/sprotty-protocol/lib/utils/async.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.Deferred = void 0;
+    var Deferred = class {
+      constructor() {
+        this._state = "unresolved";
+        this.promise = new Promise((resolve, reject) => {
+          this.resolve = resolve;
+          this.reject = reject;
+        });
+        this.promise.then((res) => this._state = "resolved", (rej) => this._state = "rejected");
+      }
+      set state(state) {
+        if (this._state === "unresolved") {
+          this._state = state;
+        }
+      }
+      get state() {
+        return this._state;
+      }
+    };
+    exports2.Deferred = Deferred;
+  }
+});
+
+// node_modules/sprotty-protocol/lib/utils/model-utils.js
+var require_model_utils = __commonJS({
+  "node_modules/sprotty-protocol/lib/utils/model-utils.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.SModelIndex = exports2.findElement = exports2.getSubType = exports2.getBasicType = exports2.applyBounds = exports2.cloneModel = void 0;
+    function cloneModel(model) {
+      return JSON.parse(JSON.stringify(model));
+    }
+    exports2.cloneModel = cloneModel;
+    function applyBounds(root, action) {
+      const index = new SModelIndex();
+      index.add(root);
+      for (const b of action.bounds) {
+        const element = index.getById(b.elementId);
+        if (element) {
+          const bae = element;
+          if (b.newPosition) {
+            bae.position = { x: b.newPosition.x, y: b.newPosition.y };
+          }
+          if (b.newSize) {
+            bae.size = { width: b.newSize.width, height: b.newSize.height };
+          }
+        }
+      }
+      if (action.alignments) {
+        for (const a of action.alignments) {
+          const element = index.getById(a.elementId);
+          if (element) {
+            const alignable = element;
+            alignable.alignment = { x: a.newAlignment.x, y: a.newAlignment.y };
+          }
+        }
+      }
+    }
+    exports2.applyBounds = applyBounds;
+    function getBasicType(element) {
+      if (!element.type) {
+        return "";
+      }
+      const colonIndex = element.type.indexOf(":");
+      return colonIndex >= 0 ? element.type.substring(0, colonIndex) : element.type;
+    }
+    exports2.getBasicType = getBasicType;
+    function getSubType(schema) {
+      if (!schema.type) {
+        return "";
+      }
+      const colonIndex = schema.type.indexOf(":");
+      return colonIndex >= 0 ? schema.type.substring(colonIndex + 1) : schema.type;
+    }
+    exports2.getSubType = getSubType;
+    function findElement(parent, elementId) {
+      if (parent.id === elementId) {
+        return parent;
+      }
+      if (parent.children) {
+        for (const child of parent.children) {
+          const result = findElement(child, elementId);
+          if (result !== void 0) {
+            return result;
+          }
+        }
+      }
+      return void 0;
+    }
+    exports2.findElement = findElement;
+    var SModelIndex = class {
+      constructor() {
+        this.id2element = /* @__PURE__ */ new Map();
+        this.id2parent = /* @__PURE__ */ new Map();
+      }
+      add(element) {
+        if (!element.id) {
+          throw new Error("Model element has no ID.");
+        } else if (this.contains(element)) {
+          throw new Error("Duplicate ID in model: " + element.id);
+        }
+        this.id2element.set(element.id, element);
+        if (Array.isArray(element.children)) {
+          for (const child of element.children) {
+            this.add(child);
+            this.id2parent.set(child.id, element);
+          }
+        }
+        return this;
+      }
+      remove(element) {
+        this.id2element.delete(element.id);
+        if (Array.isArray(element.children)) {
+          for (const child of element.children) {
+            this.id2parent.delete(child.id);
+            this.remove(child);
+          }
+        }
+        return this;
+      }
+      contains(element) {
+        return this.id2element.has(element.id);
+      }
+      getById(id) {
+        return this.id2element.get(id);
+      }
+      getParent(id) {
+        return this.id2parent.get(id);
+      }
+      getRoot(element) {
+        let current = element;
+        while (current) {
+          const parent = this.id2parent.get(current.id);
+          if (parent === void 0) {
+            return current;
+          }
+          current = parent;
+        }
+        throw new Error("Element has no root");
+      }
+    };
+    exports2.SModelIndex = SModelIndex;
+  }
+});
+
+// node_modules/sprotty-protocol/lib/diagram-server.js
+var require_diagram_server = __commonJS({
+  "node_modules/sprotty-protocol/lib/diagram-server.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.DiagramServer = void 0;
+    var actions_1 = require_actions();
+    var async_1 = require_async2();
+    var model_utils_1 = require_model_utils();
+    var DiagramServer = class {
+      constructor(dispatch, services) {
+        this.state = {
+          currentRoot: {
+            type: "NONE",
+            id: "ROOT"
+          },
+          revision: 0
+        };
+        this.requests = /* @__PURE__ */ new Map();
+        this.dispatch = dispatch;
+        this.diagramGenerator = services.DiagramGenerator;
+        this.layoutEngine = services.ModelLayoutEngine;
+        this.actionHandlerRegistry = services.ServerActionHandlerRegistry;
+      }
+      /**
+       * Set the model and submit it to the client.
+       */
+      setModel(newRoot) {
+        newRoot.revision = ++this.state.revision;
+        this.state.currentRoot = newRoot;
+        return this.submitModel(newRoot, false);
+      }
+      /**
+       * Update the model to a new state and submit it to the client.
+       */
+      updateModel(newRoot) {
+        newRoot.revision = ++this.state.revision;
+        this.state.currentRoot = newRoot;
+        return this.submitModel(newRoot, true);
+      }
+      /**
+       * Whether the client needs to compute the layout of parts of the model. This affects the behavior
+       * of `submitModel`.
+       *
+       * This setting is determined by the `DiagramOptions` that are received with the `RequestModelAction`
+       * from the client. If the client does not specify whether it needs client layout, the default value
+       * is `true`.
+       */
+      get needsClientLayout() {
+        if (this.state.options && this.state.options.needsClientLayout !== void 0) {
+          return !!this.state.options.needsClientLayout;
+        }
+        return true;
+      }
+      /**
+       * Whether the server needs to compute the layout of parts of the model. This affects the behavior
+       * of `submitModel`.
+       *
+       * This setting is determined by the `DiagramOptions` that are received with the `RequestModelAction`
+       * from the client. If the client does not specify whether it needs server layout, the default value
+       * is `false`.
+       */
+      get needsServerLayout() {
+        if (this.state.options && this.state.options.needsServerLayout !== void 0) {
+          return !!this.state.options.needsServerLayout;
+        }
+        return false;
+      }
+      /**
+       * Called when an action is received from the client.
+       */
+      accept(action) {
+        if ((0, actions_1.isResponseAction)(action)) {
+          const id = action.responseId;
+          const future = this.requests.get(id);
+          if (future) {
+            this.requests.delete(id);
+            if (action.kind === actions_1.RejectAction.KIND) {
+              const rejectAction = action;
+              future.reject(new Error(rejectAction.message));
+              console.warn(`Request with id ${action.responseId} failed: ${rejectAction.message}`, rejectAction.detail);
+            } else {
+              future.resolve(action);
+            }
+            return Promise.resolve();
+          }
+          console.info("No matching request for response:", action);
+        }
+        return this.handleAction(action);
+      }
+      /**
+       * Send a request action to the client. The resulting promise is resolved when a matching
+       * response is received and rejected when a `RejectAction` is received.
+       */
+      request(action) {
+        if (!action.requestId) {
+          action.requestId = "server_" + (0, actions_1.generateRequestId)();
+        }
+        const future = new async_1.Deferred();
+        this.requests.set(action.requestId, future);
+        this.dispatch(action).catch((err) => {
+          this.requests.delete(action.requestId);
+          future.reject(err);
+        });
+        return future.promise;
+      }
+      /**
+       * Send a `RejectAction` to the client to notify that a request could not be fulfilled.
+       */
+      rejectRemoteRequest(action, error) {
+        if (action && (0, actions_1.isRequestAction)(action)) {
+          this.dispatch({
+            kind: actions_1.RejectAction.KIND,
+            responseId: action.requestId,
+            message: error.message,
+            detail: error.stack
+          });
+        }
+      }
+      handleAction(action) {
+        var _a, _b;
+        const handlers = (_a = this.actionHandlerRegistry) === null || _a === void 0 ? void 0 : _a.getHandler(action.kind);
+        if (handlers && handlers.length === 1) {
+          return (_b = handlers[0](action, this.state, this)) !== null && _b !== void 0 ? _b : Promise.resolve();
+        } else if (handlers && handlers.length > 1) {
+          return Promise.all(handlers.map((h) => {
+            var _a2;
+            return (_a2 = h(action, this.state, this)) !== null && _a2 !== void 0 ? _a2 : Promise.resolve();
+          }));
+        }
+        switch (action.kind) {
+          case actions_1.RequestModelAction.KIND:
+            return this.handleRequestModel(action);
+          case actions_1.ComputedBoundsAction.KIND:
+            return this.handleComputedBounds(action);
+          case actions_1.LayoutAction.KIND:
+            return this.handleLayout(action);
+        }
+        console.warn(`Unhandled action from client: ${action.kind}`);
+        return Promise.resolve();
+      }
+      async handleRequestModel(action) {
+        var _a;
+        this.state.options = action.options;
+        try {
+          const newRoot = await this.diagramGenerator.generate({
+            options: (_a = this.state.options) !== null && _a !== void 0 ? _a : {},
+            state: this.state
+          });
+          newRoot.revision = ++this.state.revision;
+          this.state.currentRoot = newRoot;
+          await this.submitModel(this.state.currentRoot, false, action);
+        } catch (err) {
+          this.rejectRemoteRequest(action, err);
+          console.error("Failed to generate diagram:", err);
+        }
+      }
+      /**
+       * Submit a model to the client after it has been updated in the server state.
+       */
+      async submitModel(newRoot, update, cause) {
+        if (this.needsClientLayout) {
+          if (!this.needsServerLayout) {
+            this.dispatch({ kind: actions_1.RequestBoundsAction.KIND, newRoot });
+          } else {
+            const request = actions_1.RequestBoundsAction.create(newRoot);
+            const response = await this.request(request);
+            const currentRoot = this.state.currentRoot;
+            if (response.revision === currentRoot.revision) {
+              (0, model_utils_1.applyBounds)(currentRoot, response);
+              await this.doSubmitModel(currentRoot, update, cause);
+            } else {
+              this.rejectRemoteRequest(cause, new Error(`Model revision does not match: ${response.revision}`));
+            }
+          }
+        } else {
+          await this.doSubmitModel(newRoot, update, cause);
+        }
+      }
+      async doSubmitModel(newRoot, update, cause) {
+        if (newRoot.revision !== this.state.revision) {
+          return;
+        }
+        if (this.needsServerLayout && this.layoutEngine) {
+          newRoot = await this.layoutEngine.layout(newRoot);
+        }
+        const modelType = newRoot.type;
+        if (cause && cause.kind === actions_1.RequestModelAction.KIND) {
+          const requestId = cause.requestId;
+          const response = actions_1.SetModelAction.create(newRoot, requestId);
+          await this.dispatch(response);
+        } else if (update && modelType === this.state.lastSubmittedModelType) {
+          await this.dispatch({ kind: actions_1.UpdateModelAction.KIND, newRoot, cause });
+        } else {
+          await this.dispatch({ kind: actions_1.SetModelAction.KIND, newRoot });
+        }
+        this.state.lastSubmittedModelType = modelType;
+      }
+      handleComputedBounds(action) {
+        if (action.revision !== this.state.currentRoot.revision) {
+          return Promise.reject();
+        }
+        (0, model_utils_1.applyBounds)(this.state.currentRoot, action);
+        return Promise.resolve();
+      }
+      async handleLayout(action) {
+        if (!this.layoutEngine) {
+          return;
+        }
+        if (!this.needsServerLayout) {
+          let newRoot = (0, model_utils_1.cloneModel)(this.state.currentRoot);
+          newRoot = await this.layoutEngine.layout(newRoot);
+          newRoot.revision = ++this.state.revision;
+          this.state.currentRoot = newRoot;
+        }
+        await this.doSubmitModel(this.state.currentRoot, true, action);
+      }
+    };
+    exports2.DiagramServer = DiagramServer;
+  }
+});
+
+// node_modules/sprotty-protocol/lib/diagram-services.js
+var require_diagram_services = __commonJS({
+  "node_modules/sprotty-protocol/lib/diagram-services.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+  }
+});
+
+// node_modules/sprotty-protocol/lib/model.js
+var require_model = __commonJS({
+  "node_modules/sprotty-protocol/lib/model.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.isZoomable = exports2.isScrollable = void 0;
+    var object_1 = require_object();
+    function isScrollable(element) {
+      return (0, object_1.hasOwnProperty)(element, "scroll");
+    }
+    exports2.isScrollable = isScrollable;
+    function isZoomable(element) {
+      return (0, object_1.hasOwnProperty)(element, "zoom");
+    }
+    exports2.isZoomable = isZoomable;
+  }
+});
+
+// node_modules/sprotty-protocol/lib/utils/geometry.js
+var require_geometry = __commonJS({
+  "node_modules/sprotty-protocol/lib/utils/geometry.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.almostEquals = exports2.toRadians = exports2.toDegrees = exports2.Bounds = exports2.isBounds = exports2.Dimension = exports2.centerOfLine = exports2.angleBetweenPoints = exports2.angleOfPoint = exports2.Point = void 0;
+    var object_1 = require_object();
+    var Point;
+    (function(Point2) {
+      Point2.ORIGIN = Object.freeze({
+        x: 0,
+        y: 0
+      });
+      function add(p1, p2) {
+        return {
+          x: p1.x + p2.x,
+          y: p1.y + p2.y
+        };
+      }
+      Point2.add = add;
+      function subtract(p1, p2) {
+        return {
+          x: p1.x - p2.x,
+          y: p1.y - p2.y
+        };
+      }
+      Point2.subtract = subtract;
+      function equals(point1, point2) {
+        return point1.x === point2.x && point1.y === point2.y;
+      }
+      Point2.equals = equals;
+      function shiftTowards(point, refPoint, distance) {
+        const diff = subtract(refPoint, point);
+        const normalized = normalize(diff);
+        const shift = { x: normalized.x * distance, y: normalized.y * distance };
+        return add(point, shift);
+      }
+      Point2.shiftTowards = shiftTowards;
+      function normalize(point) {
+        const mag = magnitude(point);
+        if (mag === 0 || mag === 1) {
+          return Point2.ORIGIN;
+        }
+        return {
+          x: point.x / mag,
+          y: point.y / mag
+        };
+      }
+      Point2.normalize = normalize;
+      function magnitude(point) {
+        return Math.sqrt(Math.pow(point.x, 2) + Math.pow(point.y, 2));
+      }
+      Point2.magnitude = magnitude;
+      function linear(p0, p1, lambda) {
+        return {
+          x: (1 - lambda) * p0.x + lambda * p1.x,
+          y: (1 - lambda) * p0.y + lambda * p1.y
+        };
+      }
+      Point2.linear = linear;
+      function euclideanDistance(a, b) {
+        const dx = b.x - a.x;
+        const dy = b.y - a.y;
+        return Math.sqrt(dx * dx + dy * dy);
+      }
+      Point2.euclideanDistance = euclideanDistance;
+      function manhattanDistance(a, b) {
+        return Math.abs(b.x - a.x) + Math.abs(b.y - a.y);
+      }
+      Point2.manhattanDistance = manhattanDistance;
+      function maxDistance(a, b) {
+        return Math.max(Math.abs(b.x - a.x), Math.abs(b.y - a.y));
+      }
+      Point2.maxDistance = maxDistance;
+      function dotProduct(a, b) {
+        return a.x * b.x + a.y * b.y;
+      }
+      Point2.dotProduct = dotProduct;
+    })(Point || (exports2.Point = Point = {}));
+    function angleOfPoint(p) {
+      return Math.atan2(p.y, p.x);
+    }
+    exports2.angleOfPoint = angleOfPoint;
+    function angleBetweenPoints(a, b) {
+      const lengthProduct = Math.sqrt((a.x * a.x + a.y * a.y) * (b.x * b.x + b.y * b.y));
+      if (isNaN(lengthProduct) || lengthProduct === 0)
+        return NaN;
+      const dotProduct = a.x * b.x + a.y * b.y;
+      return Math.acos(dotProduct / lengthProduct);
+    }
+    exports2.angleBetweenPoints = angleBetweenPoints;
+    function centerOfLine(s, e) {
+      const b = {
+        x: s.x > e.x ? e.x : s.x,
+        y: s.y > e.y ? e.y : s.y,
+        width: Math.abs(e.x - s.x),
+        height: Math.abs(e.y - s.y)
+      };
+      return Bounds.center(b);
+    }
+    exports2.centerOfLine = centerOfLine;
+    var Dimension;
+    (function(Dimension2) {
+      Dimension2.EMPTY = Object.freeze({
+        width: -1,
+        height: -1
+      });
+      function isValid(d) {
+        return d.width >= 0 && d.height >= 0;
+      }
+      Dimension2.isValid = isValid;
+    })(Dimension || (exports2.Dimension = Dimension = {}));
+    function isBounds(element) {
+      return (0, object_1.hasOwnProperty)(element, ["x", "y", "width", "height"]);
+    }
+    exports2.isBounds = isBounds;
+    var Bounds;
+    (function(Bounds2) {
+      Bounds2.EMPTY = Object.freeze({
+        x: 0,
+        y: 0,
+        width: -1,
+        height: -1
+      });
+      function combine(b0, b1) {
+        if (!Dimension.isValid(b0))
+          return Dimension.isValid(b1) ? b1 : Bounds2.EMPTY;
+        if (!Dimension.isValid(b1))
+          return b0;
+        const minX = Math.min(b0.x, b1.x);
+        const minY = Math.min(b0.y, b1.y);
+        const maxX = Math.max(b0.x + (b0.width >= 0 ? b0.width : 0), b1.x + (b1.width >= 0 ? b1.width : 0));
+        const maxY = Math.max(b0.y + (b0.height >= 0 ? b0.height : 0), b1.y + (b1.height >= 0 ? b1.height : 0));
+        return {
+          x: minX,
+          y: minY,
+          width: maxX - minX,
+          height: maxY - minY
+        };
+      }
+      Bounds2.combine = combine;
+      function translate(b, p) {
+        return {
+          x: b.x + p.x,
+          y: b.y + p.y,
+          width: b.width,
+          height: b.height
+        };
+      }
+      Bounds2.translate = translate;
+      function center(b) {
+        return {
+          x: b.x + (b.width >= 0 ? 0.5 * b.width : 0),
+          y: b.y + (b.height >= 0 ? 0.5 * b.height : 0)
+        };
+      }
+      Bounds2.center = center;
+      function includes(b, p) {
+        return p.x >= b.x && p.x <= b.x + b.width && p.y >= b.y && p.y <= b.y + b.height;
+      }
+      Bounds2.includes = includes;
+    })(Bounds || (exports2.Bounds = Bounds = {}));
+    function toDegrees(a) {
+      return a * 180 / Math.PI;
+    }
+    exports2.toDegrees = toDegrees;
+    function toRadians(a) {
+      return a * Math.PI / 180;
+    }
+    exports2.toRadians = toRadians;
+    function almostEquals(a, b) {
+      return Math.abs(a - b) < 1e-3;
+    }
+    exports2.almostEquals = almostEquals;
+  }
+});
+
+// node_modules/sprotty-protocol/lib/utils/json.js
+var require_json = __commonJS({
+  "node_modules/sprotty-protocol/lib/utils/json.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+  }
+});
+
+// node_modules/sprotty-protocol/lib/index.js
+var require_lib3 = __commonJS({
+  "node_modules/sprotty-protocol/lib/index.js"(exports2) {
+    "use strict";
+    var __createBinding = exports2 && exports2.__createBinding || (Object.create ? function(o, m, k, k2) {
+      if (k2 === void 0)
+        k2 = k;
+      var desc = Object.getOwnPropertyDescriptor(m, k);
+      if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+        desc = { enumerable: true, get: function() {
+          return m[k];
+        } };
+      }
+      Object.defineProperty(o, k2, desc);
+    } : function(o, m, k, k2) {
+      if (k2 === void 0)
+        k2 = k;
+      o[k2] = m[k];
+    });
+    var __exportStar = exports2 && exports2.__exportStar || function(m, exports3) {
+      for (var p in m)
+        if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports3, p))
+          __createBinding(exports3, m, p);
+    };
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    __exportStar(require_action_handler(), exports2);
+    __exportStar(require_actions(), exports2);
+    __exportStar(require_diagram_server(), exports2);
+    __exportStar(require_diagram_services(), exports2);
+    __exportStar(require_model(), exports2);
+    __exportStar(require_async2(), exports2);
+    __exportStar(require_geometry(), exports2);
+    __exportStar(require_json(), exports2);
+    __exportStar(require_model_utils(), exports2);
+    __exportStar(require_object(), exports2);
+  }
+});
+
+// node_modules/sprotty-vscode-protocol/lib/handshake.js
+var require_handshake = __commonJS({
+  "node_modules/sprotty-vscode-protocol/lib/handshake.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.ActionNotification = exports2.DiagramIdentifierNotification = exports2.SprottyDiagramIdentifier = exports2.WebviewReadyNotification = void 0;
+    exports2.WebviewReadyNotification = { method: "WebviewReadyMessage" };
+    exports2.SprottyDiagramIdentifier = Symbol("SprottyDiagramIdentifier");
+    exports2.DiagramIdentifierNotification = { method: "SprottyDiagramIdentifier" };
+    exports2.ActionNotification = { method: "ActionMessage" };
+  }
+});
+
+// node_modules/sprotty-vscode-protocol/lib/index.js
+var require_lib4 = __commonJS({
+  "node_modules/sprotty-vscode-protocol/lib/index.js"(exports2) {
+    "use strict";
+    var __createBinding = exports2 && exports2.__createBinding || (Object.create ? function(o, m, k, k2) {
+      if (k2 === void 0)
+        k2 = k;
+      var desc = Object.getOwnPropertyDescriptor(m, k);
+      if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+        desc = { enumerable: true, get: function() {
+          return m[k];
+        } };
+      }
+      Object.defineProperty(o, k2, desc);
+    } : function(o, m, k, k2) {
+      if (k2 === void 0)
+        k2 = k;
+      o[k2] = m[k];
+    });
+    var __exportStar = exports2 && exports2.__exportStar || function(m, exports3) {
+      for (var p in m)
+        if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports3, p))
+          __createBinding(exports3, m, p);
+    };
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    __exportStar(require_handshake(), exports2);
+  }
+});
+
+// node_modules/sprotty-vscode/lib/webview-endpoint.js
+var require_webview_endpoint = __commonJS({
+  "node_modules/sprotty-vscode/lib/webview-endpoint.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.WebviewEndpoint = exports2.isWebviewView = exports2.isWebviewPanel = void 0;
+    var sprotty_protocol_1 = require_lib3();
+    var sprotty_vscode_protocol_1 = require_lib4();
+    var vscode2 = require("vscode");
+    function isWebviewPanel(container) {
+      return typeof container.onDidChangeViewState === "function";
+    }
+    exports2.isWebviewPanel = isWebviewPanel;
+    function isWebviewView(container) {
+      return typeof container.onDidChangeVisibility === "function";
+    }
+    exports2.isWebviewView = isWebviewView;
+    var WebviewEndpoint = class {
+      constructor(options) {
+        this.actionHandlers = /* @__PURE__ */ new Map();
+        this.disposables = [];
+        this.webviewReady = new Promise((resolve) => this.resolveWebviewReady = resolve);
+        this.webviewContainer = options.webviewContainer;
+        this.messenger = options.messenger;
+        this.messageParticipant = options.messageParticipant;
+        this.diagramIdentifier = options.identifier;
+        if (options.diagramServer) {
+          this.diagramServer = options.diagramServer;
+        } else if (options.diagramServerFactory) {
+          const dispatch = (action) => this.sendAction(action);
+          this.diagramServer = options.diagramServerFactory(dispatch);
+        }
+        this.connect();
+      }
+      get ready() {
+        return this.webviewReady;
+      }
+      connect() {
+        this.disposables.push(this.webviewContainer.onDidDispose(() => {
+          this.disposables.forEach((disposable) => disposable.dispose());
+        }));
+        if (isWebviewPanel(this.webviewContainer)) {
+          this.disposables.push(this.webviewContainer.onDidChangeViewState((event) => {
+            this.setWebviewActiveContext(event.webviewPanel.active);
+          }));
+        }
+        this.disposables.push(this.messenger.onNotification(sprotty_vscode_protocol_1.ActionNotification, (message) => this.receiveAction(message), { sender: this.messageParticipant }));
+        this.disposables.push(this.messenger.onNotification(sprotty_vscode_protocol_1.WebviewReadyNotification, (message) => {
+          this.resolveWebviewReady();
+          this.sendDiagramIdentifier();
+        }, { sender: this.messageParticipant }));
+      }
+      /**
+       * Enable or disable a context variable to be used in UI contributions in the package.json file.
+       */
+      setWebviewActiveContext(isActive) {
+        if (this.diagramIdentifier) {
+          vscode2.commands.executeCommand("setContext", this.diagramIdentifier.diagramType + "-focused", isActive);
+        }
+      }
+      /**
+       * Trigger loading of new content in the webview. The content is identified by the URI and diagram type.
+       */
+      async reloadContent(newIdentifier) {
+        if (this.diagramIdentifier) {
+          this.diagramIdentifier.uri = newIdentifier.uri;
+          this.diagramIdentifier.diagramType = newIdentifier.diagramType;
+        } else {
+          this.diagramIdentifier = newIdentifier;
+        }
+        await this.sendDiagramIdentifier();
+      }
+      async sendDiagramIdentifier() {
+        await this.ready;
+        if (this.diagramIdentifier) {
+          this.messenger.sendNotification(sprotty_vscode_protocol_1.DiagramIdentifierNotification, this.messageParticipant, this.diagramIdentifier);
+        }
+      }
+      /**
+       * Send an action to the webview to be processed by the Sprotty frontend.
+       */
+      async sendAction(action) {
+        var _a;
+        const message = (0, sprotty_protocol_1.isActionMessage)(action) ? action : {
+          clientId: (_a = this.diagramIdentifier) === null || _a === void 0 ? void 0 : _a.clientId,
+          action
+        };
+        const handlers = this.actionHandlers.get(message.action.kind);
+        if (handlers && handlers.length > 0) {
+          return Promise.all(handlers.map((handler) => handler(message.action)));
+        }
+        this.messenger.sendNotification(sprotty_vscode_protocol_1.ActionNotification, this.messageParticipant, message);
+      }
+      /**
+       * Process an action received from the webview.
+       */
+      receiveAction(message) {
+        const action = message.action;
+        const handlers = this.actionHandlers.get(action.kind);
+        if (handlers && handlers.length > 0) {
+          return Promise.all(handlers.map((handler) => handler(action)));
+        }
+        if (this.diagramServer) {
+          return this.diagramServer.accept(action);
+        }
+        return Promise.resolve();
+      }
+      /**
+       * Add an action handler for actions that are sent or received. If one or more handlers are registered for an
+       * action kind, the corresponding actions are sent to those handlers and are not propagated further.
+       */
+      addActionHandler(kind, handler) {
+        const handlers = this.actionHandlers.get(kind);
+        if (handlers) {
+          handlers.push(handler);
+        } else {
+          this.actionHandlers.set(kind, [handler]);
+        }
+      }
+      /**
+       * Remove a previously registered action handler.
+       */
+      removeActionHandler(kind, handler) {
+        const handlers = this.actionHandlers.get(kind);
+        if (handlers) {
+          const index = handlers.indexOf(handler);
+          if (index >= 0) {
+            handlers.splice(index, 1);
+          }
+        }
+      }
+    };
+    exports2.WebviewEndpoint = WebviewEndpoint;
+  }
+});
+
+// node_modules/sprotty-vscode/lib/webview-utils.js
+var require_webview_utils = __commonJS({
+  "node_modules/sprotty-vscode/lib/webview-utils.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.getExtname = exports2.getBasename = exports2.createFileUri = exports2.createWebviewHtml = exports2.createWebviewTitle = exports2.createWebviewPanel = exports2.serializeUri = void 0;
+    var path2 = require("path");
+    var vscode2 = require("vscode");
+    function serializeUri(uri) {
+      let uriString = uri.toString();
+      const matchDrive = uriString.match(/^file:\/\/\/([a-z])%3A/i);
+      if (matchDrive) {
+        uriString = "file:///" + matchDrive[1] + ":" + uriString.substring(matchDrive[0].length);
+      }
+      return uriString;
+    }
+    exports2.serializeUri = serializeUri;
+    function createWebviewPanel(identifier, options) {
+      const title = createWebviewTitle(identifier);
+      const diagramPanel = vscode2.window.createWebviewPanel(identifier.diagramType || "diagram", title, vscode2.ViewColumn.Beside, {
+        localResourceRoots: options.localResourceRoots,
+        enableScripts: true,
+        retainContextWhenHidden: true
+      });
+      diagramPanel.webview.html = createWebviewHtml(identifier, diagramPanel, {
+        scriptUri: options.scriptUri,
+        cssUri: options.cssUri,
+        title
+      });
+      return diagramPanel;
+    }
+    exports2.createWebviewPanel = createWebviewPanel;
+    function createWebviewTitle(identifier) {
+      if (identifier.uri) {
+        const uri = vscode2.Uri.parse(identifier.uri);
+        return getBasename(uri);
+      } else if (identifier.diagramType) {
+        return identifier.diagramType.charAt(0).toUpperCase() + identifier.diagramType.substring(1);
+      } else {
+        return "Diagram";
+      }
+    }
+    exports2.createWebviewTitle = createWebviewTitle;
+    function createWebviewHtml(identifier, container, options) {
+      const transformUri = (uri) => container.webview.asWebviewUri(uri).toString();
+      return `<!DOCTYPE html>
+<html lang="en">
+    <head>
+        <meta charset="UTF-8">
+        <meta name="viewport" content="width=device-width, height=device-height">
+        ${options.title ? `<title>${options.title}</title>` : ""}
+        ${options.cssUri ? `<link rel="stylesheet" type="text/css" href="${transformUri(options.cssUri)}" />` : ""}
+    </head>
+    <body>
+        <div id="${identifier.clientId}_container" style="height: 100%;"></div>
+        <script src="${transformUri(options.scriptUri)}"></script>
+    </body>
+</html>`;
+    }
+    exports2.createWebviewHtml = createWebviewHtml;
+    function createFileUri2(...segments) {
+      return vscode2.Uri.file(path2.join(...segments));
+    }
+    exports2.createFileUri = createFileUri2;
+    function getBasename(uri) {
+      const slashIndex = uri.path.lastIndexOf("/");
+      return uri.path.substring(slashIndex + 1);
+    }
+    exports2.getBasename = getBasename;
+    function getExtname(uri) {
+      const basename = getBasename(uri);
+      const dotIndex = basename.lastIndexOf(".");
+      if (dotIndex <= 0) {
+        return "";
+      }
+      return basename.substring(dotIndex);
+    }
+    exports2.getExtname = getExtname;
+  }
+});
+
+// node_modules/sprotty-vscode/lib/sprotty-editor-provider.js
+var require_sprotty_editor_provider = __commonJS({
+  "node_modules/sprotty-vscode/lib/sprotty-editor-provider.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.SprottyEditorProvider = void 0;
+    var vscode2 = require("vscode");
+    var vscode_messenger_1 = require_lib2();
+    var webview_endpoint_1 = require_webview_endpoint();
+    var webview_utils_1 = require_webview_utils();
+    var SprottyEditorProvider = class _SprottyEditorProvider {
+      get onDidChangeCustomDocument() {
+        return this.changeEmitter.event;
+      }
+      constructor(options) {
+        var _a;
+        this.options = options;
+        this.changeEmitter = new vscode2.EventEmitter();
+        this.documents = [];
+        this.messenger = (_a = options.messenger) !== null && _a !== void 0 ? _a : new vscode_messenger_1.Messenger();
+      }
+      /**
+       * Find the webview endpoint of a custom editor that is currently active.
+       */
+      findActiveWebview() {
+        for (const document of this.documents) {
+          if (document.endpoint && (0, webview_endpoint_1.isWebviewPanel)(document.endpoint.webviewContainer) && document.endpoint.webviewContainer.active) {
+            return document.endpoint;
+          }
+        }
+        return void 0;
+      }
+      /**
+       * Open a custom editor for the given URI.
+       */
+      async openDiagram(uri, options) {
+        await vscode2.commands.executeCommand("vscode.openWith", uri, this.options.viewType);
+        return void 0;
+      }
+      openCustomDocument(uri, openContext, cancelToken) {
+        const document = {
+          uri,
+          dispose: () => this.disposeDocument(document)
+        };
+        this.documents.push(document);
+        return document;
+      }
+      disposeDocument(document) {
+        const index = this.documents.indexOf(document);
+        if (index >= 0) {
+          this.documents.splice(index, 1);
+        }
+      }
+      async resolveCustomEditor(document, webviewPanel, cancelToken) {
+        const identifier = await this.createDiagramIdentifier(document);
+        if (!identifier) {
+          throw new Error(`Document type not supported: ${document.uri.toString(true)}`);
+        }
+        document.endpoint = this.createEndpoint(identifier, webviewPanel);
+        await this.configureWebview(document, webviewPanel, cancelToken);
+      }
+      createEndpoint(identifier, webviewContainer) {
+        const participant = this.messenger.registerWebviewPanel(webviewContainer);
+        return new webview_endpoint_1.WebviewEndpoint({
+          webviewContainer,
+          messenger: this.messenger,
+          messageParticipant: participant,
+          identifier
+        });
+      }
+      /**
+       * Configure the given webview panel. The default implementation sets `localResourceRoots` to the `pack` subfolder of the extension host
+       * and `scriptUri` to `pack/webview.js`. Please configure your bundler to generate such an output file from the Sprotty webview frontend.
+       * In case you need to use different settings or change the HTML content, you can override this functionality in a subclass.
+       */
+      configureWebview(document, webviewPanel, cancelToken) {
+        var _a;
+        const extensionPath = this.options.extensionUri.fsPath;
+        webviewPanel.webview.options = {
+          localResourceRoots: [(0, webview_utils_1.createFileUri)(extensionPath, "pack")],
+          enableScripts: true
+        };
+        const identifier = (_a = document.endpoint) === null || _a === void 0 ? void 0 : _a.diagramIdentifier;
+        if (identifier) {
+          const scriptUri = (0, webview_utils_1.createFileUri)(extensionPath, "pack", "webview.js");
+          webviewPanel.webview.html = (0, webview_utils_1.createWebviewHtml)(identifier, webviewPanel, { scriptUri });
+        }
+      }
+      async createDiagramIdentifier(document, diagramType) {
+        if (!diagramType) {
+          diagramType = await this.getDiagramType(document.uri);
+          if (!diagramType) {
+            return void 0;
+          }
+        }
+        const clientId = diagramType + "_" + _SprottyEditorProvider.viewCount++;
+        return {
+          diagramType,
+          uri: (0, webview_utils_1.serializeUri)(document.uri),
+          clientId
+        };
+      }
+      /**
+       * Determine a diagram type from the given URI. The default implementation returns the `viewType` of the custom
+       * editor if the URI matches the `supportedFileExtensions` or no file extensions were provided.
+       */
+      getDiagramType(uri) {
+        const extname = (0, webview_utils_1.getExtname)(uri);
+        if (!this.options.supportedFileExtensions || this.options.supportedFileExtensions.includes(extname)) {
+          return this.options.viewType;
+        }
+      }
+      saveCustomDocument(document, cancellation) {
+        return Promise.resolve();
+      }
+      revertCustomDocument(document, cancelToken) {
+        return Promise.resolve();
+      }
+      saveCustomDocumentAs(document, destination, cancelToken) {
+        return Promise.reject("Operation not supported.");
+      }
+      backupCustomDocument(document, context, cancelToken) {
+        return Promise.reject("Operation not supported.");
+      }
+    };
+    exports2.SprottyEditorProvider = SprottyEditorProvider;
+    SprottyEditorProvider.viewCount = 0;
+  }
+});
+
+// node_modules/sprotty-vscode/lib/sprotty-view-provider.js
+var require_sprotty_view_provider = __commonJS({
+  "node_modules/sprotty-vscode/lib/sprotty-view-provider.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.SprottyViewProvider = void 0;
+    var vscode2 = require("vscode");
+    var vscode_messenger_1 = require_lib2();
+    var webview_endpoint_1 = require_webview_endpoint();
+    var webview_utils_1 = require_webview_utils();
+    var SprottyViewProvider = class _SprottyViewProvider {
+      constructor(options) {
+        var _a;
+        this.options = options;
+        this.clientId = options.viewType + "_" + _SprottyViewProvider.viewCount++;
+        this.messenger = (_a = options.messenger) !== null && _a !== void 0 ? _a : new vscode_messenger_1.Messenger();
+      }
+      /**
+       * Returns the webview endpoint of the created view if it is already opened.
+       */
+      findActiveWebview() {
+        return this.endpoint;
+      }
+      /**
+       * Open the given URI in the view if it is already opened. There is currently no way to open the view
+       * programmatically, so this method shows an error message if the view is not opened. The message can
+       * be suppressed with the `quiet` option.
+       */
+      async openDiagram(uri, options = {}) {
+        const identifier = await this.createDiagramIdentifier(uri, options.diagramType);
+        if (!identifier) {
+          return void 0;
+        }
+        const endpoint = this.endpoint;
+        if (endpoint) {
+          endpoint.reloadContent(identifier);
+          if (options.reveal && (0, webview_endpoint_1.isWebviewView)(endpoint.webviewContainer)) {
+            endpoint.webviewContainer.show(options.preserveFocus);
+          }
+        } else {
+          vscode2.commands.executeCommand(`${identifier.diagramType}.focus`);
+        }
+        return endpoint;
+      }
+      async resolveWebviewView(webviewView, context, cancelToken) {
+        if (this.endpoint) {
+          console.warn("Warning: Sprotty webview-view is already resolved.");
+        }
+        let identifier;
+        if (this.options.openActiveEditor) {
+          const editor = vscode2.window.activeTextEditor;
+          if (editor) {
+            identifier = await this.createDiagramIdentifier(editor.document.uri);
+          }
+        }
+        const endpoint = this.createEndpoint(webviewView, identifier);
+        this.configureWebview(webviewView, endpoint, cancelToken);
+        this.endpoint = endpoint;
+        webviewView.onDidDispose(() => this.didCloseWebview(endpoint));
+      }
+      createEndpoint(webviewContainer, identifier) {
+        const participant = this.messenger.registerWebviewView(webviewContainer);
+        return new webview_endpoint_1.WebviewEndpoint({
+          webviewContainer,
+          messenger: this.messenger,
+          messageParticipant: participant,
+          identifier
+        });
+      }
+      /**
+       * Configure the given webview view. The default implementation sets `localResourceRoots` to the `pack` subfolder of the extension host
+       * and `scriptUri` to `pack/webview.js`. Please configure your bundler to generate such an output file from the Sprotty webview frontend.
+       * In case you need to use different settings or change the HTML content, you can override this functionality in a subclass.
+       */
+      configureWebview(webviewView, endpoint, cancelToken) {
+        const extensionPath = this.options.extensionUri.fsPath;
+        webviewView.webview.options = {
+          localResourceRoots: [(0, webview_utils_1.createFileUri)(extensionPath, "pack")],
+          enableScripts: true
+        };
+        let identifier = endpoint.diagramIdentifier;
+        if (!identifier) {
+          identifier = { clientId: this.clientId, diagramType: this.options.viewType, uri: "" };
+        }
+        const scriptUri = (0, webview_utils_1.createFileUri)(extensionPath, "pack", "webview.js");
+        webviewView.webview.html = (0, webview_utils_1.createWebviewHtml)(identifier, webviewView, { scriptUri });
+      }
+      async createDiagramIdentifier(uri, diagramType) {
+        if (!diagramType) {
+          diagramType = await this.getDiagramType(uri);
+          if (!diagramType) {
+            return void 0;
+          }
+        }
+        return {
+          diagramType,
+          uri: (0, webview_utils_1.serializeUri)(uri),
+          clientId: this.clientId
+        };
+      }
+      /**
+       * Determine a diagram type from the given URI. The default implementation returns the `viewType` of the view
+       * if the URI matches the `supportedFileExtensions` or no file extensions were provided.
+       */
+      getDiagramType(uri) {
+        const extname = (0, webview_utils_1.getExtname)(uri);
+        if (!this.options.supportedFileExtensions || this.options.supportedFileExtensions.includes(extname)) {
+          return this.options.viewType;
+        }
+      }
+      didCloseWebview(endpoint) {
+        if (this.endpoint === endpoint) {
+          this.endpoint = void 0;
+        }
+      }
+    };
+    exports2.SprottyViewProvider = SprottyViewProvider;
+    SprottyViewProvider.viewCount = 0;
+  }
+});
+
+// node_modules/sprotty-vscode/lib/webview-panel-manager.js
+var require_webview_panel_manager = __commonJS({
+  "node_modules/sprotty-vscode/lib/webview-panel-manager.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.WebviewPanelManager = void 0;
+    var vscode_messenger_1 = require_lib2();
+    var webview_endpoint_1 = require_webview_endpoint();
+    var webview_utils_1 = require_webview_utils();
+    var WebviewPanelManager = class _WebviewPanelManager {
+      constructor(options) {
+        var _a;
+        this.options = options;
+        this.endpoints = [];
+        this.messenger = (_a = options.messenger) !== null && _a !== void 0 ? _a : new vscode_messenger_1.Messenger();
+      }
+      /**
+       * Find the webview endpoint of a webview panel that is currently active.
+       */
+      findActiveWebview() {
+        for (const endpoint of this.endpoints) {
+          if ((0, webview_endpoint_1.isWebviewPanel)(endpoint.webviewContainer) && endpoint.webviewContainer.active) {
+            return endpoint;
+          }
+        }
+        return void 0;
+      }
+      /**
+       * Open a webview panel for the given URI. Depending on the `singleton` option, this either replaces a
+       * previously opened diagram or creates a new panel.
+       */
+      async openDiagram(uri, options = {}) {
+        const identifier = await this.createDiagramIdentifier(uri, options.diagramType);
+        if (!identifier) {
+          return void 0;
+        }
+        let endpoint = this.options.singleton ? this.endpoints[0] : this.endpoints.find((ep) => {
+          var _a, _b;
+          return ((_a = ep.diagramIdentifier) === null || _a === void 0 ? void 0 : _a.uri) === identifier.uri && ((_b = ep.diagramIdentifier) === null || _b === void 0 ? void 0 : _b.diagramType) === identifier.diagramType;
+        });
+        if (endpoint) {
+          if (endpoint.diagramIdentifier) {
+            identifier.clientId = endpoint.diagramIdentifier.clientId;
+          }
+          endpoint.webviewContainer.title = (0, webview_utils_1.createWebviewTitle)(identifier);
+          endpoint.reloadContent(identifier);
+          if (options.reveal && (0, webview_endpoint_1.isWebviewPanel)(endpoint.webviewContainer)) {
+            endpoint.webviewContainer.reveal(endpoint.webviewContainer.viewColumn, options.preserveFocus);
+          }
+        } else {
+          endpoint = this.createEndpoint(identifier);
+          endpoint.webviewContainer.onDidDispose(() => this.didCloseWebview(endpoint));
+          this.endpoints.push(endpoint);
+        }
+        return endpoint;
+      }
+      createEndpoint(identifier) {
+        const webviewContainer = this.createWebview(identifier);
+        const participant = this.messenger.registerWebviewPanel(webviewContainer);
+        return new webview_endpoint_1.WebviewEndpoint({
+          webviewContainer,
+          messenger: this.messenger,
+          messageParticipant: participant,
+          identifier
+        });
+      }
+      /**
+       * Create and configure a webview panel. The default implementation sets `localResourceRoots` to the `pack` subfolder of the extension
+       * host and `scriptUri` to `pack/webview.js`. Please configure your bundler to generate such an output file from the Sprotty webview
+       * frontend. In case you need to use different settings or change the HTML content, you can override this functionality in a subclass.
+       */
+      createWebview(identifier) {
+        const extensionPath = this.options.extensionUri.fsPath;
+        return (0, webview_utils_1.createWebviewPanel)(identifier, {
+          localResourceRoots: [(0, webview_utils_1.createFileUri)(extensionPath, "pack")],
+          scriptUri: (0, webview_utils_1.createFileUri)(extensionPath, "pack", "webview.js")
+        });
+      }
+      async createDiagramIdentifier(uri, diagramType) {
+        if (!diagramType) {
+          diagramType = await this.getDiagramType(uri);
+          if (!diagramType) {
+            return void 0;
+          }
+        }
+        const clientId = diagramType + "_" + _WebviewPanelManager.viewCount++;
+        return {
+          diagramType,
+          uri: (0, webview_utils_1.serializeUri)(uri),
+          clientId
+        };
+      }
+      /**
+       * Determine a diagram type from the given URI. The default implementation returns the `defaultDiagramType` option
+       * if the URI matches the `supportedFileExtensions` or no file extensions were provided. If no default diagram type
+       * was provided, the file extension is used instead.
+       */
+      getDiagramType(uri) {
+        const extname = (0, webview_utils_1.getExtname)(uri);
+        if (!this.options.supportedFileExtensions || this.options.supportedFileExtensions.includes(extname)) {
+          if (this.options.defaultDiagramType) {
+            return this.options.defaultDiagramType;
+          }
+          if (extname.length >= 2) {
+            return extname.substring(1);
+          }
+        }
+      }
+      didCloseWebview(endpoint) {
+        const index = this.endpoints.indexOf(endpoint);
+        if (index >= 0) {
+          this.endpoints.splice(index, 1);
+        }
+      }
+    };
+    exports2.WebviewPanelManager = WebviewPanelManager;
+    WebviewPanelManager.viewCount = 0;
+  }
+});
+
+// node_modules/sprotty-vscode/lib/index.js
+var require_lib5 = __commonJS({
+  "node_modules/sprotty-vscode/lib/index.js"(exports2) {
+    "use strict";
+    var __createBinding = exports2 && exports2.__createBinding || (Object.create ? function(o, m, k, k2) {
+      if (k2 === void 0)
+        k2 = k;
+      var desc = Object.getOwnPropertyDescriptor(m, k);
+      if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+        desc = { enumerable: true, get: function() {
+          return m[k];
+        } };
+      }
+      Object.defineProperty(o, k2, desc);
+    } : function(o, m, k, k2) {
+      if (k2 === void 0)
+        k2 = k;
+      o[k2] = m[k];
+    });
+    var __exportStar = exports2 && exports2.__exportStar || function(m, exports3) {
+      for (var p in m)
+        if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports3, p))
+          __createBinding(exports3, m, p);
+    };
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    __exportStar(require_default_contributions(), exports2);
+    __exportStar(require_sprotty_editor_provider(), exports2);
+    __exportStar(require_sprotty_view_provider(), exports2);
+    __exportStar(require_webview_endpoint(), exports2);
+    __exportStar(require_webview_panel_manager(), exports2);
+    __exportStar(require_webview_utils(), exports2);
+    __exportStar(require_lib4(), exports2);
+  }
+});
+
+// node_modules/sprotty-vscode/lib/lsp/lsp-utils.js
+var require_lsp_utils = __commonJS({
+  "node_modules/sprotty-vscode/lib/lsp/lsp-utils.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.openInTextEditor = exports2.convertUri = exports2.convertPosition = exports2.convertRange = exports2.convertTextEdit = exports2.convertWorkspaceEdit = void 0;
+    var vscode2 = require("vscode");
+    var lsp = require_main4();
+    function convertWorkspaceEdit(workspaceEdit) {
+      var _a;
+      const result = new vscode2.WorkspaceEdit();
+      const changes = workspaceEdit.changes;
+      if (changes) {
+        for (const uri in changes) {
+          const textEdits = changes[uri];
+          if (Array.isArray(textEdits)) {
+            result.set(convertUri(uri), textEdits.map(convertTextEdit));
+          }
+        }
+      }
+      (_a = workspaceEdit.documentChanges) === null || _a === void 0 ? void 0 : _a.forEach((documentChange) => {
+        if (lsp.TextDocumentEdit.is(documentChange)) {
+          result.set(convertUri(documentChange.textDocument.uri), documentChange.edits.map(convertTextEdit));
+        } else if (lsp.CreateFile.is(documentChange)) {
+          result.createFile(convertUri(documentChange.uri), documentChange.options);
+        } else if (lsp.DeleteFile.is(documentChange)) {
+          result.deleteFile(convertUri(documentChange.uri), documentChange.options);
+        } else if (lsp.RenameFile.is(documentChange)) {
+          result.renameFile(convertUri(documentChange.oldUri), convertUri(documentChange.newUri), documentChange.options);
+        }
+      });
+      return result;
+    }
+    exports2.convertWorkspaceEdit = convertWorkspaceEdit;
+    function convertTextEdit(textEdit) {
+      return new vscode2.TextEdit(convertRange(textEdit.range), textEdit.newText);
+    }
+    exports2.convertTextEdit = convertTextEdit;
+    function convertRange(range) {
+      return new vscode2.Range(convertPosition(range.start), convertPosition(range.end));
+    }
+    exports2.convertRange = convertRange;
+    function convertPosition(position) {
+      return new vscode2.Position(position.line, position.character);
+    }
+    exports2.convertPosition = convertPosition;
+    function convertUri(uri) {
+      return vscode2.Uri.parse(uri);
+    }
+    exports2.convertUri = convertUri;
+    function openInTextEditor(message) {
+      const editor = vscode2.window.visibleTextEditors.find((ed) => ed.document.uri.toString() === message.location.uri);
+      if (editor) {
+        const start = convertPosition(message.location.range.start);
+        const end = convertPosition(message.location.range.end);
+        editor.selection = new vscode2.Selection(start, end);
+        editor.revealRange(editor.selection, vscode2.TextEditorRevealType.InCenter);
+      } else if (message.forceOpen) {
+        vscode2.window.showTextDocument(vscode2.Uri.parse(message.location.uri), {
+          selection: new vscode2.Range(convertPosition(message.location.range.start), convertPosition(message.location.range.end)),
+          viewColumn: vscode2.ViewColumn.One
+        });
+      }
+    }
+    exports2.openInTextEditor = openInTextEditor;
+  }
+});
+
+// node_modules/sprotty-vscode-protocol/lib/lsp/messages.js
+var require_messages4 = __commonJS({
+  "node_modules/sprotty-vscode-protocol/lib/lsp/messages.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.LspRequest = exports2.LspNotification = void 0;
+    exports2.LspNotification = { method: "LspNotification" };
+    exports2.LspRequest = { method: "LspRequest" };
+  }
+});
+
+// node_modules/sprotty-vscode-protocol/lib/lsp/index.js
+var require_lsp = __commonJS({
+  "node_modules/sprotty-vscode-protocol/lib/lsp/index.js"(exports2) {
+    "use strict";
+    var __createBinding = exports2 && exports2.__createBinding || (Object.create ? function(o, m, k, k2) {
+      if (k2 === void 0)
+        k2 = k;
+      var desc = Object.getOwnPropertyDescriptor(m, k);
+      if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+        desc = { enumerable: true, get: function() {
+          return m[k];
+        } };
+      }
+      Object.defineProperty(o, k2, desc);
+    } : function(o, m, k, k2) {
+      if (k2 === void 0)
+        k2 = k;
+      o[k2] = m[k];
+    });
+    var __exportStar = exports2 && exports2.__exportStar || function(m, exports3) {
+      for (var p in m)
+        if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports3, p))
+          __createBinding(exports3, m, p);
+    };
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    __exportStar(require_messages4(), exports2);
+  }
+});
+
+// node_modules/sprotty-vscode/lib/lsp/protocol.js
+var require_protocol2 = __commonJS({
+  "node_modules/sprotty-vscode/lib/lsp/protocol.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.openInTextEditorMessageType = exports2.didCloseMessageType = exports2.acceptMessageType = void 0;
+    var vscode_languageclient_1 = require_main4();
+    exports2.acceptMessageType = new vscode_languageclient_1.NotificationType("diagram/accept");
+    exports2.didCloseMessageType = new vscode_languageclient_1.NotificationType("diagram/didClose");
+    exports2.openInTextEditorMessageType = new vscode_languageclient_1.NotificationType("diagram/openInTextEditor");
+  }
+});
+
+// node_modules/sprotty-vscode/lib/lsp/lsp-webview-endpoint.js
+var require_lsp_webview_endpoint = __commonJS({
+  "node_modules/sprotty-vscode/lib/lsp/lsp-webview-endpoint.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.LspWebviewEndpoint = void 0;
+    var lsp_1 = require_lsp();
+    var webview_endpoint_1 = require_webview_endpoint();
+    var protocol_1 = require_protocol2();
+    var LspWebviewEndpoint = class extends webview_endpoint_1.WebviewEndpoint {
+      constructor(options) {
+        super(options);
+        this.languageClient = options.languageClient;
+      }
+      connect() {
+        super.connect();
+        this.disposables.push(this.messenger.onRequest(lsp_1.LspRequest, async (request) => {
+          const result = request.params === void 0 ? await this.languageClient.sendRequest(request.method) : await this.languageClient.sendRequest(request.method, request.params);
+          const response = {
+            jsonrpc: "2.0",
+            id: request.id,
+            result
+          };
+          return response;
+        }, { sender: this.messageParticipant }));
+        this.disposables.push(this.messenger.onNotification(lsp_1.LspNotification, (notification) => {
+          this.languageClient.sendNotification(notification.method, notification.params);
+        }, { sender: this.messageParticipant }));
+      }
+      async receiveAction(message) {
+        await super.receiveAction(message);
+        await this.languageClient.sendNotification(protocol_1.acceptMessageType, message);
+      }
+    };
+    exports2.LspWebviewEndpoint = LspWebviewEndpoint;
+  }
+});
+
+// node_modules/sprotty-vscode/lib/lsp/lsp-sprotty-view-provider.js
+var require_lsp_sprotty_view_provider = __commonJS({
+  "node_modules/sprotty-vscode/lib/lsp/lsp-sprotty-view-provider.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.LspSprottyViewProvider = void 0;
+    var sprotty_view_provider_1 = require_sprotty_view_provider();
+    var lsp_utils_1 = require_lsp_utils();
+    var lsp_webview_endpoint_1 = require_lsp_webview_endpoint();
+    var protocol_1 = require_protocol2();
+    var LspSprottyViewProvider2 = class extends sprotty_view_provider_1.SprottyViewProvider {
+      constructor(options) {
+        super(options);
+        options.languageClient.onNotification(protocol_1.acceptMessageType, (message) => this.acceptFromLanguageServer(message));
+        options.languageClient.onNotification(protocol_1.openInTextEditorMessageType, (message) => (0, lsp_utils_1.openInTextEditor)(message));
+      }
+      get languageClient() {
+        return this.options.languageClient;
+      }
+      createEndpoint(webviewContainer, identifier) {
+        const participant = this.messenger.registerWebviewView(webviewContainer);
+        return new lsp_webview_endpoint_1.LspWebviewEndpoint({
+          languageClient: this.languageClient,
+          webviewContainer,
+          messenger: this.messenger,
+          messageParticipant: participant,
+          identifier
+        });
+      }
+      didCloseWebview(endpoint) {
+        var _a;
+        super.didCloseWebview(endpoint);
+        try {
+          this.languageClient.sendNotification(protocol_1.didCloseMessageType, (_a = endpoint.diagramIdentifier) === null || _a === void 0 ? void 0 : _a.clientId);
+        } catch (err) {
+        }
+      }
+      acceptFromLanguageServer(message) {
+        if (this.endpoint) {
+          this.endpoint.sendAction(message);
+        }
+      }
+    };
+    exports2.LspSprottyViewProvider = LspSprottyViewProvider2;
+  }
+});
+
 // src/extension/main.ts
 var main_exports = {};
 __export(main_exports, {
@@ -18070,11 +20848,51 @@ __export(main_exports, {
   deactivate: () => deactivate
 });
 module.exports = __toCommonJS(main_exports);
+var vscode = __toESM(require("vscode"), 1);
 var path = __toESM(require("path"), 1);
 var import_node = __toESM(require_node3(), 1);
+var import_sprotty_vscode = __toESM(require_lib5(), 1);
+var import_lsp_sprotty_view_provider = __toESM(require_lsp_sprotty_view_provider(), 1);
+var import_vscode_messenger = __toESM(require_lib2(), 1);
 var client;
+var CustomLspSprottyViewProvider = class extends import_lsp_sprotty_view_provider.LspSprottyViewProvider {
+  createWebview(container) {
+    const webview = container.webview;
+    const localResourceRoots = [(0, import_sprotty_vscode.createFileUri)(this.options.extensionUri.fsPath, "pack", "diagram")];
+    webview.options = {
+      enableScripts: true,
+      localResourceRoots
+    };
+    const identifier = { clientId: "aurora", diagramType: "aurora", uri: "aurora" };
+    webview.html = (0, import_sprotty_vscode.createWebviewHtml)(identifier, container, {
+      scriptUri: (0, import_sprotty_vscode.createFileUri)(this.options.extensionUri.fsPath, "pack", "diagram", "main.js"),
+      cssUri: (0, import_sprotty_vscode.createFileUri)(this.options.extensionUri.fsPath, "pack", "diagram", "main.css")
+    });
+  }
+};
 function activate(context) {
+  console.log("Hello Activation...");
   client = startLanguageClient(context);
+  context.subscriptions.push(
+    vscode.commands.registerCommand("aurora.focus", () => {
+      console.log("Aurora focus command executed");
+    })
+  );
+  const webviewViewProvider = new CustomLspSprottyViewProvider({
+    extensionUri: context.extensionUri,
+    viewType: "aurora",
+    languageClient: client,
+    supportedFileExtensions: [".aurora"],
+    openActiveEditor: true,
+    messenger: new import_vscode_messenger.Messenger({ ignoreHiddenViews: false })
+  });
+  context.subscriptions.push(
+    vscode.window.registerWebviewViewProvider("aurora", webviewViewProvider, {
+      webviewOptions: { retainContextWhenHidden: true }
+    })
+  );
+  (0, import_sprotty_vscode.registerDefaultCommands)(webviewViewProvider, context, { extensionPrefix: "aurora" });
+  (0, import_sprotty_vscode.registerTextEditorSync)(webviewViewProvider, context);
 }
 function deactivate() {
   if (client) {
@@ -18090,7 +20908,15 @@ function startLanguageClient(context) {
     debug: { module: serverModule, transport: import_node.TransportKind.ipc, options: debugOptions }
   };
   const clientOptions = {
-    documentSelector: [{ scheme: "*", language: "aurora" }]
+    documentSelector: [{ scheme: "file", language: "aurora" }],
+    synchronize: {
+      fileEvents: vscode.workspace.createFileSystemWatcher("**/*.aurora")
+    },
+    outputChannel: vscode.window.createOutputChannel("Aurora Language Server"),
+    initializationFailedHandler: (error) => {
+      console.error("Language server initialization failed:", error);
+      return false;
+    }
   };
   const client2 = new import_node.LanguageClient(
     "aurora",
@@ -18098,7 +20924,17 @@ function startLanguageClient(context) {
     serverOptions,
     clientOptions
   );
-  client2.start();
+  client2.start().catch((error) => {
+    console.error("Failed to start language client:", error);
+    vscode.window.showErrorMessage(`Failed to start Aurora language server: ${error.message}`);
+  });
+  context.subscriptions.push(
+    client2.onDidChangeState((event) => {
+      if (event.newState === import_node.State.Stopped) {
+        console.log("Language server stopped");
+      }
+    })
+  );
   return client2;
 }
 // Annotate the CommonJS export names for ESM import in node: